Coverage for mindsdb / integrations / handlers / pypi_handler / api.py: 0%

1from os import path 

2from typing import Collection, Dict 

3 

4import numpy as np 

5import pandas as pd 

6import requests 

7 

8SERVICE_URL = r"https://pypistats.org" 

9API_BASE_URL = path.join(SERVICE_URL, "api/packages/") 

10 

11 

12class PyPI: 

13 def __init__(self, name: str, limit: int = None) -> None: 

14 """initializer method 

15 

16 Args: 

17 name(str): package name 

18 """ 

19 self.name: str = name 

20 self.limit = limit 

21 self.endpoint: str = path.join(API_BASE_URL, name) 

22 

23 def recent(self, period: str = None) -> pd.DataFrame: 

24 """recent endpoint 

25 

26 Args: 

27 period (str, optional): the desired `day` or `week` or `month` period. Defaults to None. 

28 

29 Returns: 

30 pd.DataFrame: pandas dataframe 

31 """ 

32 endpoint: str = path.join(self.endpoint, "recent") 

33 params: Dict = {} 

34 

35 if period: 

36 params["period"] = period 

37 

38 payload = requests.get(endpoint, params=params).json()["data"] 

39 

40 df = self.__to_dataframe(payload, [0]) 

41 

42 return df 

43 

44 def overall(self, mirrors: bool = None) -> pd.DataFrame: 

45 """overall endpoint 

46 

47 Args: 

48 mirrors (bool, optional): filter by mirrors. Defaults to None. 

49 

50 Returns: 

51 pd.DataFrame: pandas dataframe 

52 """ 

53 endpoint: str = path.join(self.endpoint, "overall") 

54 params: Dict = {} 

55 

56 if mirrors is not None: 

57 params["mirrors"] = str(mirrors).lower() 

58 

59 payload = requests.get(endpoint, params=params).json()["data"] 

60 df = self.__to_dataframe(payload, limit=self.limit) 

61 

62 return df 

63 

64 def python_major(self, version: str = None) -> pd.DataFrame: 

65 """python major endpoint 

66 

67 Args: 

68 version (str, optional): filter by the major version number. Defaults to None. 

69 

70 Returns: 

71 pd.DataFrame: pandas dataframe 

72 """ 

73 endpoint: str = path.join(self.endpoint, "python_major") 

74 params: Dict = {} 

75 

76 if version is not None: 

77 params["version"] = version 

78 

79 payload = requests.get(endpoint, params=params).json()["data"] 

80 df = self.__to_dataframe(payload, limit=self.limit) 

81 

82 return df 

83 

84 def python_minor(self, version: str = None) -> pd.DataFrame: 

85 """python minor endpoint 

86 

87 Args: 

88 version (str, optional): filter by the minor.patch version number. Defaults to None. 

89 

90 Returns: 

91 pd.DataFrame: pandas dataframe 

92 """ 

93 endpoint: str = path.join(self.endpoint, "python_minor") 

94 params: Dict = {} 

95 

96 if version is not None: 

97 params["version"] = version 

98 

99 payload = requests.get(endpoint, params=params).json()["data"] 

100 df = self.__to_dataframe(payload, limit=self.limit) 

101 

102 return df 

103 

104 def system(self, os: str = None) -> pd.DataFrame: 

105 """system endpoint 

106 

107 Args: 

108 os (str, optional): filter by the operating system. Defaults to None. 

109 

110 Returns: 

111 pd.DataFrame: pandas dataframe 

112 """ 

113 endpoint: str = path.join(self.endpoint, "system") 

114 params: Dict = {} 

115 

116 if os is not None: 

117 params["os"] = os 

118 

119 payload = requests.get(endpoint, params=params).json()["data"] 

120 df = self.__to_dataframe(payload, limit=self.limit) 

121 

122 return df 

123 

124 @staticmethod 

125 def __to_dataframe( 

126 json_data: Dict, 

127 index: Collection = None, 

128 limit: int = 20, 

129 ) -> pd.DataFrame: 

130 """_summary_ 

131 

132 Args: 

133 json_data (Dict): data 

134 index (Collection, optional): desired index. Defaults to None. 

135 limit (int, optional): limit the output coming from dataframe. Defaults to 20. 

136 

137 Returns: 

138 pd.DataFrame: _description_ 

139 """ 

140 df = pd.DataFrame(json_data, index=index) 

141 df.replace("null", np.nan, inplace=True) 

142 df = df.dropna() 

143 

144 return df.tail(limit) 

145 

146 @classmethod 

147 def is_connected(cls) -> Dict: 

148 try: 

149 _ = requests.get(SERVICE_URL, timeout=5).raise_for_status() 

150 return {"status": True} 

151 except requests.exceptions.RequestException as e: 

152 return {"status": False, "message": e}