def get_and_store_routes(user: User, strava_client_id, strava_client_secret): """Retrieves all (summary) activities from the Strava-API and stores them in the DB.""" # TODO: find better place for this function # TODO: Handle API exhaustion user.check_and_refresh(strava_client_id, strava_client_secret) api = swagger_client.ActivitiesApi() api.api_client.configuration.access_token = user.access_token existing_route_ids = [r.id for r in db.session.query(Route).all()] # Pagination: Load new route pages until exhausted page = 1 while True: r = api.get_logged_in_athlete_activities(per_page=100, page=page) # Filter bike-rides and new routes routes = [] for route in r: if route.type == "Ride" and route.id not in existing_route_ids: route = Route.from_summary_activity(route) # Get detailed route and overwrite the summary polyline detailed_route = api.get_activity_by_id(route.id) route.route = detailed_route.map.polyline routes.append(route) if routes: db.session.add_all(routes) page += 1 else: break db.session.commit()
def __init__(self, access_token=None): if access_token is None: access_token = os.getenv('STRAVA_ACCESS_TOKEN') self.configuration = swagger_client.Configuration() self.configuration.access_token = access_token self._api_client = swagger_client.ApiClient(self.configuration) self.athletes_api = swagger_client.AthletesApi(self._api_client) self.activities_api = swagger_client.ActivitiesApi(self._api_client) self.streams_api = swagger_client.StreamsApi(self._api_client)
def swagger_get_activity(token: str, activity_id: int) -> swagger_client.models.detailed_activity: configuration = swagger_client.Configuration() configuration.access_token = token api_instance = swagger_client.ActivitiesApi(swagger_client.ApiClient(configuration)) try: # Get Authenticated Athlete api_response = api_instance.get_activity_by_id(activity_id) return api_response except ApiException as e: print("Exception when calling AthletesApi->getLoggedInAthlete: %s\n" % e) # todo - handle the exception
def list_routes(user_id): """List the last routes.""" user_id = int(user_id) check_and_refresh(app, user_id) api = swagger_client.ActivitiesApi() api.api_client.configuration.access_token = app.config["USERS"][user_id][ "access_token"] r = api.get_logged_in_athlete_activities(per_page=100) response = jsonify(list(map(activity_to_dict, r))) response.headers.add("Access-Control-Allow-Origin", "*") return response
def _update_activity_data(access_token: str, file_path: str, activities: list): """ Update the file and list of detailed activity data with any new activities uploaded to Strava since the last stored activity. Arguments: access_token - An OAuth2 access token for the Strava v3 API. activities - The list of detailed activity data to be updated. """ print('Strava: Checking for new activities') # Create an instance of the Activities API class api_instance = swagger_client.ActivitiesApi() api_instance.api_client.configuration.access_token = access_token # Get the start time of the last stored activity start_time = _get_last_activity_start_time(activities) # Get and store any new activities in pages of 25 page_count = 1 while True: page = api_instance.get_logged_in_athlete_activities(after=start_time, page=page_count, per_page=25) if page: activities_in_page = [] for activity in page: print('Strava: Getting detailed activity data for {}'.format( activity.name)) # Get detailed activity data for each activity in the # page response = api_instance.get_activity_by_id(activity.id) # Convert the detailed activity data into a dictionary # and append it to the list of activity data from the # current page activities_in_page.append(response.to_dict()) # Write the current page of activity data to the Strava # activities file _write_activity_data_to_file(file_path, activities_in_page) # Append the current page of activity data to the master # list of activity data activities += activities_in_page page_count += 1 else: print('Strava: No new activities found') break
def uploadManualActivity(tok, acttype, name, startDate, durationSec, descr, distanceMtrs): api_instance = swagger_client.ActivitiesApi() api_instance.api_client.configuration.access_token = tok api_instance.api_client.set_default_header( 'Content-Type', 'application/x-www-form-urlencoded') try: api_response = api_instance.create_activity(name, acttype, startDate, durationSec, description=descr, distance=distanceMtrs, trainer=0, commute=0) return True except ApiException as e: print("Exception when calling ActivitiesApi->createActivity: %s\n" % e) return False
def swagger_get_activities(token: str, before: int = datetime.now().timestamp(), after: int = 0, page: int = 1, per_page: int = 30, async_req=True) -> list[swagger_client.models.summary_activity.SummaryActivity]: # todo make possible synchronous requests. Now asyc behaviour is hardcoded configuration = swagger_client.Configuration() configuration.access_token = token api_instance = swagger_client.ActivitiesApi(swagger_client.ApiClient(configuration)) def _get_page_of_activities(current_page): try: # List Athlete Activities thread = api_instance.get_logged_in_athlete_activities( async_req=async_req, before=before, after=after, page=current_page, per_page=per_page ) api_response = thread.get() return api_response except ApiException as e: print("Exception when calling ActivitiesApi->getLoggedInAthleteActivities: %s\n" % e) list_activities = [] while True: page_of_activities = _get_page_of_activities(page) if not page_of_activities: break list_activities.extend(page_of_activities) if len(page_of_activities) < 30: break page += 1 return list_activities
from __future__ import print_statement import time import swagger_client from swagger_client.rest import ApiException from pprint import pprint # Configure OAuth2 access token for authorization: strava_oauth swagger_client.configuration.access_token = '750c4ecce9aecec0414bbeb8e295b833a6f7d95a' # create an instance of the API class api_instance = swagger_client.ActivitiesApi() before = 56 # Integer | An epoch timestamp to use for filtering activities that have taken place before a certain time. (optional) after = 56 # Integer | An epoch timestamp to use for filtering activities that have taken place after a certain time. (optional) page = 56 # Integer | Page number. Defaults to 1. (optional) perPage = 56 # Integer | Number of items per page. Defaults to 30. (optional) (default to 30) try: # List Athlete Activities api_response = api_instance.getLoggedInAthleteActivities(before=before, after=after, page=page, perPage=perPage) pprint(api_response) except ApiException as e: print("Exception when calling ActivitiesApi->getLoggedInAthleteActivities: %s\n" % e)
def get_strava(last_date=False): ## Getting log in info config = configparser.ConfigParser() config.read("/home/irarickman/strava.ini") params = { 'client_id': config['strava']['client_id'], 'client_secret': config['strava']['client_secret'], 'code': config['strava']['code'] } auth_url = config['strava']['auth_url'] ref_url = config['strava']['ref_url'] athlete_id = config['strava']['athlete_id'] if not last_date: ## Getting the most recent date last_date = datetime.datetime.strptime( strav.start_date.max().split(' ')[0], "%Y-%m-%d") else: last_date = datetime.datetime.strptime(last_date, "%Y-%m-%d") timestamp = last_date.timestamp() delta = datetime.datetime.now() - last_date date_diff = delta.days + 5 r_auth = requests.post(auth_url, data=params) response = r_auth.json() configuration = swagger_client.Configuration() configuration.access_token = response['access_token'] # create an instance of the API class api_instance = swagger_client.ActivitiesApi( swagger_client.ApiClient(configuration)) if date_diff < 200: try: # Get Authenticated Athlete api_response = api_instance.get_logged_in_athlete_activities( after=timestamp, per_page=date_diff) except ApiException as e: print( "Exception when calling AthletesApi->get_logged_in_athlete: {}\n" .format(e)) else: num_rounds = math.ceil(date_diff / 200) api_response = [] for n in range(num_rounds): if n == num_rounds: page_num = date_diff - (200 * (n - 1)) else: page_num = 200 try: # Get Authenticated Athlete activities = api_instance.get_logged_in_athlete_activities( after=timestamp, page=n + 1, per_page=page_num) except ApiException as e: print( "Exception when calling AthletesApi->get_logged_in_athlete: {}\n" .format(e)) api_response = api_response + activities example = list(api_response[len(api_response) - 1].to_dict().keys()) example = [ x for x in example if x not in ['map', 'athlete', 'start_latlng', 'end_latlng'] ] dicts = {} for n in range(len(api_response)): d = api_response[n].to_dict() new_dict = {variable: d[variable] for variable in example} dicts[n] = new_dict index = list(dicts.keys()) strava = pd.DataFrame([dicts[key] for key in index], index=index) mult_mile = 0.000621371 strava['miles'] = strava.distance * mult_mile strava['race'] = strava.workout_type.apply(lambda x: 1 if x in [1.0, 11.0] else 0) strava['date_string'] = strava.start_date_local.astype(str).apply( lambda x: x[:10]) strava['moving_minutes'] = strava.moving_time / 60 strava['elapsed_minutes'] = strava.elapsed_time / 60 strava['rest'] = strava.elapsed_minutes - strava.moving_minutes ## average speed is in meters/second - 2.237 to multiply to mph strava['avg_mph'] = strava.average_speed * 2.237 strava.start_date = pd.to_datetime(strava.start_date_local) strava.sort_values('start_date', inplace=True) strava['time_since_last_act'] = ( pd.to_datetime(strava.start_date) - pd.to_datetime(strava.start_date.shift(1))).astype('timedelta64[h]') strava['order'] = strava.groupby('date_string').start_date.rank() if len(strav) == 0: wks_1.set_dataframe(strava, (1, 1)) else: all_acts = pd.concat([strava, strav]) all_acts.drop_duplicates(['id'], keep='first', inplace=True) wks_1.set_dataframe(all_acts, (1, 1))
client = mqtt.Client() client.on_connect = on_connect client.on_message = on_message client.on_publish = on_publish client.username_pw_set(secrets["user"], password=secrets["pass"]) client.connect(mqttServer, mqttPort, 60) #Get epoch time for a week ago now = round(time.time()) aweek = 60 * 60 * 24 * 7 weekAgo = now - aweek #Do the swagger stuff configuration = swagger_client.Configuration() configuration.access_token = token api_instance = swagger_client.ActivitiesApi( swagger_client.ApiClient(configuration)) after = weekAgo # int | An epoch timestamp to use for filtering activities that have taken place after a certain time. (optional) #Call the API for the logged in athelete's activities api_response = api_instance.get_logged_in_athlete_activities(after=after) #Create our list list = {} #Take the API response and just get the stuff we want count = 0 for i in api_response: activitynum = "activity" + count.__str__() print(i.type) activity = {
def get_strava(last_date=False): ## Getting log in info config = configparser.ConfigParser() config.read("../strava.ini") params={'client_id':config['strava']['client_id'], 'client_secret':config['strava']['client_secret'], 'code':config['strava']['code']} auth_url=config['strava']['auth_url'] ref_url=config['strava']['ref_url'] athlete_id=config['strava']['athlete_id'] if not last_date: ## Getting the most recent date last_date=datetime.datetime.strptime(strav.start_date.max().split(' ')[0],"%Y-%m-%d") else: last_date=datetime.datetime.strptime(last_date,"%Y-%m-%d") timestamp=last_date.timestamp() delta=datetime.datetime.now() - last_date date_diff=delta.days+5 r_auth = requests.post(auth_url, data=params) response=r_auth.json() configuration = swagger_client.Configuration() configuration.access_token = response['access_token'] # create an instance of the API class api_instance = swagger_client.ActivitiesApi(swagger_client.ApiClient(configuration)) if date_diff<200: try: # Get Authenticated Athlete api_response = api_instance.get_logged_in_athlete_activities(after=timestamp, per_page=date_diff) except ApiException as e: print("Exception when calling AthletesApi->get_logged_in_athlete: {}\n".format(e)) else: num_rounds=math.ceil(date_diff/200) api_response=[] for n in range(num_rounds): if n==num_rounds: page_num=date_diff-(200*(n-1)) else: page_num=200 try: # Get Authenticated Athlete activities = api_instance.get_logged_in_athlete_activities(after=timestamp, page=n+1,per_page=page_num) except ApiException as e: print("Exception when calling AthletesApi->get_logged_in_athlete: {}\n".format(e)) api_response=api_response+activities example=list(api_response[len(api_response)-1].to_dict().keys()) example=[x for x in example if x not in ['map','athlete','start_latlng','end_latlng']] dicts={} for n in range(len(api_response)): d=api_response[n].to_dict() new_dict={variable:d[variable] for variable in example} dicts[n]=new_dict index=list(dicts.keys()) new_acts=pd.DataFrame([dicts[key] for key in index],index=index) if len(strav)==0: wks_1.set_dataframe(new_acts,(1,1)) else: all_acts=pd.concat([new_acts,strav]) all_acts.drop_duplicates(inplace=True) wks_1.set_dataframe(all_acts,(1,1))
def main(args): client = Client() client_id = 40291 client_secret = '174e515190aa81a04416b147a32937ea5a86c672' with open("stravtoken.json", "r") as stravtoken: tokendict = json.load(stravtoken) access_token = tokendict["access_token"] refresh_token1 = tokendict["refresh_token"] expires_at = tokendict['expires_at'] if time.time() > tokendict['expires_at']: refresh_response = client.refresh_access_token(client_id, client_secret, refresh_token1) access_token = refresh_response['access_token'] refresh_token1 = refresh_response['refresh_token'] expires_at = refresh_response['expires_at'] with open("stravtoken.json", "w+") as json_file: json.dump(refresh_response, json_file) client.access_token = access_token client.refresh_access_token = refresh_token1 client.token_expires_at = expires_at api_instance = swagger_client.ActivitiesApi() api_instance.api_client.configuration.access_token = access_token list_acts2 = [] for x in range(1, 20): try: api_response = api_instance.get_logged_in_athlete_activities( page=x, per_page=100) acts = str(api_response) acts = acts.replace("\'", "\"") acts = acts.replace("None", "0") acts = acts.replace("False", "0") acts = acts.replace("True", "1") acts = json.loads(acts) for each in acts: if isinstance(each['start_latlng'], list): list_acts2.append([ each['id'], each['distance'] / 1609.344, each['moving_time'], each['elapsed_time'] - each['moving_time'], each['total_elevation_gain'], each['total_elevation_gain'] / each['moving_time'], each['start_latlng'][0], each['start_latlng'][1], each['map']['summary_polyline'] ]) except ApiException as e: print(x) acts_df = pd.DataFrame(list_acts2) acts_df.columns = [ 'Run ID', 'Distance', 'Time', 'Resting Time', 'Elevation Gain', 'Elevation Grade', 'Start Latitude', 'Start Longitude', 'Polyline' ] acts_df_clean = acts_df.drop(acts_df[acts_df['Start Latitude'] > 34].index) acts_df_clean = acts_df_clean.drop( acts_df[acts_df['Start Latitude'] < 33].index).reset_index() #DIST LABEL -------------------------------------------------------------------------------- conditions = [ (acts_df_clean['Distance'] <= 5), (acts_df_clean['Distance'] > 5) & (acts_df_clean['Distance'] <= 9), (acts_df_clean['Distance'] > 9) ] values = ['Short', 'Medium', 'Long'] acts_df_clean['Difficulty'] = np.select(conditions, values) #DIFF LABEL --------------------------------------------------------------------------------- #clust_df = acts_df_clean.filter(['Distance','Elevation Grade'], axis=1) #clust_df['Distance'] = clust_df['Distance'].apply(lambda x: pow(x*150,.35)) #clust_df['Elevation Grade'] = clust_df['Elevation Grade'].apply(lambda x: pow(x*150,.8)) #kmeans = KMeans(n_clusters=6,random_state=3425) #kmeans.fit(clust_df) #labels = pd.Series(kmeans.predict(clust_df),name='Difficulty').to_frame().reset_index() #clust_df = pd.concat([clust_df, labels], axis=1, sort=False) #acts_df_clean = pd.concat([acts_df_clean, labels], axis=1, sort=False) #maps = {0:2,1:1,2:0,3:2,4:0,5:1} #acts_df_clean['Difficulty'] = acts_df_clean['Difficulty'].apply(lambda x: maps[x]) acts_df_clean.to_csv('activities.csv', index=False)