def check_oauth_token(cls, access_token): if not access_token: return False c = Client() c.access_token = access_token try: c.get_athlete() except HTTPError: return False else: return True
def get_strava_api(secret, ID): all_act = [] client = Client(access_token=secret) tot = total_num(client) me = client.get_athlete(ID) activities = client.get_activities() for i in trange(tot): df = pd.DataFrame() _a = activities.next() _streams = client.get_activity_streams(_a.id, types=types) for item in types: if item in _streams.keys(): df[item] = pd.Series(_streams[item].data, index=None) df['act_id'] = _a.id df['act_name'] = _a.name df['act_type'] = _a.type df['lat'] = map(split_lat, (df['latlng'])) df['lon'] = map(split_long, (df['latlng'])) df['time'] = df['distance'] / (df['velocity_smooth']) df.fillna(0) all_act.append(df) del df with open(save_file + '.pkl', 'wb') as fp: pickle.dump(all_act, fp) pd.concat(all_act, ignore_index=True).to_csv(save_file + '.csv') return all_act
def get(request): """ Request -and store- a strava access token. """ client = Client() # Extract the code from the response code = request.GET.get('code') access_token = client.exchange_code_for_token( client_id=settings.STRAVA_CLIENT_ID, client_secret=settings.STRAVA_CLIENT_SECRET, code=code ) strava_athlete = client.get_athlete() try: athlete = Athlete.objects.get(strava_id=strava_athlete.id) athlete.strava_token = access_token except Athlete.DoesNotExist: athlete = Athlete(strava_id=strava_athlete.id, strava_token=access_token) athlete.save() cache_key = _get_cache_key(request) cache.delete(cache_key) redir_url = '{}?start_date={}&end_date={}'.format( reverse_lazy('strava-summary'), _get_start_date(request), _get_end_date(request) ) return HttpResponseRedirect(redir_url)
class StravaData: RUNNER_ID = None ACCESS_TOKEN = None client = None def __init__(self, runner_id, access_token): self.RUNNER_ID = runner_id self.ACCESS_TOKEN = access_token self.client = Client() self.client.access_token = access_token def getAthlete(self): athlete = self.client.get_athlete() return athlete def getActivities(self): activities = self.client.get_activities() return activities def getActivity(self, id): activity = self.client.get_activity(id) return activity def getActivityStreams(self, id, types): streams = self.client.get_activity_streams(id, types=types, resolution='medium') return streams
def index(): #if the user has already used the app(and has a cookie saved) if session: #if user is already authenticated and not expired if (time.time() < session['expires_at']): return render_template('index.html',auth_link=request.url_root+'map') #if the user's token is expired, refresh the oken else: token = refresh_token(session['refresh_token']) #if a code is being returned if request.args.get('code'): #take code and convert to token code = request.args.get('code') token = token_exchange(code) # if this is the user's first visit, load page for authentication else: return render_template('index.html',auth_link=request.url_root+'authenticate') #store token and athlete_id in flask session session.clear() client = Client(token['access_token']) athlete_id = client.get_athlete().id session['athlete_id'] = athlete_id session['expires_at'] = token['expires_at'] session['access_token'] = token['access_token'] session['refresh_token'] = token['refresh_token'] session['code'] = code #send to map page return redirect(request.url_root+'map', code=302)
class Strava: def __init__(self, token): self._token = token self._client = None self._verbose = True def connect(self): self._client = Client() token = self._token refresh_response = self._client.refresh_access_token( client_id=token['client_id'], client_secret=token['client_secret'], refresh_token=token['refresh_token']) token.update(refresh_response) self._token = token athlete = self._client.get_athlete() if self._verbose: logger.info("Connected to STRAVA as athelete \"{} {}\"".format( athlete.firstname, athlete.lastname)) return self._token def set_weight(self, weight): self._client.update_athlete(weight=weight) @property def client(self): return self._client
def home(request): if 'access_token' not in request.session: return redirect('auth') # Retrieving athlete's data from API client = Client(access_token=request.session.get('access_token')) athlete = client.get_athlete() # Checking if the athlete has already visited the site before try: db_athlete = Athlete.objects.get(id=athlete.id) except Athlete.DoesNotExist: db_athlete = Athlete.create(athlete) db_athlete.save() # Getting the latest activity from the current athlete try: latest_activity = Activity.objects.filter(athlete=db_athlete).latest('date') activities = client.get_activities(after=latest_activity.date) except Activity.DoesNotExist: activities = client.get_activities() # Adding new activities to the database for activity in activities: if not activity.manual: stream = client.get_activity_streams(activity.id, types=['latlng'], resolution='medium').get('latlng') db_activity = Activity.create(activity, db_athlete, stream.data) db_activity.save() return render(request, 'home.html', {'athlete': athlete, 'activities': activities, 'act_length': len(list(activities))})
def create_context(): token_struct = session.get('token_struct') if token_struct == None: raise NoToken try: access_token = token_struct['access_token'] except KeyError: raise NoToken client = Client(access_token=access_token) try: refresh_token(client) athlete = client.get_athlete() except AccessUnauthorized: raise athlete_dir = os.path.join(current_app.instance_path, 'athletes', str(athlete.id)) if not os.path.isdir(athlete_dir): make_dirs(athlete_dir) with open(os.path.join(athlete_dir, 'athlete.json'), 'w') as f: json.dump(athlete.to_dict(), f) return client, athlete
def main(ctx): client = Client() client.access_token = get_access_token() ctx.obj['client'] = client ctx.obj['athlete'] = client.get_athlete() ctx.obj['bikes'] = get_bikes(ctx.obj['athlete'])
def auth_success(request): temp_code = request.GET.get('code') # temp auth code print(temp_code) client = Client() token = client.exchange_code_for_token(5928, 'a486a0b19c8d16aef41090371b7726dc510ee4a7', temp_code) if not athlete.objects.filter(pk=client.get_athlete().id): new_athlete = athlete( id = client.get_athlete().id, firstname = client.get_athlete().firstname, lastname = client.get_athlete().lastname, access_token = token ) new_athlete.save() data_scraper(after_utc, before_utc, client.get_athlete().id) result = 'added' else: result = 'already exists' return render(request, 'auth_success.html', {'leaderboard':get_leaderboard(), 'result':result})
def authorize(self): client = Client() authorize_url = client.authorization_url( client_id=9531, redirect_uri='http://127.0.0.1:5000/authorization') # Have the user click the authorization URL, a 'code' param will be added to the redirect_uri # ..... # Extract the code from your webapp response # code = request.args.get('code') # or whatever your framework does # access_token = client.exchange_code_for_token(client_id=9531, client_secret='111b5017534c4bd4049f8ff941790b0762b63701', code=code) access_token = "990aa3bd5897c731ee759794edeecd7c058939de" # Now store that access token somewhere (a database?) client.access_token = access_token athlete = client.get_athlete() print("For {id}, I now have an access token {token}".format( id=athlete.id, token=access_token)) athlete = client.get_athlete(227615) print("Hello, {}".format(athlete.firstname))
def auth_success(request): temp_code = request.GET.get('code') # temp auth code print(temp_code) client = Client() token = client.exchange_code_for_token( 5928, 'a486a0b19c8d16aef41090371b7726dc510ee4a7', temp_code) if not athlete.objects.filter(pk=client.get_athlete().id): new_athlete = athlete(id=client.get_athlete().id, firstname=client.get_athlete().firstname, lastname=client.get_athlete().lastname, access_token=token) new_athlete.save() data_scraper(after_utc, before_utc, client.get_athlete().id) result = 'added' else: result = 'already exists' return render(request, 'auth_success.html', { 'leaderboard': get_leaderboard(), 'result': result })
def main(): global leader_list client = Client() authorize_url = client.authorization_url( client_id=16694, redirect_uri='http://localhost:8282/authorized') access_token = '1a424f23c2b57360dab45e720a9a45bd0868f299' client.access_token = access_token rex = client.get_athlete(168768) abdul = client.get_athlete(9954274) addison = client.get_athlete(3070847) jd = client.get_athlete(2903427) leaders = client.get_segment_leaderboard(7769406) for leader in leaders: name = (str(leader.athlete_name)) leader_list.append(name) print(leader_list)
def get_emails(): email_list = [] athletes = athlete.objects.all() for each_athlete in athletes: # for each athlete client = Client(access_token=each_athlete.access_token) this_athlete_email = client.get_athlete().email email_list.append(this_athlete_email) string_of_emails = "" for value in email_list: string_of_emails += str(value) string_of_emails += "; " print(string_of_emails)
def get_user(self): client = Client() token = self.accessToken() if token is None: return None client.access_token = token athlete = client.get_athlete() return dict(first_name=athlete.firstname, last_name=athlete.lastname, email=athlete.email)
def auth(): try: code = request.args["code"] c = Client() token = c.exchange_code_for_token(app.config['STRAVA_ID'], app.config['STRAVA_SECRET'], code) except (KeyError, requests.exceptions.HTTPError): return redirect("/") session["token"] = c.access_token = token a = c.get_athlete() # Technically shouldn't be needed as the athlete details are returned in the oauth call session["athlete"] = {"firstname": a.firstname, "picture": a.profile_medium} return redirect("/")
def add_athlete(access_token): # An authorized callback is coming. Process it and add client = Client() # Now store that access token along with athlete details client.access_token = access_token athlete = client.get_athlete() ath = extract_athlete(athlete) ath['access_token'] = access_token dao = MainDAO() dao.add_athlete(ath) pull_activities(access_token, ath['firstname'], ath['lastname']) return True
def AddUserToken(self, token): client = Client(token) athlete = client.get_athlete() # Simplified logic not to add duplicate user tokens. # todo: check the user is not in the user token table. if self.GetMemcacheToken(athlete.id) is None: rider = UserToken(strava_id=athlete.id, strava_token=token) rider.put() memcache.add(self.GetMemcacheKey(athlete.id), token, 60) return athlete.id
def strava_login(): code = request.args.get('code') client = Client() cid = current_app.config['STRAVA_CLIENT_ID'] csecret = current_app.config['STRAVA_CLIENT_SECRET'] access_token = client.exchange_code_for_token(client_id=cid, client_secret=csecret, code=code) athlete = client.get_athlete() email = athlete.email send_user_to_dataservice(email, access_token) session['user'] = email session['token'] = access_token return redirect('/')
def main(action, filename): if action == "DOWNLOAD": client = Client() client.access_token = access_token athlete = client.get_athlete() print("For {id}, I now have an access token {token}".format( id=athlete.id, token=access_token)) fileToUpload = open(filename, 'rb') activityUploader = client.upload_activity(fileToUpload, 'fit', 'TestActivity', '', 'ride', False, '1') activityUploader.wait(60, 1) print('Finished uploading to strava') return 0
def index(request): # Get KM cycled from Strava API from stravalib.client import Client from stravalib import unithelper strava = Client(settings.STRAVA_TOKEN) profile = strava.get_athlete(settings.STRAVA_ID) cycled = 0 for b in profile.bikes: cycled += float(b.distance) / 1000 return render_to_response( 'cv/index.html', locals(), context_instance=RequestContext(request) )
def authorized(): # get access token to make requests client = Client() code = request.args.get('code') client.access_token = client.exchange_code_for_token(client_id=creds.client_id, client_secret=creds.client_secret, code=code) # add id and secret # get data today = datetime.datetime.strptime(str(datetime.date.today()), "%Y-%m-%d") one_month_ago = today - dateutil.relativedelta.relativedelta(months=1) athlete = client.get_athlete() activities = client.get_activities(after=one_month_ago) rides = toolkit.get_activity_types(activities, 'ride') runs = toolkit.get_activity_types(activities, 'run') ride_set = ActivitySet("Rides", rides) run_set = ActivitySet("Runs", runs) return render_template('main.html', athlete=athlete, activity_sets=[ride_set, run_set])
def index(request): user = None if (request.user.is_authenticated): user = AuthUser.objects.get(user_id=request.user.id) client = Client() authorize_url = client.authorization_url(client_id=24429, redirect_uri="http://localhost:8000/main") #get code from get #Get Code from webapp response code = request.GET.get('code') if (request.GET.get('code') != None) else '' start_pos, end_pos, a_polyline = '', '', '' if (code != '' and request.user.is_authenticated): access_token = client.exchange_code_for_token(client_id=24429, client_secret=config_vars.STRAVA_CLIENT_SECRET, code=code) user_model = AuthUser.objects.get(user_id=request.user.id) # Store User Access Token in DB if (user_model is not None): user_model.auth_code = access_token user_model.save() # Set Access Token On Client if (request.user.is_authenticated and user.auth_code != ''): pprint("User Logged in and has an auth code") client.access_token = user.auth_code athlete = client.get_athlete() full_activity = client.get_activity(1486441471, True) a_polyline = full_activity.map.polyline start_pos = full_activity.start_latlng end_pos = full_activity.end_latlng return render(request, "index.html", { "auth_url": authorize_url, "start_pos": start_pos, "end_pos": end_pos, "polyline": a_polyline, "user_is_authenticated": request.user.is_authenticated })
def index(request): url_strava = 'https://www.strava.com/oauth/authorize?client_id=13966&response_type=code&redirect_uri=http://maaxrun.pythonanywhere.com/authorization/&scope=write&state=mystate&approval_prompt=force' print(type(url_strava)) date = datetime.now() username = None if request.user.is_authenticated(): #username = request.user.username access_token = request.user.profile.user_token client = Client(access_token) athlete = client.get_athlete() id_runner = athlete.id elevation = 0 best_speed = 0.0 longest_run = 0.0 # Activities can have many streams, you can request desired stream types for activity in client.get_activities(after="2016-01-01T00:00:00Z"): #print("{0.distance} {0.moving_time} {0.total_elevation_gain}".format(activity).encode('utf-8')) if activity.type == 'Run': elevation += float(activity.total_elevation_gain) if float(activity.distance ) / activity.moving_time.total_seconds() > best_speed: best_speed = float( activity.distance ) / activity.moving_time.total_seconds() if float(activity.distance) > longest_run: longest_run = float(activity.distance) nb_everest = round(elevation / 8848, 2) nb_mtblanc = round(elevation / 4809, 2) longest_run = longest_run / 1000 best_speed = round(best_speed * 3.6, 2) best_allure = 1 / (best_speed / 60) partie_entiere = int(best_allure) partie_decimale = int((best_allure - partie_entiere) * 60) if partie_decimale < 10: is_inf10 = 1 else: is_inf10 = 0 #best_allure = partie_entiere + partie_decimale else: print('error') return render(request, 'index.html', locals())
def strava_redirect(request): auth_code = request.GET.get("code") client = Client() access_token = client.exchange_code_for_token(CLIENT_ID, CLIENT_SECRET, auth_code) client.access_token = access_token global accesToken accesToken = access_token athlete = client.get_athlete() currentUser = User.objects.get(pk=request.user.id) currentUser.profile.stravaAccessToken = access_token currentUser.profile.save() return render(request, 'strava_redirect.html', {'athlete_name': athlete.username})
def index(): access_token = session.get('access_token') if access_token is None: return redirect(url_for('login')) client = Client(access_token=access_token) athlete = client.get_athlete() # client.protocol.get('/athletes/your_id') athlete_id = athlete.id # bo = 'hi' # kim = 'yo' # c = bo + kim stats_m = client.protocol.get('/athletes/' + str(athlete_id) + '/stats') stats_mi = { 'run_distance': m_to_mi(stats_m['recent_run_totals']['distance']), 'run_count': stats_m['recent_run_totals']['count'], 'run_elevation': stats_m['recent_run_totals']['elevation_gain'], 'run_pace': average_pace(stats_m['recent_run_totals']['distance'], stats_m['recent_run_totals']['moving_time']), 'run_distance_ytd': m_to_mi(stats_m['ytd_run_totals']['distance']), 'run_count_ytd': stats_m['ytd_run_totals']['count'], 'run_elevation_ytd': stats_m['ytd_run_totals']['elevation_gain'], 'run_pace_ytd': average_pace(stats_m['ytd_run_totals']['distance'], stats_m['ytd_run_totals']['moving_time']), 'run_distance_all': m_to_mi(stats_m['all_run_totals']['distance']), 'run_count_all': stats_m['all_run_totals']['count'], 'run_elevation_all': stats_m['all_run_totals']['elevation_gain'], 'run_pace_all': average_pace(stats_m['all_run_totals']['distance'], stats_m['all_run_totals']['moving_time']), 'ride_distance': m_to_mi(stats_m['recent_ride_totals']['distance']), 'ride_count': stats_m['recent_ride_totals']['count'], 'ride_elevation': stats_m['recent_ride_totals']['elevation_gain'], 'ride_speed': average_mph(stats_m['recent_ride_totals']['distance'], stats_m['recent_ride_totals']['moving_time']), 'ride_distance_ytd': m_to_mi(stats_m['ytd_ride_totals']['distance']), 'ride_count_ytd': stats_m['ytd_ride_totals']['count'], 'ride_elevation_ytd': stats_m['ytd_ride_totals']['elevation_gain'], 'ride_speed_ytd': average_mph(stats_m['ytd_ride_totals']['distance'], stats_m['ytd_ride_totals']['moving_time']), 'ride_distance_all': m_to_mi(stats_m['all_ride_totals']['distance']), 'ride_count_all': stats_m['all_ride_totals']['count'], 'ride_elevation_all': stats_m['all_ride_totals']['elevation_gain'], 'ride_speed_all': average_mph(stats_m['all_ride_totals']['distance'], stats_m['all_ride_totals']['moving_time']), } # raise Exception(stats_mi['run_distance']) return render_template('index.html', athlete=athlete, stats=stats_mi, athlete_id=athlete)
def index(): access_token = session.get('access_token') if access_token is None: return redirect(url_for('login')) client = Client(access_token=access_token) athlete = client.get_athlete() # client.protocol.get('/athletes/your_id') athlete_id = athlete.id # bo = 'hi' # kim = 'yo' # c = bo + kim stats_m = client.protocol.get('/athletes/' + str(athlete_id) + '/stats') stats_mi = { 'run_distance': m_to_mi(stats_m['recent_run_totals']['distance']), 'run_count': stats_m['recent_run_totals']['count'], 'run_elevation': el(stats_m['recent_run_totals']['elevation_gain']), 'run_pace': average_pace(stats_m['recent_run_totals']['distance'], stats_m['recent_run_totals']['moving_time']), 'run_distance_ytd': m_to_mi(stats_m['ytd_run_totals']['distance']), 'run_count_ytd': stats_m['ytd_run_totals']['count'], 'run_elevation_ytd': el(stats_m['ytd_run_totals']['elevation_gain']), 'run_pace_ytd': average_pace(stats_m['ytd_run_totals']['distance'], stats_m['ytd_run_totals']['moving_time']), 'run_distance_all': m_to_mi(stats_m['all_run_totals']['distance']), 'run_count_all': stats_m['all_run_totals']['count'], 'run_elevation_all': el(stats_m['all_run_totals']['elevation_gain']), 'run_pace_all': average_pace(stats_m['all_run_totals']['distance'], stats_m['all_run_totals']['moving_time']), 'ride_distance': m_to_mi(stats_m['recent_ride_totals']['distance']), 'ride_count': stats_m['recent_ride_totals']['count'], 'ride_elevation': el(stats_m['recent_ride_totals']['elevation_gain']), 'ride_speed': average_mph(stats_m['recent_ride_totals']['distance'], stats_m['recent_ride_totals']['moving_time']), 'ride_distance_ytd': m_to_mi(stats_m['ytd_ride_totals']['distance']), 'ride_count_ytd': stats_m['ytd_ride_totals']['count'], 'ride_elevation_ytd': el(stats_m['ytd_ride_totals']['elevation_gain']), 'ride_speed_ytd': average_mph(stats_m['ytd_ride_totals']['distance'], stats_m['ytd_ride_totals']['moving_time']), 'ride_distance_all': m_to_mi(stats_m['all_ride_totals']['distance']), 'ride_count_all': stats_m['all_ride_totals']['count'], 'ride_elevation_all': el(stats_m['all_ride_totals']['elevation_gain']), 'ride_speed_all': average_mph(stats_m['all_ride_totals']['distance'], stats_m['all_ride_totals']['moving_time']), } # raise Exception(stats_mi['run_distance']) return render_template('index.html', athlete=athlete, stats=stats_mi, athlete_id=athlete)
def profileView(request): username = None if request.user.is_authenticated(): #username = request.user.username access_token = request.user.profile.user_token client = Client(access_token) athlete = client.get_athlete() id_runner = athlete.id elevation = 0 best_speed = 0.0 longest_run = 0 #longest_run_date; # Activities can have many streams, you can request desired stream types for activity in client.get_activities(after="2016-01-01T00:00:00Z"): #print("{0.distance} {0.moving_time} {0.total_elevation_gain}".format(activity).encode('utf-8')) if activity.type == 'Run': elevation += float(activity.total_elevation_gain) if float(activity.distance ) / activity.moving_time.total_seconds() > best_speed: best_speed = float( activity.distance ) / activity.moving_time.total_seconds() if activity.distance > longest_run: longest_run = activity.distance nb_everest = round(elevation / 8848, 2) nb_mtblanc = round(elevation / 4809, 2) best_speed = round(best_speed * 3.6, 2) best_allure = 1 / (best_speed / 60) partie_entiere = int(best_allure) partie_decimale = int((best_allure - partie_entiere) * 60) if partie_decimale < 10: is_inf10 = 1 else: is_inf10 = 0 #best_allure = partie_entiere + partie_decimale longest_run = longest_run / 1000 else: print('error') return render(request, 'profile.html', locals())
class DataProcessor: def __init__(self, token): self.dataService = Client() self.dataService.access_token = token self.me = self.dataService.get_athlete() def get_week_report(self): return { "weeklyRuns": [ { "day": "Monday", "distance": 1 }, { "day": "Tuesday", "distance": 1 }, { "day": "Wednesday", "distance": 1 }, { "day": "Thursday", "distance": 1 }, { "day": "Friday", "distance": 1 }, { "day": "Saturday", "distance": 1 }, { "day": "Sunday", "distance": 1 }, ], "dailyAverage": 1 }
def main(): friend_df = pd.read_csv('friend_colour_new.csv', index_col=False) now = datetime.datetime.now().strftime('%Y-%m-%d') client = Client(access_token='76824abf6abf903eb3d8b0bde83625135c0be0ec') athlete = client.get_athlete() outputlist = [] #should try to redo this using apply: for index, row in friend_df.iterrows(): outputlist.append(fetch_data(row, now)) outfile = open('distance.csv', 'a+') for s in outputlist: outfile.write(s) outfile.write('\n') print(str(now) + ' : ACTION: new data added to ' + outfile.name) outfile.close()
def main(): reload(sys) sys.setdefaultencoding('utf8') client = Client(access_token='76824abf6abf903eb3d8b0bde83625135c0be0ec') athlete = client.get_athlete() print("Hello, {}. I know your email is {}".format(athlete.firstname, athlete.email)) josh_friends = client.get_athlete_friends(5991862) print "Starting...." leaderboard = client.get_segment_leaderboard(2658830,following=True) print leaderboard[0].athlete_name friend_colour_dict = {} friend_colour_file = open('friend_colour.csv') colourreader = UnicodeDictReader(friend_colour_file) for line in colourreader: friend_colour_dict[line["name"]] = line["colour"] for x in friend_colour_dict: print str(x).encode("utf8")
def logged_in(): """ Method called by Strava (redirect) that includes parameters. - state - code - error """ error = request.args.get('error') state = request.args.get('state') if error: return render_template('login_error.html', error=error) else: code = request.args.get('code') client = Client() access_token = client.exchange_code_for_token( client_id=app.config['STRAVA_CLIENT_ID'], client_secret=app.config['STRAVA_CLIENT_SECRET'], code=code) # Probably here you'd want to store this somewhere -- e.g. in a database. strava_athlete = client.get_athlete() return render_template('login_results.html', athlete=strava_athlete, access_token=access_token)
def auth(): try: code = request.args["code"] c = Client() token = c.exchange_code_for_token(app.config['STRAVA_ID'], app.config['STRAVA_SECRET'], code) except (KeyError, requests.exceptions.HTTPError): return redirect("/") session["token"] = c.access_token = token a = c.get_athlete() # Technically shouldn't be needed as the athlete details are returned in the oauth call session["athlete"] = {"name": a.firstname, "picture": a.profile_medium, "id": a.id} # lookup athlete in db cur = g.db.execute('select * from users where id = {}'.format(a.id)) x = cur.fetchall() print x if not x: # Create the object in the db cur = g.db.cursor() cur.execute('insert into users (id, name, picture) values (?, ?, ?)', (a.id, a.firstname, a.profile)) g.db.commit() cur.close() return redirect("/")
class StrvaSignIn(StravaAuthSignIn): def __init__(self): super(StrvaSignIn, self).__init__('Strava') self.StravaClient = Client() def authorize(self): return redirect( self.StravaClient.authorization_url( client_id=self.consumer_id, redirect_uri=self.get_callback_url())) def callback(self): if 'code' not in request.args: return None access_token = self.StravaClient.exchange_code_for_token( client_id=self.consumer_id, client_secret=self.consumer_secret, code=request.args['code']) social_id = session['social_id'] user = User.query.filter_by(social_id=social_id).first() user.stravatoken = access_token self.StravaClient.access_token = access_token user.athlete_id = self.StravaClient.get_athlete().id db.session.commit() a = Athlete.query.get(user.athlete_id) if a is None: dbathlete = Athlete( id=user.athlete_id, stravatoken=access_token, firstname=self.StravaClient.get_athlete().firstname, lastname=self.StravaClient.get_athlete().lastname) db.session.add(dbathlete) else: dbathlete = Athlete.query.filter_by(id=user.athlete_id).first() dbathlete.stravatoken = access_token dbathlete.firstname = self.StravaClient.get_athlete().firstname dbathlete.lastname = self.StravaClient.get_athlete().lastname db.session.add(dbathlete) db.session.commit() return (user, self.StravaClient.get_athlete())
def main(): reload(sys) sys.setdefaultencoding('utf8') df1 = pd.read_csv('segoutput.csv',index_col=False) df1 = df1.set_index(['segment_id']) segmentlist = [] file = open('segments.csv') reader = csv.DictReader(file) for line in reader: segmentlist.append(line["Segment Id"]) #get rid of badsegments badsegments = [] badinfile = open('bad_segments.csv') badreader = csv.DictReader(badinfile) for line in badreader: badsegments.append(line["Segment Id"]) print 'Bad Segments: '+str(badsegments) for x in badsegments: if x in segmentlist: segmentlist.remove(x) client = Client(access_token='76824abf6abf903eb3d8b0bde83625135c0be0ec') athlete = client.get_athlete() print("Hello, {}. I know your email is {}".format(athlete.firstname, athlete.email)) josh_friends = client.get_athlete_friends(5991862) print "Starting...." #colors colours = ['575757','FFCDF3','FFEE33','FF9233','29D0D0','8126C0','814A19','1D6914','2A4BD7','AD2323','000000','88C6ED','C7258E'] segoutfile = open('segoutput.csv', 'w') segoutfile.write('id,latitude,longitude,name,type,color,segment_name,segment_id,url'+'\n') segoutputlist = [] friend_colour_dict = {} friend_colour_file = open('friend_colour.csv') colourreader = csv.DictReader(friend_colour_file) for line in colourreader: friend_colour_dict[line["name"]] = line["colour"] friend_count_dict = {} for num,j in enumerate(segmentlist): time.sleep(3) segment = retry_get_segment(client,j) try: leaderboard = retry_get_leaderboard(client,j) if not leaderboard: topguy = 'UNCLAIMED' else: topguy = leaderboard[0].athlete_name if not topguy in friend_colour_dict: friend_colour_dict[topguy] = colours.pop() print str(topguy)+' not in friend_colour_dict, popping colour: '+ str(friend_colour_dict[topguy]) if topguy in friend_count_dict: friend_count_dict[topguy] += 1 else: friend_count_dict[topguy] = 1 for z in segment_details(num,segment,topguy,friend_colour_dict): segoutfile.write(str(z)+',') segoutfile.write('\n') except Exception: #badoutfile = open('bad_segments.csv', 'a+') #badoutfile.write(str(j)+','+'\n') #badoutfile.close() pass segoutfile.close() #segment count output segcountoutfile = open('segmentcount.csv', 'w') segcountoutfile.write('name,colour,count'+'\n') for x in friend_count_dict: if x != 'UNCLAIMED': print str(x)+': '+str(friend_count_dict[x]) segcountoutfile.write(str(x)+','+str(friend_colour_dict[x])+','+str(friend_count_dict[x])+'\n') segcountoutfile.write('\n') segcountoutfile.close() json_convert_segmentcount() #segment count over time output segcountovertimefile = open('segmentcountovertime.csv', 'a+') nowdate = datetime.datetime.now().strftime('%Y-%m-%d') for x in friend_count_dict: if x != 'UNCLAIMED': segcountovertimefile.write(str(nowdate)+','+str(x)+','+str(friend_colour_dict[x])+','+str(friend_count_dict[x])+'\n') segcountovertimefile.close() trim_count_overtime() json_convert_trim_count_overtime() time.sleep(5) #read newly created segoutput.csv (df2) and compare it to original (df1): df2 = pd.read_csv('segoutput.csv',index_col=False) df2 = df2.set_index(['segment_id']) try: main_logger(df2,df1) #strava1 main_logger (warlog creation) res = requests.get("https://nosnch.in/ae58837141") except Exception as e: print 'Error: '+str(e) pass # strava1_segment main res = requests.get("https://nosnch.in/26ba53ff3d")
''' Script to grab activities from strava ''' import sys import stravalib from stravalib.client import Client from configparser import SafeConfigParser config = SafeConfigParser() config.read('config.yaml') client = Client() authorize_url = client.authorization_url( client_id=config.get('strava', 'client_id'), redirect_uri='http://localhost:8282/authorized') # Extract the code from your webapp response # access_token = client.exchange_code_for_token(client_id=config.get('strava', 'client_id'), client_secret=config.get('strava', 'client_secret'), code=config.get('strava', 'code')) # Now store that access token somewhere (a database?) client.access_token = config.get('strava', 'Bearer') athlete = client.get_athlete() activities = client.get_activities(after="2017-11-17T00:00:00Z", limit=15) activity_data = [] for activity in activities: activity_stream = client.get_activity_streams(activity.id, types=['latlng', 'distance']) activity_data.append(activity_stream['latlng'].data)
REAUTH = False ClientId = "<ClientId_int_here>" ClientSecret = "<ClientSecret_string_here>" AccessToken = "<AccessToken_here_if_available>" clientCode = "<ClientCodeHere>" meterToMile = 0.000621371 if(REAUTH): AccessToken = client.exchange_code_for_token(client_id=ClientId, client_secret=ClientSecret, code=clientCode) print(AccessToken) client = Client(access_token=AccessToken) athlete = client.get_athlete() r = open('data.json', 'r') data = json.load(r) activities = list(d["id"] for d in data) r.close() stravaActivities = client.get_activities() for activity in stravaActivities: if (activity.id in activities): print("Already have this activity!") continue a = client.get_activity(activity.id) if (a.type != "Run"): print("Activity was a run")
class StravaAthlete(object): ''' Gathers data for a strava athelete given possession of the API token ''' def __init__(self, token): self.token = token self.client = Client(access_token=self.token) self._athlete_name() def _athlete_name(self): this_athlete = self.client.get_athlete() first = this_athlete.firstname last = this_athlete.lastname return first + '_' + last def check_strava_dir(self): if os.path.basename(os.getcwd()) != 'strava': return print('Please navigate to strava directory before proceeding.') else: print('In strava directory.') pass def check_athlete_folder(self): try: os.chdir('data/'+self._athlete_name()) print('Data for {0} to be stored in {1}'.format( self._athlete_name(),'data/'+self._athlete_name())) os.chdir(Path(os.getcwd()).parents[1]) except: return print('Need to create directory first. use .add_athlete()') def check_directories(self): self.check_strava_dir() self.check_athlete_folder() def add_athlete(self): self.check_strava_dir() if os.path.isdir('data') == False: os.mkdir('data') print('data directory created') else: pass if os.path.isdir(os.path.join('data/',self._athlete_name())) == False: print('creating data/{} directory...'.format(self._athlete_name())) os.mkdir('data/' + self._athlete_name()) print('data/{} directory created'.format(self._athlete_name())) else: print('data/{} directory already exists'.format(self._athlete_name())) try: #try to load df self.ath_df = pd.read_csv('data/athletes.csv') print('ath_df successfully loaded') except: #check that df isn't in memory # if ath_df in globals(): # print('ath_df already in memory') # else: # ath_cols = ['firstname','lastname','city','state'] # ath_df = pd.DataFrame(columns = ath_cols) # print('empty ath_df intialized') try: self.ath_df = self.ath_df print('ath_df already in memory') except: #create empty df ath_cols = ['firstname','lastname','city','state'] ath_df = pd.DataFrame(columns = ath_cols) print('empty ath_df intialized') ath_cols = ['firstname','lastname','city','state'] athlete_dict = self.client.get_athlete().to_dict() self.ath_df = self.ath_df.append( {k:athlete_dict[k] for k in ath_cols if k in athlete_dict},ignore_index=True) self.ath_df = self.ath_df.drop_duplicates() #in case athlete was already added print('{0} {1} added to ath_df'.format(self.ath_df.firstname.iloc[-1], self.ath_df.lastname.iloc[-1])) self.ath_df.to_csv('data/athletes.csv', index=False) print('ath_df saved to data/athletes.csv') def get_rides(self): ''' Downloads a csv of all activity ids associated with rides ''' self.check_directories() try: self.ride_ids = pd.read_csv('data/'+self._athlete_name()+'/ride_ids.csv') print('ride_ids.csv successfully loaded.') except: print('Need to gather ride IDs...') try: os.chdir('data/'+self._athlete_name()) print('data for {0} to be stored in {1}'.format( self._athlete_name(),'data/'+self._athlete_name())) os.chdir(Path(os.getcwd()).parents[1]) except: return print('Need to create directory first. Use .add_athlete()') activities = self.client.get_activities() act_list = list(activities) print('Ride IDs successfully downloaded') ride_id_list = [] for act in act_list: if act.type != 'Ride': continue else: ride_id_list.append(act.id) ride_ids = pd.DataFrame(ride_id_list) ride_ids.columns = ['ride_id'] ride_ids.name = ride_ids ride_ids.to_csv('data/'+self._athlete_name()+'/ride_ids.csv', index=False) print('Ride IDs saved to data/{}/ride_ids.csv'.format(self._athlete_name())) self.ride_ids = ride_ids def check_dependency(self, df): ''' This has a problem with passing a df that isn't defined. In that case it will get an error before it even runs. Leaving in for now in case I can fix it but will just code it individually. (It's not too redundant. ''' try: df = df except NameError: return print('No'+df+'. Run appropriate method') def get_segments(self): ''' Downloads .csv of rides and segment ids. Require ride_ids dataframe ''' self.check_directories() ### replace with check_dependency(ride_ids) if I get that working try: self.ride_ids = self.ride_ids except: return print('No ride_ids data frame. Must run get_rides() method first') ### try: self.segments_df = pd.read_csv('data/'+self._athlete_name()+'/segments_df.csv') return print('segments_df successfully loaded') except: segment_cols = ['ride_name', 'ride_id', 'bike', 'ride_distance', 'ride_moving_time', 'ride_elapsed_time', 'ride_elevation_gain', 'ride_start_time', 'segment_id'] self.segments_df = pd.DataFrame(columns = segment_cols) print('Empty segments_df created.') ride_index = 0 remaining_rides = self.ride_ids.ride_id rides_left = len(remaining_rides) while ride_index <= rides_left: try: for ride in range(ride_index, rides_left): activity = self.client.get_activity(self.ride_ids.ride_id[ride], include_all_efforts=True) for segment in activity.segment_efforts: try: activity.gear.name self.segments_df = self.segments_df.append( {'ride_name' : activity.name, 'ride_id' : activity.id, 'bike' : activity.gear.name, 'ride_distance' : activity.distance, 'ride_moving_time' : activity.moving_time, 'ride_elapsed_time' : activity.elapsed_time, 'ride_elevation_gain' : activity.total_elevation_gain, 'ride_start_time' : activity.start_date_local, 'segment_id' : segment.segment.id}, ignore_index=True) except AttributeError: #if activity.gear.name is missing, skip it self.segments_df = self.segments_df.append( {'ride_name' : activity.name, 'ride_id' : activity.id, 'ride_distance' : activity.distance, 'ride_moving_time' : activity.moving_time, 'ride_elapsed_time' : activity.elapsed_time, 'ride_elevation_gain' : activity.total_elevation_gain, 'ride_start_time' : activity.start_date_local, 'segment_id' : segment.segment.id}, ignore_index=True) ride_index += 1 if ride_index % 50 == 0: print('Last ride downloaded: id:{} {}'.format(self.segments_df.tail(1).iloc[0,1], self.segments_df.tail(1).iloc[0,0])) print('It is {0}. Segments for {1} rides downloaded. {2} rides to go' .format(datetime.datetime.now().strftime("%H:%M"), ride_index, rides_left-ride_index)) except: wait = 0 print('rate limit exceeded, need to wait 15') print('it is now {} minutes after the hour'.format(datetime.datetime.now().minute)) time.sleep(60*16) print('trying again...') print('segments for all {} rides downloaded'.format(ride_index)) self.segments_df.name = 'segments_df' self.segments_df.to_csv('data/'+self._athlete_name()+'/segments_df.csv', index=False) print('segments_df saved to data/{}/segments_df.csv'.format(self._athlete_name())) def get_efforts(self): ''' Returns df of individual efforts on segements. Requires segments_df df. ''' self.check_directories() ### replace with check_dependency(ride_ids) if I get that working try: self.segments_df = self.segments_df except: return print('No segments_df data frame. Must run get_segments() method first') ### try: self.efforts_df = pd.read_csv('data/'+self._athlete_name()+'/efforts_df.csv') return print('efforts_df successfully loaded.') except FileNotFoundError: efforts_columns = ['segment_id', 'effort_id', 'name', 'start_date', 'moving_time', 'elapsed_time', 'average_heartrate', 'max_heartrate'] try: self.efforts_df = self.efforts_df effort_segs = self.efforts_df.segment_id.unique() print('Appending to existing efforts df.') except: self.efforts_df = pd.DataFrame(columns = efforts_columns) effort_segs = np.array([]) print('Empty efforts_df created.') effort_segment_index = 0 effort_segs_to_download = 1 while effort_segment_index < effort_segs_to_download: effort_segment_index = 0 remaining_effort_segs = list(np.setdiff1d(self.segments_df.segment_id,effort_segs)) effort_segs_to_download = len(remaining_effort_segs) print('remaining segments to get efforts for: {}'.format(effort_segs_to_download)) try: for segment in remaining_effort_segs: this_segment = list(self.client.get_segment_efforts(segment)) for this_effort in this_segment: this_effort_dict = this_effort.to_dict() this_effort_dict['segment_id'] = segment this_effort_dict['effort_id'] = this_effort.id self.efforts_df = self.efforts_df.append( {k:this_effort_dict[k] for k in efforts_columns if k in this_effort_dict}, ignore_index=True) effort_segment_index += 1 if effort_segment_index % 50 == 0: print('Last segment downloaded: {0} {1}'.format(self.efforts_df.tail(1).iloc[0,0], self.efforts_df.tail(1).iloc[0,2])) print('It is {0}. Efforts for {1} segments downloaded. {2} segments to go...' .format(datetime.datetime.now().strftime("%H:%M"), effort_segment_index, effort_segs_to_download - effort_segment_index)) except: self.efforts_df.to_csv('data/'+self._athlete_name()+'/efforts_df.csv', index=False) print('efforts_df.csv successfully saved.') wait = 0 print('Rate limit exceeded, need to wait 15 minutes') print('It is now {} minutes after the hour'.format(datetime.datetime.now().minute)) time.sleep(60*16) print('Trying again...') print('Efforts for all {} segments downloaded'.format(segment_index)) self.efforts_df.to_csv('data/'+self._athlete_name()+'/efforts_df.csv', index=False) print('efforts_df.csv successfully saved.') def get_seg_details(self): ''' Downloads .csv of segment details. Require segments_df dataframe ''' self.check_directories() ### replace with check_dependency(ride_ids) if I get that working try: self.segments_df = self.segments_df except: return print('No ride_ids data frame. Must run get_rides() method first') ### try: self.seg_details_df = pd.read_csv('data/'+self._athlete_name()+'/seg_details_df.csv') return print('seg_details_df successfully loaded.') except FileNotFoundError: try: self.seg_details_df = self.seg_details_df print('Appending to existing seg_details df.') except AttributeError: seg_details_cols = ['segment_id', 'name', 'distance', 'average_grade', 'maximum_grade', 'elevation_high', 'elevation_low', 'total_elevation_gain', 'start_latitude', 'end_latitude', 'start_longitude', 'end_longitude', 'climb_category', 'city', 'state', 'country', 'effort_count', 'athlete_count', 'athlete_segment_stats', 'map'] self.seg_details_df = pd.DataFrame(columns = seg_details_cols) seg_details_to_download = np.array([]) print('Empty seg_details_df created.') segments_remaining = len(self.segments_df) seg_details_index = 0 while seg_details_index < segments_remaining: seg_details_index = 0 seg_details_remaining = list(np.setdiff1d(self.segments_df.segment_id,seg_details_to_download)) seg_details_to_download = len(seg_details_remaining) print('remaining segments to get details for: {}'.format(seg_details_to_download)) try: for segment in seg_details_remaining: this_segment_dict = self.client.get_segment(segment).to_dict() this_segment_dict['segment_id'] = segment self.seg_details_df = self.seg_details_df.append( {k:this_segment_dict[k] for k in seg_details_cols if k in this_segment_dict}, ignore_index=True) seg_details_index += 1 if seg_details_index % 50 == 0: self.seg_details_df.to_csv('data/'+self._athlete_name()+'/seg_details_df.csv', index=False) print('efforseg_details_dfts_df.csv successfully saved.') print('Last segment downloaded: {0} {1}'.format(self.seg_details_df.tail(1).iloc[0,0], self.seg_details_df.tail(1).iloc[0,1])) print('It is {0}. {1} segments downloaded. {2} segments to go...' .format(datetime.datetime.now().strftime("%H:%M"), seg_details_index, segments_remaining - seg_details_index)) except: wait = 0 print('rate limit exceeded, need to wait 15 minutes') print('it is now {} minutes after the hour'.format(datetime.datetime.now().minute)) time.sleep(60*16) print('trying again...') print('all {} segments downloaded'.format(seg_details_index)) self.seg_details_df.to_csv('data/'+self._athlete_name()+'/seg_details_df.csv', index=False) print('seg_details_df.csv successfully saved.')
from stravalib.client import Client club_id = 24151 client = Client(access_token='250d33ceabfbe833376eb18885e797af14888512') athlete = client.get_athlete() # Get John's full athlete record print("Hello, {}. I know your email is {}".format(athlete.firstname, athlete.email)) # "Hello, John. I know your email is [email protected]" activities = client.get_activities(limit=10) assert len(list(activities)) == 10 clubs = client.get_athlete_clubs() icc_members = client.get_club_members(club_id, limit=20) assert len(list(icc_members)) == 20 club_activities = client.get_club_activities(club_id, limit=20) assert len(list(club_activities)) == 20 #View activities #for x in activities: # print (x) for x in clubs: print (x) for x in icc_members: print (x)
@author: fraidylevilev """ # My access token: c2f218e5c3a9af9a3e0389d3e539e197f19f650e # My athlete id: 9753705 from stravalib.client import Client # import the strava library client = Client() # Input your access token below! client.access_token = 'c2f218e5c3a9af9a3e0389d3e539e197f19f650e' #this is me athlete = client.get_athlete(9753705) print("For {id}, I now have an access token {token}".format(id = athlete, token = client.access_token)) import requests import pandas as pd import numpy as np import time import sys #calling strava api base_url = 'https://www.strava.com/api' #using api to get efforts on a segment segment_url = base_url + '/v3/segments/{0}/all_efforts' extra_headers = {'Authorization' : 'Bearer {0}'.format(access_token)} per_page = 200
class StravaBot: def __init__(self): Config = ConfigParser.ConfigParser() Config.read("configuration/config") Config.sections() self.clientId = Config.get('Strava', 'ClientId') self.clientSecret = Config.get('Strava', 'ClientSecret') self.clientAccessToken = Config.get('Strava', 'ClientAccessToken') self.clubId = Config.get('Strava', 'ClubId') self.mattermostUrl = Config.get('Mattermost', 'URL') self.delay = Config.get('Bot', 'Delay') self.client = Client() self.client.access_token = self.clientAccessToken self.club = self.client.get_club(self.clubId) self.http = urllib3.PoolManager( cert_reqs='CERT_REQUIRED', ca_certs=certifi.where()) print('Bot for club {name} with id {id} is here :^)\n'.format(name=self.club.name, id=self.clubId)) def post_activity(self, activity): payload = {} if (activity.athlete.firstname is None): activity.athlete = self.client.get_athlete(activity.athlete.id) first_name = activity.athlete.firstname last_name = activity.athlete.lastname distance = kilometers(activity.distance) activity_duration = activity.moving_time speed = kilometers_per_hour(activity.average_speed) climbing = meters(activity.total_elevation_gain) activity_id = activity.id description = activity.name if (len(description) > 100): description = description[:97] + "..." payload = {'username': '******', 'icon_url': 'https://raw.githubusercontent.com/patoupatou/pymatterstrava/master/icon-strava.png', 'text': u':bicyclist: *{} {} : distance: {}, moving time duration: {}, speed: {}, climbing: {}* [{}](http://strava.com/activities/{}) :bicyclist:'.format(first_name, last_name, distance, activity_duration, speed, climbing, description, activity_id)} r = self.http.request('POST', self.mattermostUrl, headers={'Content-Type': 'application/json'}, body=json.dumps(payload)) print(time.ctime() + ': New activity posted') print('payload: ' + str(payload) + '\n') def get_activity_details(self, activity): return self.client.get_activity(activity.id) def get_new_activities(self, old_activities, new_activities): new_list = [] new_activity_ids = [] old_activity_ids = [] for new_activity in new_activities: new_activity_ids.append(new_activity.id) for old_activity in old_activities: old_activity_ids.append(old_activity.id) diff_ids = list(set(new_activity_ids) - set(old_activity_ids)) new_list = [act for act in new_activities if act.id in diff_ids] return new_list def run(self): activities = set(self.client.get_club_activities(self.clubId, limit=5)) new_activities = activities # for activity in activities: # details = self.get_activity_details(activity) # self.post_activity(details) while(1): new_activities = set(self.client.get_club_activities(self.clubId, limit=5)) diff_activities = self.get_new_activities(activities, new_activities) if len(diff_activities) > 0: print(time.ctime() + ': New activities!\n') print(diff_activities) for new_activity in diff_activities: details = self.get_activity_details(new_activity) self.post_activity(details) else: print(time.ctime() + ': No new activities\n') activities = new_activities time.sleep(float(self.delay))
cfg.sections() cfg.items('strava') token_entry = cfg.get('strava', 'token_entry') clientid = cfg.get('strava', 'clientid') activity = cfg.get('strava', 'activity') client = Client() authorize_url = client.authorization_url( clientid, redirect_uri='http://127.0.0.0.0:8100/authorized') # Have the user click the authorization URL, a 'code' param will be added to the redirect_uri client = Client(access_token=token_entry) # Currently-authenticated (based on provided token) athlete curr_athlete = client.get_athlete() # This is now me # Saying hello athlete = client.get_athlete() print("Hello, {}".format(athlete.firstname)) # Showing the friends athlete = client.get_athlete_clubs() for a in athlete: print("{} is your club.".format(a)) # Testing the activities # setting the athlete specific activity activity_1 = client.get_activity(activity) # method to take more activities and its informations
class Strava(object): def __init__(self): self.client_id = current_app.config['STRAVA_CLIENT_ID'] self.client_secret = current_app.config['STRAVA_CLIENT_SECRET'] self.redirect_uri = url_for('strava.confirm_auth', _external=True) self.client = StravaClient() self._activity_type = 'ride' # rides or runs self._activities = None @property def activity_type(self): return self._activity_type @activity_type.setter def activity_type(self, value): self._activity_type = value self._activities = None @property def athlete(self): return self.client.get_athlete() @property def activities(self): if not self._activities: # current_year = datetime.datetime.now().year # after = datetime.datetime(current_year - 2, 12, 25) self._activities = Activities(self.client.get_activities(), self.activity_type) return self._activities @classmethod def authorization_url(cls): self = cls() return self.client.authorization_url(client_id=self.client_id, redirect_uri=self.redirect_uri) def get_access_token(self, code): return self.client.exchange_code_for_token(client_id=self.client_id, client_secret=self.client_secret, code=code) @classmethod def athlete_by_code(cls, code): self = cls() self.client.access_token = self.get_access_token(code) return self.athlete @classmethod def athlete_by_token(cls, token): self = cls() self.client.access_token = token return self.athlete @classmethod def activities_by_token(cls, token): self = cls() self.client.access_token = token return self.activities @classmethod def by_token(cls, token): self = cls() self.client.access_token = token return self
client = Client(access_token='f91aebddd4bc9a15e28840703966bb27d11d70f0'); friendDe = 4303495; for activity in client.get_activities(limit=1): strava_id = u'{0.id}'.format(activity) print "no calories here" print "upload_id:", strava_id print "calories:", u'{0.calories}'.format(activity) print "starred_segments" starred_segments = client.get_starred_segment() print "athletes" me = client.get_athlete() friend = client.get_athlete(athlete_id=friendDe) print "list differences" for segment in starred_segments: Deefforts = client.get_segment_efforts(segment.id, athlete_id=friendDe, limit=1) #Myefforts = client.get_segment_efforts(segment.id, athlete_id=client.get_athlete().id, limit=1) friendrecord = None myrecord = None for deeffort in Deefforts: friendrecord = deeffort #for myeffort in Myefforts: #myrecord = myeffort
segment_id = 8516849 # 2015 Leeds Abbey Dash race_time = datetime(2015,11,15) output_file = 'data/leeds.times.csv' access_token = "<ACCESS TOKEN>" client = Client() client.access_token = access_token # Get all efforts on the day of the race efforts = client.get_segment_efforts(segment_id, start_date_local=race_time, end_date_local=race_time+timedelta(1)) data = [] data.append(["athlete_id", "sex", "first_name", "last_name", "time"]) print "a" counter = 0 for effort in efforts: print counter counter = counter + 1 time = effort.elapsed_time.seconds athlete_id = effort.athlete.id athlete = client.get_athlete(athlete_id) first_name = re.sub('[^0-9a-zA-Z]+', '', athlete.firstname) last_name = re.sub('[^0-9a-zA-Z]+', '', athlete.lastname) data.append([athlete_id, athlete.sex, first_name, last_name, time]) # Write to file with open(output_file, 'wb') as csv_file: writer = csv.writer(csv_file) writer.writerows(data)
class Strava(object): def __init__(self): self.client_id = current_app.config['STRAVA_CLIENT_ID'] self.client_secret = current_app.config['STRAVA_CLIENT_SECRET'] self.redirect_uri = url_for('strava.confirm_auth', _external=True) self.client = StravaClient() self._activity_type = 'ride' # rides or runs self._activities = None @property def activity_type(self): return self._activity_type @activity_type.setter def activity_type(self, value): self._activity_type = value self._activities = None @property def athlete(self): return self.client.get_athlete() @property def activities(self): if not self._activities: # current_year = datetime.datetime.now().year # after = datetime.datetime(current_year - 2, 12, 25) self._activities = Activities(self.client.get_activities(), self.activity_type) return self._activities @classmethod def authorization_url(cls): self = cls() return self.client.authorization_url(client_id=self.client_id, redirect_uri=self.redirect_uri) def get_access_token(self, code): return self.client.exchange_code_for_token( client_id=self.client_id, client_secret=self.client_secret, code=code) @classmethod def athlete_by_code(cls, code): self = cls() self.client.access_token = self.get_access_token(code) return self.athlete @classmethod def athlete_by_token(cls, token): self = cls() self.client.access_token = token return self.athlete @classmethod def activities_by_token(cls, token): self = cls() self.client.access_token = token return self.activities @classmethod def by_token(cls, token): self = cls() self.client.access_token = token return self
def main(): ChallengeSqlDB.init(MYSQL_HOST, MYSQL_USERNAME, MYSQL_PASSWORD, MYSQL_DB_NAME) print("Get all runners from db") users = ChallengeSqlDB.get_all_users() intania_clubs = ChallengeSqlDB.get_all_intania_clubs() # Map strava_id -> club.id intania_clubs_dict = {} for intania_club in intania_clubs: intania_clubs_dict[intania_club.strava_id] = intania_club # Find intania for for user in users: # User already has basic data in the database print("User: strava_id=%s displayname='%s %s'" % (user.strava_id, user.first_name, user.last_name)) if not user.credentials: print( "Skip runner with empty credentials: id=%s displayname='%s %s'" % (user.strava_id, user.first_name, user.last_name)) continue refresh_token = None for cred in user.credentials: if cred.strava_client == CLIENT_ID: refresh_token = cred.strava_refresh if refresh_token is None: print( "Skip runner with empty credentials for client_id=%s : id=%s displayname='%s %s'" % (CLIENT_ID, user.strava_id, user.first_name, user.last_name)) continue print('Found refresh_token for the user ...') client = Client() # Get new access token refresh_response = client.refresh_access_token( client_id=CLIENT_ID, client_secret=CLIENT_SECRET, refresh_token=refresh_token) # Set up user's access token and ready to fetch Strava data client.access_token = refresh_response['access_token'] # stravalib.exc.RateLimitExceeded try: athlete = client.get_athlete() except Exception as e: print('Error: failed to fetch Strava profile') print(e) continue joined_clubs = athlete.clubs if not (user.clubs is None or not user.clubs): print("%s %s is in '%s' club, skip club update..." % (user.first_name, user.last_name, user.clubs[0].name)) elif joined_clubs is None: print( "Error: failed to fetch clubs for %s %s, skip club update..." % (user.first_name, user.last_name)) else: for club in joined_clubs: # print("id:", club.id, "Club name:", club.name) club_strava_id = str(club.id) if club_strava_id in intania_clubs_dict: # update in database intania_club = intania_clubs_dict[club_strava_id] print('Update intania club (%s) for %s %s' % (intania_club.name, user.first_name, user.last_name)) ChallengeSqlDB.update_user_intania(user.id, intania_club.id) # Update first & last name try: ChallengeSqlDB.update_user_name(user.id, athlete.firstname, athlete.lastname) except Exception as e: print( 'Error: failed to update user entity: id=%d displayname=%s %s' % (user.id, athlete.firstname, athlete.lastname)) print(e) time.sleep(0.2)