Coverage for mindsdb / integrations / handlers / strava_handler / strava_tables.py: 0%

1import pandas as pd 

2 

3from typing import List 

4 

5from mindsdb.integrations.libs.api_handler import APITable 

6from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions 

7from mindsdb.utilities import log 

8 

9from mindsdb_sql_parser import ast 

10 

11 

12logger = log.getLogger(__name__) 

13 

14 

15class StravaAllClubsTable(APITable): 

16 """Strava List all Clubs Table implementation""" 

17 

18 def select(self, query: ast.Select) -> pd.DataFrame: 

19 """Pulls data from the Strava "getLoggedInAthleteClubs" API endpoint 

20 Parameters 

21 ---------- 

22 query : ast.Select 

23 Given SQL SELECT query 

24 Returns 

25 ------- 

26 pd.DataFrame 

27 strava "List Athlete Clubs " matching the query 

28 Raises 

29 ------ 

30 ValueError 

31 If the query contains an unsupported condition 

32 """ 

33 

34 order_by_conditions = {} 

35 

36 if query.order_by and len(query.order_by) > 0: 

37 order_by_conditions["columns"] = [] 

38 order_by_conditions["ascending"] = [] 

39 

40 for an_order in query.order_by: 

41 if an_order.field.parts[0] != "id": 

42 next 

43 if an_order.field.parts[1] in self.get_columns(): 

44 order_by_conditions["columns"].append(an_order.field.parts[1]) 

45 

46 if an_order.direction == "ASC": 

47 order_by_conditions["ascending"].append(True) 

48 else: 

49 order_by_conditions["ascending"].append(False) 

50 else: 

51 raise ValueError( 

52 f"Order by unknown column {an_order.field.parts[1]}" 

53 ) 

54 strava_clubs_df = self.call_strava_allclubs_api() 

55 

56 selected_columns = [] 

57 for target in query.targets: 

58 if isinstance(target, ast.Star): 

59 selected_columns = self.get_columns() 

60 break 

61 elif isinstance(target, ast.Identifier): 

62 selected_columns.append(target.parts[-1]) 

63 else: 

64 raise ValueError(f"Unknown query target {type(target)}") 

65 

66 if len(strava_clubs_df) == 0: 

67 strava_clubs_df = pd.DataFrame([], columns=selected_columns) 

68 else: 

69 strava_clubs_df.columns = self.get_columns() 

70 for col in set(strava_clubs_df.columns).difference(set(selected_columns)): 

71 strava_clubs_df = strava_clubs_df.drop(col, axis=1) 

72 

73 if len(order_by_conditions.get("columns", [])) > 0: 

74 strava_clubs_df = strava_clubs_df.sort_values( 

75 by=order_by_conditions["columns"], 

76 ascending=order_by_conditions["ascending"], 

77 ) 

78 

79 if query.limit: 

80 strava_clubs_df = strava_clubs_df.head(query.limit.value) 

81 

82 return strava_clubs_df 

83 

84 def get_columns(self) -> List[str]: 

85 """Gets all columns to be returned in pandas DataFrame responses 

86 Returns 

87 ------- 

88 List[str] 

89 List of columns 

90 """ 

91 return [ 

92 'id', 

93 'name', 

94 'sport_type', 

95 'city', 

96 'state', 

97 'country', 

98 'member_count', 

99 ] 

100 

101 def call_strava_allclubs_api(self): 

102 """Pulls all the records from the given and returns it select() 

103 

104 Returns 

105 ------- 

106 pd.DataFrame of all the records of the "List Athlete Clubs" API end point 

107 """ 

108 

109 clubs = self.handler.connect().get_athlete_clubs() 

110 

111 club_cols = self.get_columns() 

112 data = [] 

113 

114 for club in clubs: 

115 club_dict = club.dict() 

116 data.append([club_dict.get(x) for x in club_cols]) 

117 

118 all_strava_clubs_df = pd.DataFrame(data, columns=club_cols) 

119 

120 return all_strava_clubs_df 

121 

122 

123class StravaClubActivitesTable(APITable): 

