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 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 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 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 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)