124 """Strava List Club Activities by id Table implementation""" 

125 

126 def select(self, query: ast.Select) -> pd.DataFrame: 

127 """Pulls data from the Strava "List Club Activities " API endpoint 

128 Parameters 

129 ---------- 

130 query : ast.Select 

131 Given SQL SELECT query 

132 Returns 

133 ------- 

134 pd.DataFrame 

135 strava "List Club Activities" matching the query 

136 Raises 

137 ------ 

138 ValueError 

139 If the query contains an unsupported condition 

140 """ 

141 conditions = extract_comparison_conditions(query.where) 

142 

143 order_by_conditions = {} 

144 clubs_kwargs = {} 

145 

146 if query.order_by and len(query.order_by) > 0: 

147 order_by_conditions["columns"] = [] 

148 order_by_conditions["ascending"] = [] 

149 

150 for an_order in query.order_by: 

151 if an_order.field.parts[0] != "id": 

152 next 

153 if an_order.field.parts[1] in self.get_columns(): 

154 order_by_conditions["columns"].append(an_order.field.parts[1]) 

155 

156 if an_order.direction == "ASC": 

157 order_by_conditions["ascending"].append(True) 

158 else: 

159 order_by_conditions["ascending"].append(False) 

160 else: 

161 raise ValueError( 

162 f"Order by unknown column {an_order.field.parts[1]}" 

163 ) 

164 

165 for a_where in conditions: 

166 if a_where[1] == "strava_club_id": 

167 if a_where[0] != "=": 

168 raise ValueError("Unsupported where operation for strava_club_id ") 

169 clubs_kwargs["type"] = a_where[2] 

170 else: 

171 raise ValueError(f"Unsupported where argument {a_where[1]}") 

172 

173 strava_club_activities_df = self.call_strava_clubactivities_api(a_where[2]) 

174 

175 selected_columns = [] 

176 for target in query.targets: 

177 if isinstance(target, ast.Star): 

178 selected_columns = self.get_columns() 

179 break 

180 elif isinstance(target, ast.Identifier): 

181 selected_columns.append(target.parts[-1]) 

182 else: 

183 raise ValueError(f"Unknown query target {type(target)}") 

184 

185 if len(strava_club_activities_df) == 0: 

186 strava_club_activities_df = pd.DataFrame([], columns=selected_columns) 

187 else: 

188 strava_club_activities_df.columns = self.get_columns() 

189 for col in set(strava_club_activities_df.columns).difference(set(selected_columns)): 

190 strava_club_activities_df = strava_club_activities_df.drop(col, axis=1) 

191 

192 if len(order_by_conditions.get("columns", [])) > 0: 

193 strava_club_activities_df = strava_club_activities_df.sort_values( 

194 by=order_by_conditions["columns"], 

195 ascending=order_by_conditions["ascending"], 

196 ) 

197 

198 if query.limit: 

199 strava_club_activities_df = strava_club_activities_df.head(query.limit.value) 

200 

201 return strava_club_activities_df 

202 

203 def get_columns(self) -> List[str]: 

204 """Gets all columns to be returned in pandas DataFrame responses 

205 Returns 

206 ------- 

207 List[str] 

208 List of columns 

209 """ 

210 return [ 

211 'name', 

212 'distance', 

213 'moving_time', 

214 'elapsed_time', 

215 'total_elevation_gain', 

216 'sport_type', 

217 'athlete.firstname', 

218 ] 

219 

220 def call_strava_clubactivities_api(self, club_id): 

221 """Pulls all the records from the given and returns it select() 

222 

223 Returns 

224 ------- 

225 pd.DataFrame of all the records of the "getClubActivitiesById" API end point 

226 """ 

227 

228 club_activities = self.handler.connect().get_club_activities(club_id) 

229 

230 club_cols = self.get_columns() 

231 data = [] 

232 

233 for club in club_activities: 

234 club_dict = club.dict() 

235 data.append([club_dict.get(x) for x in club_cols]) 

236 

237 all_strava_club_activities_df = pd.DataFrame(data, columns=club_cols) 

238 

239 return all_strava_club_activities_df