def load_strava_tracks(self, strava_config: str) -> typing.List[Track]:
tracks = []
tracks_names = []
if self.cache_dir:
self.strava_cache_file = os.path.join(self.cache_dir,
strava_config)
if os.path.isfile(self.strava_cache_file):
with open(self.strava_cache_file) as f:
strava_cache_data = json.load(f)
tracks = [
self._strava_cache_to_track(i)
for i in strava_cache_data
]
tracks_names = [track.file_names[0] for track in tracks]
with open(strava_config) as f:
strava_data = json.load(f)
client = Client()
response = client.refresh_access_token(**strava_data)
client.access_token = response["access_token"]
fliter_dict = {"before": datetime.datetime.utcnow()}
if tracks:
max_time = max(track.start_time for track in tracks)
if max_time:
fliter_dict = {"after": max_time - datetime.timedelta(days=2)}
for activate in client.get_activities(**fliter_dict):
# tricky to pass the timezone
if str(activate.id) in tracks_names:
continue
t = Track()
t.load_strava(activate)
tracks.append(t)
self._store_strava_tracks_to_cache(tracks)
return self._filter_and_merge_tracks(tracks)
def main():
access_token = getToken()
if access_token == None:
return redirectAuth()
client = Client(access_token=access_token)
athlete = client.get_athlete() # Get current athlete details
#if you want a simple output of first name, last name, just use this line:
#return athlete.firstname + ' ' + athlete.lastname
#now get most recent activity for this athlete...
names = []
maps = []
for a in client.get_activities(before = "2016-08-12T00:00:00Z", limit=1):
names.append(a.name)
maps.append(a.map)
# another simple output for this bit is to return the name of the route
#return names[0]
# but a sightly more complicated output is this matplotlib figure --
m = maps[0]
summary_lat_lon = polyline.decode(m.summary_polyline)
lats = [i[0] for i in summary_lat_lon]
lons = [i[1] for i in summary_lat_lon]
session['name']=names[0]
session['lats']=lats
session['lons']=lons
return redirect('/simple.png')
def main():
token = get_token()
if not token:
print("No API token available, can't continue")
return
client = Client(token)
activities = client.get_activities()
print("Looking for activites that have 'commute' in the title, but don't "
"have the commute property set on them...")
interactive = True
for a in activities:
if not a.commute and "commute" in a.name.lower():
print(
"Found activity '{}' on {} - https://www.strava.com/activities/{}"
"".format(a.name, a.start_date.astimezone(tz=None), a.id))
i = ""
if not interactive:
i = "y"
while i not in ("y", "n", "a", "q"):
i = input("Add the commute tag to this activity? [y/n/a/q]: "
).lower()
if i == "y":
client.update_activity(a.id, commute=True)
print("Added commute tag")
elif i == "q":
break
elif i == "a":
interactive = False
print("Done")
def load_strava_tracks(self, strava_config: str) -> typing.List[Track]:
tracks = []
tracks_names = []
if self.cache_dir:
self.strava_cache_file = os.path.join(self.cache_dir, strava_config)
if os.path.isfile(self.strava_cache_file):
with open(self.strava_cache_file) as f:
strava_cache_data = json.load(f)
tracks = [self._strava_cache_to_track(i) for i in strava_cache_data]
tracks_names = [track.file_names[0] for track in tracks]
with open(strava_config) as f:
strava_data = json.load(f)
filter_type = strava_data.pop("activity_type", None)
client = Client()
response = client.refresh_access_token(**strava_data)
client.access_token = response["access_token"]
filter_dict = {"before": datetime.datetime.utcnow()}
if tracks:
max_time = max(track.start_time() for track in tracks)
filter_dict = {"after": max_time - datetime.timedelta(days=2)}
for activity in client.get_activities(**filter_dict):
# tricky to pass the timezone
if str(activity.id) in tracks_names:
continue
if filter_type and activity.type not in (
[filter_type] if isinstance(filter_type, str) else filter_type
): # pylint: disable=superfluous-parens
continue
t = Track()
t.load_strava(activity)
tracks.append(t)
self._store_strava_tracks_to_cache(tracks)
return self._filter_and_merge_tracks(tracks)
def process():
token = session.get('access_token', None)
if token is None:
return redirect(url_for('login'))
client = Client(token)
athlete = client.get_athlete()
activities = client.get_activities()
points = [pnt for a in activities for pnt in (a.end_latlng, a.start_latlng) if pnt]
#temp = [pnt for ints in point_intercepts(points) for pnt in ints]
#temp = filter_close_points(points)
seg = []
for grps in group_points(points):
out = []
for pnt in grps:
out.append("<trkpt lat=\"{0.lat}\" lon=\"{0.lon}\"></trkpt>".format(pnt))
seg.append("<trkseg>{}</trkseg>".format("".join(out)))
return """<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.0">
<name>TEST</name>
<trk>{}</trk>
</gpx>""".format("".join(seg))
return "<html><body><img src='{}'/>{} {}</body></html>".format(athlete.profile, athlete.firstname, athlete.lastname)
def get(self, request, athlete_id):
if request.user.is_authenticated():
template = loader.get_template('athlete.html')
try:
token = StravaToken.objects.get(user=request.user.id)
except ObjectDoesNotExist:
logger.error("Either the entry or blog doesn't exist.")
client_id = settings.CLIENT_ID
client_secret = settings.CLIENT_SECRET
client = Client(access_token=token.token)
logger.info(token.user)
logger.info(token.token)
athlete = client.get_athlete()
logger.info(athlete.city)
activities = client.get_activities(limit=10)
for activity in activities:
logger.info(
u"{0.name} {0.moving_time} {0.suffer_score}".format(
activity))
context = {
# 'latest_question_list': latest_question_list,
}
return HttpResponse(template.render(context, request))
else:
raise Http404("user is not login.")
class strava_class(object):
def __init__(self):
self.client = Client()
def login_vegard(self):
MY_STRAVA_CLIENT_ID = 14139
MY_STRAVA_CLIENT_SECRET = 'd753993b6646b15440914a6477e0d0e594b6a5b5'
code = '3436d2f7d6b3926667097f39cb9d07eeb8fdc9d2'
access_token = self.client.exchange_code_for_token(
client_id=MY_STRAVA_CLIENT_ID,
client_secret=MY_STRAVA_CLIENT_SECRET,
code=code)
self.client.access_token = access_token
def login_other():
MY_Url = 'http://127.0.0.1:5000'
url = client.authorization_url(client_id=MY_STRAVA_CLIENT_ID,
redirect_uri=self.MY_Url)
#Start web server
#Get the user to click the link
#read out the code from web server
#stop web server
return 0
def get_last_week(self, lim):
for activity in self.client.get_activities(
after="2016-08-01T00:00:00Z", limit=lim):
print("{0.name} {0.moving_time}".format(activity))
def get_activity_data(access_token):
client = Client(access_token)
athlete = client.get_athlete()
activity_stats = client.get_athlete_stats()
run_count = activity_stats.all_run_totals.count
bike_count = activity_stats.all_ride_totals.count
swim_count = activity_stats.all_swim_totals.count
total_count = run_count + bike_count + swim_count
all_activities = client.get_activities()
run_activities = []
swim_activities = []
bike_activities = []
calorie_count = 0.0
for activity in all_activities:
if (activity.type == "Run"):
run_activities.append(activity)
calorie_count += (float(activity.distance) / 1000) * float(athlete.weight) * 1.036
if (activity.type == "Swim"):
swim_activities.append(activity)
if (activity.type == "Ride"):
bike_activities.append(activity)
return ({"Runs": run_activities, "Swims" : swim_activities, "Rides": bike_activities, "Calorie_Count" : calorie_count})
def fetch_runs(user):
client = Client(access_token=user['strava_token'])
runs = []
for activity in client.get_activities(limit=10):
if activity.type != 'Run':
continue
runs.append(activity2run(activity))
return runs
def get_activitys(LIMIT):
TOKEN = retreve_token(c['client_id'], c['client_secret'])
data = list()
client = Client(access_token=TOKEN)
activitys = client.get_activities(limit=LIMIT)
for activ in activitys:
data.append(activ.to_dict())
return data
def get_activities(self, days, code):
dt1 = datetime.now()
dt2 = timedelta(days=days)
dt3 = dt1 - dt2
dt3 = dt3.strftime("%Y-%m-%dT%H:%M:%SZ")
client = Client(access_token=code)
activities = client.get_activities(after=dt3)
return activities
def segment_ids_from_activities(client, max_activities=5):
# get segment ids from most recent runs
client = Client(access_token=session['access_token'])
segment_ids = []
for a in client.get_activities(limit=max_activities):
# this is jank but I can't pass include_all_efforts to get_activities
activity = client.get_activity(
a.id, include_all_efforts=True) # return all segment efforts
for effort in activity.segment_efforts:
segment_ids.append(effort.segment.id)
session['segment_ids_unique'] = list(set(segment_ids))
session['uniques'] = len(session['segment_ids_unique'])
return
def fetch_runs(user):
client = Client(access_token=user.strava_token)
runs = 0
for activity in client.get_activities(limit=5):
if activity.type != "Run":
continue
q = db.session.query(Run).filter(Run.strava_id == activity.id)
run = q.first()
if run is None:
db.session.add(activity2run(activity))
runs += 1
db.session.commit()
return runs
def process():
token = session.get('access_token', None)
if token is None:
return redirect(url_for('login'))
client = Client(token)
athlete = client.get_athlete()
activities = client.get_activities()
for a in activities:
if not a.commute and "commute" in a.name.lower():
print(a)
client.update_activity(a.id, commute=True)
return "<html><body>processed</body></html>"
def should_unlock(lock_time_of_day):
"""Determine whether the person registered an activity since lock time."""
token = get_strava_token()
client = Client(access_token=token)
today = datetime.date.today()
afterdate = datetime.datetime.combine(today, lock_time_of_day)
activities = client.get_activities(after=afterdate.isoformat())
activity_list = [a for a in activities]
# Did the locked person record at least one activity since the lock time?
if len(activity_list) > 0:
return True
return False
def get_activity_map():
# just to see if i can plot my own activity map!
f = open('secrets.txt', 'r')
MY_STRAVA_CLIENT_ID = f.readline().strip()
MY_STRAVA_CLIENT_SECRET = f.readline().strip()
STORED_ACCESS_TOKEN = f.readline().strip()
f.close()
from stravalib import Client
client = Client(access_token=STORED_ACCESS_TOKEN)
client.get_athlete(7656735) # Get current athlete details
#now get most recent activity for this athlete...
a=client.get_activities(before = "2016-08-11T00:00:00Z", limit=1)
session['map']=a.map
session['name']=a.name
def get_activities_from_strava():
last_activity = None
if not os.path.exists(STRAVA_ACCESS_TOKEN_STRING_FNAME):
print '* Obtain a request token ...'
strava_client = Client()
auth_url = strava_client.authorization_url(client_id='601', redirect_uri='http://127.0.0.1:5000/authorisation')
print auth_url
auth_token = strava_client.exchange_code_for_token(client_id='601', client_secret='600580e02b4814c75c93d3a60e15077147895776', code = '74cc257e6bc370d9da44cabc8852f3667ad95515')
print auth_token
# write the access token to file; next time we just read it from file
if DEBUG:
print 'Writing file', STRAVA_ACCESS_TOKEN_STRING_FNAME
fobj = open(STRAVA_ACCESS_TOKEN_STRING_FNAME, 'w')
fobj.write(auth_token)
fobj.close()
else:
if DEBUG:
print 'Reading file', STRAVA_ACCESS_TOKEN_STRING_FNAME
fobj = open(STRAVA_ACCESS_TOKEN_STRING_FNAME)
access_token_string = fobj.read()
print access_token_string
#access_token = oauth.OAuthToken.from_string(access_token_string)
strava_client = Client(access_token=access_token_string)
activities = strava_client.get_activities(limit=10)
# for activity in activities:
# details = strava_client.get_activity(activity_id=activity.id)
# print details.name
# print unithelper.kilometers(details.distance)
# print details.start_date_local
# print details.elapsed_time
# print details.calories
# print details.type
# print "------"
# fobj.close()
for activity in activities:
last_activity = activity
return strava_client.get_activity(activity_id=activity.id)
class StravaHelper:
def __init__(self, token=''):
self.client = Client(access_token=token)
def get_last_activities(self, before=None, after=None, limit=None):
"""
Récupére les dernieres activités
:param before:
:param after:
:param limit: nombre limite d'activité
:return:
"""
return [
activity
for activity in self.client.get_activities(before, after, limit)
]
async def new_athlete(athlete):
# This is a hack to have the callback response return before the reports are generated
await asyncio.sleep(1)
client = Client(athlete.access_token)
for activity in client.get_activities(limit=STRAVA_BACKFILL_COUNT):
# This is a hack to have this job not block all other requests
await asyncio.sleep(1)
if athlete.token_expiration_datetime < datetime.now() + timedelta(
minutes=5):
athlete = await refresh_access_token(athlete)
await generate_report(athlete, activity.id)
await athlete.update(backfilled=True)
def load_strava_data(user_id):
user = User.objects.get(id=user_id)
token = user.social_auth.get(provider='strava').tokens
c = StravaClient(token)
# fetch 200 activities
activities = c.get_activities(limit=200)
for track in activities:
activity, created = Activity.objects.get_or_create(
guID=track.id,
user=user
)
print track.id
activity.provider = Activity.STRAVA_PROVIDER
activity.location_city = track.location_city
activity.location_country = track.location_country
full_activity = c.get_activity(track.id)
activity.polyline = full_activity.map.polyline
activity.moving_time = full_activity.moving_time
activity.start_date = full_activity.start_date
activity.distance = float(
unithelper.meters(
track.distance
)
)
activity.total_elevation_gain = float(
unithelper.meters(
track.total_elevation_gain
)
)
activity.resource_state = track.resource_state
activity.description = track.description
if hasattr(track, 'start_latlng') and track.start_latlng is not None:
activity.start_point = Point(
track.start_latlng.lon,
track.start_latlng.lat
)
activity.save()
if activity.polyline:
activity.route = LineString(polyline_decode(activity.polyline))
activity.save()
def load_activities():
users_id = session['athlete']['id']
c = Client(access_token=session['token'])
activities = list(c.get_activities())
cur = g.db.cursor()
# Delete activities before loading to prevent id clashes
cur.execute('delete from activities where users_id = ?', [users_id])
g.db.commit()
# TODO: bulk create
for a in activities:
cur.execute('insert into activities (id, name, distance, start_time, users_id) values (?, ?, ?, ?, ?)',
(a.id, a.name, int(a.distance) / 1609, a.start_date, users_id))
g.db.commit()
cur.close()
return redirect('/activities')
def get_activity_list(strava_auth, selected_year, activities_limit):
if not 'access_token' in strava_auth:
raise PreventUpdate
client = Client(access_token=strava_auth['access_token'])
start_date = f"{selected_year}-01-01T00:00:00Z"
end_date = f"{selected_year+1}-01-01T00:00:00Z"
activities = client.get_activities(
after=start_date,
before=end_date,
limit=activities_limit,
)
store_activities = [{
"id":
activity.id,
"name":
activity.name,
"max_heartrate":
activity.max_heartrate,
"has_heartrate":
activity.has_heartrate,
"kudos_count":
activity.kudos_count,
"average_heartrate":
activity.average_heartrate,
"start_date":
str(activity.start_date).replace("+00:00", ""),
"elapsed_time":
str(activity.elapsed_time).replace(" ", ""),
"distance":
str(activity.distance).replace(" ", ""),
"calories":
str(activity.calories).replace(" ", ""),
"average_speed":
str(activity.average_speed).replace(" ", ""),
"max_speed":
str(activity.max_speed).replace(" ", ""),
} for activity in activities][::-1]
return [{
"activities": store_activities
}, store_activities,
store_activities[0] if len(store_activities) > 0 else None]
def update_trainable(request, sport, start, end, commute):
"""Will update and create new trainable entries based on the data on
strava."""
client = Client(access_token=get_access_token(request))
activities = []
count_synced = 0
count_ignored = 0
for sactivity in client.get_activities():
activity = strava2trainable(sactivity)
# Activity date is YYYY-mm-DD HH:MM. As the daterange for the
# filter is only date we need to strip the time.
adate = activity["date"].split(" ")[0]
# Filter activities based on settings.
if activity["commute"] and not commute:
count_ignored += 1
continue
if start and adate < str(start):
count_ignored += 1
continue
if end and adate > str(end):
count_ignored += 1
continue
if str(activity["sport"]) not in sport:
count_ignored += 1
continue
else:
count_synced += 1
activities.append(activity)
_ = request.translate
msg_ignored = _("Ingnored {} activities on sync because of filter settings"
).format(count_ignored)
msg_synced = _("Synced {} activities").format(count_synced)
log.info(msg_ignored)
log.info(msg_synced)
request.session.flash(msg_synced, "success")
request.session.flash(msg_ignored, "info")
importer = JSONImporter(Activity, db=request.db)
items = importer.perform(json.dumps(activities),
request.user,
load_key="strava_id")
return _handle_save(request, items, None)
def token(request):
# Get temporary code after the request
code = request.GET.get("code")
# exchange the code for an access token.
client = Client()
access_token = client.exchange_code_for_token(client_id=STRAVA_CLIENT_ID,
client_secret=STRAVA_CLIENT_SECRET,
code=code)
# Get Athlete
athlete = client.get_athlete()
# See if the athlete exists in our DB
# current_athlete = get_object_or_404(Athlete, id_strava = athlete.id)
# current_athlete = ""
try:
current_athlete = Athlete.objects.get(id_strava = athlete.id)
except (KeyError, Athlete.DoesNotExist):
current_athlete = Athlete(first_name=athlete.firstname, last_name=athlete.lastname, access_token=access_token, id_strava = athlete.id )
current_athlete.save()
# **************************
# Prep content for the HTML page.
# Get Activities.
activities = client.get_activities()
# Make a list of activities to send to the html page. These are all the activities for this athlete.
activity_list = []
name_list = []
for a in activities:
temp = [a.id, a.name, a.distance, a.moving_time, a.elapsed_time, a.start_date_local]
activity_list.append(temp)
# information to send to the html page
context = { 'activity_list': activity_list, 'current_athlete': current_athlete }
template = loader.get_template('shred/activities.html')
return HttpResponse(template.render(context))
def dave():
config = configparser.ConfigParser()
config.read(BEE42_INI)
ini_beeminder = config[BEE42_INI_BEEMINDER]
username = ini_beeminder[BEE42_INI_USERNAME]
token = ini_beeminder[BEE42_INI_TOKEN]
strava_token = ini_beeminder[BEE42_INI_STRAVA_TOKEN]
user = User(username, token)
print("Username:"******"tz:", user.timezone, "update:", user.updated_at, "goals", user.goalslugs, "db:", user.deadbeat)
strava_client = Client(access_token=strava_token)
strava_athlete = strava_client.get_athlete()
print(strava_athlete.firstname)
strava_activities = strava_client.get_activities(limit=15)
for a in strava_activities:
if (a.type == "Run"):
print(add_run(user, a))
elif (a.type == "Ride"):
print(add_ride(user, a))
def getactivity(activity_id=0, client=None):
if client == None:
token = gettoken()
client = Client(access_token=token)
if activity_id == 0:
activities = client.get_activities(limit=1)
for i in activities:
activity = i
else:
try:
activity = client.get_activity(activity_id)
except:
print('Activity not found')
return int(0), client
athlete = activity.athlete
if not athlete.is_authenticated_athlete():
print('Activity does not belong to user')
return int(1), client
return activity, client
def load_strava_data(user_id):
user = User.objects.get(id=user_id)
token = user.social_auth.get(provider='strava').tokens
c = StravaClient(token)
# fetch 200 activities
activities = c.get_activities(limit=200)
for track in activities:
activity, created = Activity.objects.get_or_create(guID=track.id,
user=user)
print track.id
activity.provider = Activity.STRAVA_PROVIDER
activity.location_city = track.location_city
activity.location_country = track.location_country
full_activity = c.get_activity(track.id)
activity.polyline = full_activity.map.polyline
activity.moving_time = full_activity.moving_time
activity.start_date = full_activity.start_date
activity.distance = float(unithelper.meters(track.distance))
activity.total_elevation_gain = float(
unithelper.meters(track.total_elevation_gain))
activity.resource_state = track.resource_state
activity.description = track.description
if hasattr(track, 'start_latlng') and track.start_latlng is not None:
activity.start_point = Point(track.start_latlng.lon,
track.start_latlng.lat)
activity.save()
if activity.polyline:
activity.route = LineString(polyline_decode(activity.polyline))
activity.save()
def import_strava_api(self):
self._init_database_handler()
st = StravaTokenHandler()
st.set_db_handler(self.dbh, self.core_info.get("db_hash"))
st.update_token()
del st
user = self.dbh.list_user_by_hash(
user_hash=self.core_info.get("db_hash"))
client = Client(access_token=user["strava_bearer"]["access_token"])
athlete = client.get_athlete()
athlete_id = athlete.id
activity_stream_types = [
"time", "latlng", "distance", "altitude", "velocity_smooth",
"heartrate", "cadence", "watts", "temp", "moving", "grade_smooth"
]
for activity in client.get_activities(
before=self.activity_raw_date_end.strftime(
"%Y-%m-%dT%H:%M:%SZ"),
after=self.activity_raw_date_beg.strftime(
"%Y-%m-%dT%H:%M:%SZ"),
limit=100):
# The first order task is to form a common branch description
# from the Strava API activity (aka. activity -> branch/track)
write_success, hash_str = self._handle_activity_from__strava_api(
activity=activity)
if write_success is False:
print(
"We do not need to continue when creating the branch/track creation fails."
)
break
#Extract more details from the activity via the API
activity_stream = client.get_activity_streams(
activity_id=activity.id,
types=activity_stream_types,
resolution="high",
# series_type=None
)
#continue
# Create a GPS data leaf
self._handle_activity_from_strava_api_gps(
activity=activity,
activity_stream=activity_stream,
hash_str=hash_str)
# Create a strava based distance leaf
self._handle_activity_from_strava_api_distances(
activity=activity,
activity_stream=activity_stream,
hash_str=hash_str)
# Create strava based metadata leaf
self._handle_activity_from_stravi_api_metadata(
activity=activity,
activity_stream=activity_stream,
hash_str=hash_str)
def authorization(request):
client = Client()
code = request.GET['code']
access_token = client.exchange_code_for_token(client_id=MY_STRAVA_CLIENT_ID, client_secret=MY_STRAVA_CLIENT_SECRET, code=code)
# making a global variable to be used across views. don't know how this will work in practice
client = Client(access_token=access_token)
athlete = client.get_athlete() # Get current athlete details
global athleteId
athleteId = athlete.id
# if athlete doesn't exist, add them
if len(Athlete.objects.filter(athleteId=athleteId)) == 0:
ath = Athlete.objects.create(name=str(athlete.firstname+' '+athlete.lastname), athleteId=athleteId, profilePic=athlete.profile, city=athlete.city, country=athlete.country, sex=athlete.sex, premium=athlete.premium, created_at=athlete.created_at, updated_at=athlete.updated_at, followers=athlete.follower_count, friends=athlete.friend_count, email=athlete.email, weight=athlete.weight, meas_pref=athlete.measurement_preference, runsSummary = DataFrame({}).to_json(orient='records'), fitLines = DataFrame({}).to_json(orient='records'), masterList = DataFrame({}).to_json(orient='records'))
ath.profilePic.name = "rudyzPic"
ath.save(update_fields=['profilePic'])
# if athlete already exists, draw their file
elif len(Athlete.objects.filter(athleteId=athleteId)) == 1:
ath = Athlete.objects.get(athleteId=athleteId)
############################################
##### compiling new runs, updating summary
# athlete's existing runs summary
existingSummary = DataFrame(pd.read_json(ath.runsSummary))
existingFitlines = DataFrame(pd.read_json(ath.fitLines))
masterList = DataFrame(pd.read_json(ath.masterList))
activities = list(client.get_activities())
# activity IDs of runs already in the system
try:
ids = existingSummary.activityId
except AttributeError:
ids = []
for i in range(len(activities)):
#for i in range(30,37):
# Ignoring activities already in the system
if (len(ids) == 0) or (float(activities[i].id) not in list(ids)):
try:
# compiling df for raw json-ization
activityId = activities[i].id
run = client.get_activity_streams(activityId, types=['time','latlng','distance','heartrate','altitude','cadence'])
latlng = run['latlng'].data
time = run['time'].data
distance = run['distance'].data
heartrate = run['heartrate'].data
altitude = run['altitude'].data
cadence = run['cadence'].data
date = activities[i].start_date_local
activity = activityId
dfi = thresher.assemble(date, activityId, heartrate, distance, time, altitude, latlng, cadence)
# basic cleanup, only removing totally unreasonable values
dfi = thresher.basicClean(dfi)
# if we ever want to try our hand at improving strava's speed data (ie by predicting speed when GPS blanks), intervene here:
#dfi = thresher.addDistDeltas(dfi)
try:
fitline = thresher.getFitlineLws(dfi) # this adds speed-shifted columns
except:
fitline = pd.DataFrame({})
try:
mafScore = fitline[fitline.hr == 140.0].avgSpeed.iloc[0]
print "MAF "
print mafScore
except:
mafScore = np.nan
fitline_json = fitline.to_json(orient='records')
# getting summary info for run (as one-entry dict)
runSummary = thresher.getSingleSummaryDf(dfi)
# adding mafScore to summary
runSummary['mafScore'] = mafScore
print runSummary
# adding predicted hr and speed values
#dfi = thresher.getPred(dfi)
# saving entry to database
Activity.objects.create(act_id = activityId, name=str(activities[i].name), description=activities[i].description, act_type=activities[i].type, date=activities[i].start_date_local, timezone=activities[i].timezone, df=dfi.to_json(orient='records'), avgHr=runSummary['avgHr'], hrVar=runSummary['variation'], realMiles=runSummary['realMiles'], recovery=runSummary['recovery'], easy=runSummary['easy'], stamina=runSummary['stamina'], impulse=runSummary['impulse'], totalTime=runSummary['totalTime'], totalDist=runSummary['totalDist'], climb=runSummary['climb'], fitline=fitline_json, mafScore=mafScore, athlete=ath)
# updating runs summary
existingSummary = existingSummary.append(runSummary, ignore_index=True)
existingFitlines = existingFitlines.append(fitline, ignore_index=True)
masterList = masterList.append(dfi, ignore_index=True)
except:
continue
# saving updated runs summary to athlete profile
ath.runsSummary = existingSummary.to_json(orient='records')
ath.save(update_fields=['runsSummary'])
existingSummary.to_pickle("runsSummary.txt")
# saving updated runs summary to athlete profile
ath.fitLines = existingFitlines.to_json(orient='records')
ath.save(update_fields=['fitLines'])
ath.masterList = masterList.to_json(orient='records')
ath.save(update_fields=['masterList'])
# testing...
existingSummary = pd.read_json(ath.runsSummary)
#print(existingSummary)
existingFitlines = pd.read_json(ath.fitLines)
#print(existingFitlines)
global path
path = os.path.dirname(__file__)
# updating dataframe, pickling for use in other views
#global df
#df = thresher.masterAssemble(client)
masterDf = pd.read_json(ath.masterList)
#print(masterDf)
masterDf.to_pickle(str(path)+"/"+str(athlete.id)+"masterDf.txt")
return render(request, 'stravaChimp/authorization.html', {'code':code, 'access_token':access_token, 'athleteId':athleteId})
def massive_test(access_token, athlete_id):
client = Client(access_token=access_token)
mysegments = {} # all segments a user has ridden
# get athlete activities
athlete_from_db = Athlete.objects.get(strava_id=athlete_id)
activities = client.get_activities(limit=5, before=athlete_from_db.oldest_activity_date) # API call
# per activity, get segment efforts
for activity in activities:
if activity.type not in ['Ride', 'ride']:
continue
try:
# if activity already exists in db, skip it
Activity.objects.get(strava_id=activity.id)
continue
except Activity.DoesNotExist:
new_activity = Activity()
new_activity.strava_id = activity.id
new_activity.start_lat = activity.start_latitude
new_activity.start_long = activity.start_longitude
new_activity.start_date = activity.start_date
new_activity.save()
# update newest / oldest activity dates
if athlete_from_db.newest_activity_date is None:
athlete_from_db.newest_activity_date = activity.start_date
athlete_from_db.oldest_activity_date = activity.start_date
else:
if activity.start_date > athlete_from_db.newest_activity_date:
athlete_from_db.newest_activity_date = activity.start_date
elif activity.start_date < athlete_from_db.oldest_activity_date:
athlete_from_db.oldest_activity_date = activity.start_date
athlete_from_db.save()
segment_efforts = client.get_activity(activity.id).segment_efforts # API call
# per segment effort
for segment in segment_efforts:
mysegments[segment.segment.id] = segment.segment # save to db
# check if segment leaderboard contains any friends
for key, segment in mysegments.iteritems():
leaderboard = client.get_segment_leaderboard(key, following=True).entries # API call (possibly lots, depends on number of segments)
# get friend with time < athlete time
for i, entry in enumerate(leaderboard):
if entry.athlete_id == athlete_id:
me = entry
if i == 0:
# I'm already the winner!
break
j = 1
while j <= i and leaderboard[i - j].elapsed_time == me.elapsed_time:
# check for ties, compare each entry from i to zero (possibly)
j += 1
if leaderboard[i - j].elapsed_time == me.elapsed_time:
# if they're still tied at the end of the loop, I don't want to see it
break
other = leaderboard[i - j]
try:
new_segment = ChallengedSegment.objects.get(my_id=athlete_id, segment_id=segment.id)
except ChallengedSegment.DoesNotExist:
new_segment = ChallengedSegment()
new_segment.my_id = athlete_id
new_segment.their_id = other.athlete_id
new_segment.their_name = other.athlete_name
new_segment.my_pr = me.activity_id
new_segment.their_pr = other.activity_id
new_segment.my_time = str(me.elapsed_time)
new_segment.their_time = str(other.elapsed_time)
new_segment.difference = str(me.elapsed_time - other.elapsed_time)
new_segment.segment_id = segment.id
new_segment.segment_name = segment.name
new_segment.segment_distance = str(unithelper.miles(segment.distance))
new_segment.save()
break # we already found my entry, why keep looking through the list?
class artbot(PyBot):
def bot_init(self):
"""
Custom initialization. Specify any configuration options you want to
override, as in particular your OAuth credentials.
"""
#############################
# #
# Twitter OAuth Credentials #
# #
# FILL THESE IN! #
# #
#############################
self.config['api_key'] = 'your_api_key'
self.config['api_secret'] = 'your_api_secret'
self.config['access_key'] = 'your_access_key'
self.config['access_secret'] = 'your_access_secret'
#############################
# #
# Other config options #
# #
# Fill these in if you want #
# or otherwise need to. #
# #
#############################
self.config['strava_access_token'] = 'your_strava_token'
self.config['update_day'] = 0
self.config['update_hour'] = 13
self.config['update_minute'] = 13
self.config['tweet_interval'] = self._compute_interval
# Create the Strava client.
self.client = Client(access_token=self.config['strava_access_token'])
def on_tweet(self):
# First, pull in the stats from Strava.
current = datetime.datetime.now()
last_week = current + datetime.timedelta(weeks=-1)
after = datetime.datetime(last_week.year, last_week.month,
last_week.day)
activities = self.client.get_activities(after=after)
# Second, filter by activity type and time frame.
lf = [a for a in activities if a.start_date_local.day != current.day]
num_activities = len(lf)
l = [a.id for a in lf if a.type == 'Run']
# Third, tabulate up the stats for mileage and calories.
mileage = 0.0
calories = 0.0
for activity_id in l:
activity = self.client.get_activity(activity_id)
distance = unithelper.miles(activity.distance)
mileage += round(distance.num, 2) # Rounds to 2 sig figs.
calories += activity.calories
calories = int(calories)
# Finally, use the stats to craft a tweet. This can be any format
# you want, but I'll use the example one from the start of the post.
tweet = "My training last week: {:d} workouts for {:.2f} miles and {:d} calories burned.".format(
num_activities, mileage, calories)
self.update_status(tweet)
def _compute_interval(self):
"""
This is a little more sophisticated than the method in the original
blog post. This is to provide for *exactly* specifying when we want
a post to be made, down to the minute.
"""
now = datetime.datetime.now()
target = datetime.datetime(year=now.year,
month=now.month,
day=now.day,
hour=self.config['update_hour'],
minute=self.config['update_minute'])
days_ahead = self.config['update_day'] - now.weekday()
if (days_ahead < 0) or (days_ahead == 0 and (target - now).days < 0):
days_ahead += 7
td = target + datetime.timedelta(days=days_ahead)
interval = int((td - datetime.datetime.now()).total_seconds())
return interval
# My data
my_data = client.get_athlete() # athlete details
me = {}
me["id"] = my_data.id
me["name"] = my_data.firstname + " " + my_data.lastname
me["city"] = my_data.city
my_bikes = my_data.bikes
bikes = {}
for b in my_bikes:
bike = {}
bike[b.id] = b.name
bikes.update(bike)
me["bikes"] = bikes
# Fetch activities this year
my_activities = client.get_activities(after=datetime(2015, 1, 1)) #(limit=5)
act = []
for a in my_activities:
act.append(a)
# Fetch every activity % make collections
cycling_collection = []
swimming_collection = []
for i in range(len(act)):
print "fetching activity " + str(i)
id = act[i].id
activity = client.get_activity(id)
# Activity collections
if activity.type == "Ride":
from stravalib import Client
import csv
client_id = '28201'
my_token = '06e91657960068f2c92e2e02419934f6493fe5b6'
client = Client(access_token=my_token)
activities = client.get_activities(limit=100)
rides = list(activities)
with open("activities.csv", "w", newline="") as file:
csv_writer = csv.writer(file)
for ride in rides:
date = str(ride.start_date_local)[:10]
distance = str(ride.distance)[:-5]
elevation = str(ride.total_elevation_gain).rstrip(" m")
csv_writer.writerow([date, distance, elevation])
# activity = client.get_activity(1801822008)
# print(activity.distance)
# print(activity.moving_time)
# print(activity.average_speed)
# print(activity.total_elevation_gain)
def get_activities(self, token):
client = Client(token)
user = client.get_athlete()
# Update StavaUser
lastUpdate = datetime.now()
strUser = StravaUser.objects.filter(uid=user.id)
print('strUser='******'lastUpdate=', lastUpdate)
#d = datetime(2018, 5, 5)
date_1_day_ago = lastUpdate - timedelta(days=1)
activities = client.get_activities(after=date_1_day_ago, limit=50)
#activities = client.get_activities(after=d,limit=15)
act = None
nbItem = 0
nbAct = 0
for activity in activities:
nbAct += 1
print('NbAct=', nbAct)
initNewActivities = False
newUser = False
segment = 15
begin = 0
end = begin + segment
currentList = Activity.objects.filter(
uid=client.get_athlete().id).order_by('-strTime')[begin:end]
if not currentList.exists():
newUser = True
while (currentList.exists() or newUser):
print('currentList=', currentList)
print('begin=', begin)
print('end=', end)
actList = []
for actItem in currentList:
#print (actItem)
serializer = ActivityItemSerializer(actItem)
#print ('serializer.data: ',serializer.data)
actList.append(serializer.data)
data = {'nbAct': nbAct, 'currentAct': nbItem, 'activities': actList}
sendMessage('actList', data, strUser[0].channel_name)
actList.clear()
if not initNewActivities:
for activity in activities:
StravaUser.objects.filter(uid=user.id).update(
currentActIndex=nbItem, nbActToRetreive=nbAct)
act = client.get_activity(activity.id)
strDate = act.start_date.strftime("%Y-%m-%d %H:%M:%S")
#print ('uid=',user.id)
#print ('start_date=',strDate)
#print ('act.distance=',act.distance)
#print ('act.type=',act.type)
dist = re.sub(' .*$', '', str(act.distance))
#print ('dist=',dist)
strDistance = format(float(dist) / 1000, '.2f')
#print ('distance=',strDistance)
#print ('stravaId=',act.upload_id)
print('name=', act.name)
#print ('time=',act.elapsed_time)
#print ('splits_metric=',act.splits_metric)
if not Activity.objects.filter(stravaId=activity.id).exists():
workout = Workout.objects.create(name=act.name)
print('wid=', workout.id)
print('stravaId=', activity.id)
activity.wid = workout.id
stravaAct = Activity(strTime=strDate,strDist=strDistance,distance=act.distance,\
time=act.elapsed_time,label=act.name,stravaId=activity.id,wid=workout.id,workout_id=workout.id,\
resolution=strUser[0].resolution,uid=user.id,type=act.type,state="c",progress=0)
stravaAct.save()
Workout.objects.filter(id=workout.id).update(
actId=stravaAct.id)
split = Split.objects.filter(workout__id=workout.id)
print('Split first element=', split.count())
if not split.count():
if split is not None:
objs = [
Split(split_index=i,
split_distance=split.distance,
split_time=split.elapsed_time,
workout=workout)
for i, split in enumerate(act.splits_metric)
]
split = Split.objects.bulk_create(objs)
# Send result list to client
for actItem in Activity.objects.filter(
stravaId=activity.id):
#print (actItem)
serializer = ActivityItemSerializer(actItem)
# pre-process Json for client response to get workout
self.result = processJsonDataBackup.delay(
token, workout.id, json.dumps(serializer.data))
#print ('serializer.data: ',serializer.data)
actList.insert(0, serializer.data)
else:
Activity.objects.filter(stravaId=activity.id).update(
strTime=strDate,
strDist=strDistance,
resolution=strUser[0].resolution)
nbItem += 1
data = {
'nbAct': nbAct,
'currentAct': nbItem,
'activities': actList
}
sendMessage('actList', data, strUser[0].channel_name)
initNewActivities = True
begin = end
end = begin + segment
currentList = Activity.objects.filter(
uid=client.get_athlete().id).order_by('-strTime')[begin:end]
newUser = False
if act is not None:
print('Update user last_date')
strUser.update(lastUpdate=datetime.now())
return {'current': nbItem, 'total': nbAct}
class Tracker:
def __init__(self):
# Strava client to hold information for tracker.
self.client = Client()
# Time token expires at.
self.token_expires_at_ = None
# Client information.
self.client_id = None
self.client_secret = None
# Time in seconds between refreshes.
self.sleep_time_ = 300
# Number of target activities per week.
self.target_ = 4
# Private display object.
self.display_ = Display()
# Activity tracking variables.
self.start_date = datetime.datetime.utcnow().date()
self.next_week = self.start_date + datetime.timedelta(weeks=1)
self.week_streak = 0
self.num_activities = 0
# Filename of save file.
self.save_file_ = 'streak.yaml'
def set_expiration(self, token_expires_at):
self.token_expires_at_ = token_expires_at
def set_client_info(self, client_id, client_secret):
self.client_id = client_id
self.client_secret = client_secret
def save_status(self):
save_obj = {'start_date' : self.start_date, 'next_week' : self.next_week,
'week_streak' : self.week_streak, 'num_activities' : self.num_activities}
with open(self.save_file_, 'wb') as save_file:
pickle.dump(save_obj, save_file)
def load_status(self):
save_obj = None
try:
with open(self.save_file_, 'rb') as save_file:
save_obj = pickle.load(save_file)
self.start_date = save_obj['start_date']
self.next_week = save_obj['next_week']
self.week_streak = save_obj['week_streak']
self.num_activities = save_obj['num_activities']
except (OSError, IOError, EOFError) as e:
print('Nothing in this save file, going to save defaults.')
self.save_status()
def update(self):
self.save_status()
self.display_.show(self.week_streak, self.target_ - self.num_activities, self.target_)
def run(self):
# Save start date/time
# Ask Strava for activities since 1 week ago
# If len(activities) >= goal increment streak
# Check that token won't expire in 12 hours
# If token needs refreshing, refresh it
# Sleep for sleep_time
self.load_status()
self.update()
while(True):
# Refresh token if necessary.
if time.time() > self.token_expires_at_:
refresh_response = self.client.refresh_access_token(client_id=self.client_id,
client_secret=self.client_secret,
refresh_token=self.client.refresh_token)
self.token_expires_at_ = refresh_response['expires_at']
print('Refreshing token, new one expires at {}'
.format(str(refresh_response['expires_at'])))
new_activities = len(list(self.client.get_activities(after = self.start_date.isoformat())))
# Handle null return from Strava servers.
if not new_activities:
new_activities = 0
print(new_activities)
if new_activities != self.num_activities:
print("New activities detected!")
self.num_activities = new_activities
self.update()
for activity in self.client.get_activities(after = self.start_date.isoformat()):
print("{0.name} {0.moving_time}".format(activity))
# Check if we've hit the target for this week.
if self.num_activities >= self.target_:
self.week_streak += 1
self.update()
cur_date = datetime.datetime.utcnow().date()
# Check if it's next week.
if cur_date == self.next_week:
# Check if we haven't hit our target and reset.
if self.num_activities < self.target_:
self.week_streak = 0
# Advance the date to a week from now.
self.start_date = cur_date
self.next_week = cur_date + datetime.timedelta(weeks=1)
self.update()
time.sleep(self.sleep_time_)
def access_token_and_database():
"""Check user authorization, get temporary authorization code, exchange code for token,
and manage database."""
# If user authorizes, "code" will be included in query string
# If user denies, error message "access_denied" will be included in query string
error = request.args.get('error', '')
if error:
return "Error: " + error
code = request.args.get("code")
access_token = client.exchange_code_for_token(
client_id=oauth_credentials["CLIENT_ID"],
client_secret=oauth_credentials["CLIENT_SECRET"],
code=code)
authenticated_athlete = Client(access_token=access_token)
# Get authenticated athlete firstname (http://strava.github.io/api/v3/athlete/).
name = authenticated_athlete.get_athlete().firstname
# Check whether authenticated_athlete already exists in database. If true, delete activities.
# If false, add athlete.
athlete_in_database = Athlete.query.filter_by(
access_token=access_token).first()
if athlete_in_database:
activities_to_delete = Activity.query.filter_by(
athlete_id=athlete_in_database.id)
for activity in activities_to_delete:
db.session.delete(activity)
db.session.commit()
else:
athlete_in_database = Athlete(access_token=access_token,
name=name,
activities=[])
db.session.add(athlete_in_database)
db.session.commit()
######################################################################
# Get authenticated athlete list of activities and store to database #
######################################################################
# Define variable for the last year of activities
one_year_ago = datetime.datetime.utcnow() - datetime.timedelta(days=365)
activities = authenticated_athlete.get_activities(after=one_year_ago)
for activity in activities:
if activity.has_heartrate and activity.average_speed.num > 0:
value = (activity.average_speed / activity.average_heartrate)
# Stravalib is returning Activity classes that work with units, requiring ".num" for some
entry = Activity(
distance=activity.distance.num,
moving_time=activity.moving_time,
total_elevation_gain=activity.total_elevation_gain.num,
type=activity.type,
start_date=activity.start_date, # Column = 4
start_date_local=activity.start_date_local,
average_speed=activity.average_speed.num,
average_heartrate=activity.average_heartrate,
aerobic_value=value.num, # Column = 8
athlete_id=athlete_in_database.id)
db.session.add(entry)
db.session.commit()
message = "<center>" \
"<p>Hello, {}. Thank you for authorizing with Strava.<br/><br/>"\
"<a href=http://0.0.0.0:8080/visualization.png>" \
"Ready to analyze your activities?</a><br/><br/>" \
"<a><img src='static/img/api_logo_pwrdBy_strava_stack_gray.png'></a></p>" \
"</center>".format(name)
return message
class Strava(object):
def __init__(self, cfg):
self.token = cfg.get('token')
self.convert_swim = cfg.get('convert_swim')
self.client = Client(access_token=self.token)
self.athlete = self.client.get_athlete()
self.activities = self.client.get_activities()
print('Loading data for: {} {}'.format(self.athlete.firstname.encode('utf8'), self.athlete.lastname.encode('utf8')))
def json(self):
out = []
for a in self.activities:
out.append(self._format_activity(a))
return out
def _format_activity(self, a):
out = {
'measurement': 'activity',
'time': a.start_date.isoformat(),
'fields': {
'distance': a.distance.num,
'moving_time': a.moving_time.total_seconds(),
'elapsed_time': a.elapsed_time.total_seconds(),
'total_elevation_gain': a.total_elevation_gain.num,
},
'tags': {
'type': a.type,
'athlete': a.athlete.id,
},
}
return out
def _get_param_from_activity(self, a):
return {
'name': a.name,
'activity_type': a.type,
'start_date_local': a.start_date_local.isoformat(),
'elapsed_time': int(a.elapsed_time.total_seconds()),
'description': a.description,
'distance': a.distance,
'private': a.private,
}
def convert_swimming(self):
print(self.convert_swim)
lap_time_min = self.convert_swim['lap_time_min']
lap_time_max = self.convert_swim['lap_time_max']
lap_distance = self.convert_swim['lap_distance']
for a in self.activities:
if a.type == 'Swim' and a.distance.num == 0 and not a.description and not re.match('DELETE:.*', a.name):
print(self._format_activity(a))
problem = 0
distance = 0
# count laps and distances
for lap in a.laps:
if lap_time_min < lap.elapsed_time.total_seconds() < lap_time_max:
distance += lap_distance
else:
problem += 1
break
if problem == 0 and distance > 0:
print('Fine:')
new_activity = self._get_param_from_activity(a)
new_activity['distance'] = float(distance)
if not new_activity['description']:
new_activity['description'] = 'Converted by Sport Sucker.\nActivity #{}'.format(a.id)
print('Create new')
print(new_activity)
new_activity_saved = self.client.create_activity(**new_activity)
if not a.description:
self.client.update_activity(
a.id,
name='DELETE: {}'.format(a.name),
description='Should be deleted, replaced by #{}'.format(new_activity_saved.id)
)
else:
print('UNABLE to convert swimming')
debug = False
METERS_IN_A_MILE = 1609.34
pacific_timezone = timezone('America/Los_Angeles')
#mmf = MapMyFitness(api_key=MMF_CLIENT_KEY, access_token=MMF_ACCESS_TOKEN)
strava = Client( access_token=STRAVA_ACCESS_TOKEN)
fitbit_client = fitbit.Fitbit( FITBIT_CLIENT_KEY, FITBIT_CLIENT_SECRET, user_key=FITBIT_USER_KEY, user_secret=FITBIT_USER_SECRET)
# Only grab the last 10 activities
activities = strava.get_activities( limit = 10 )
#for activity in activities:
# print activity.type
# Iterate through all valid activity types
#for activity_id in MMF_BIKE_ACTIVITY_TYPES:
# workouts = workouts + mmf.workout.search( user=MMF_USER_ID, activity_type=activity_id, started_after=started_after )
for activity in activities:
start_datetime = activity.start_date_local
start_date = start_datetime.strftime( '%Y-%m-%d' )
start_time = start_datetime.strftime( '%H:%M' )
duration_milliseconds = int( 1000 * activity.moving_time.total_seconds() )
distance = unithelper.miles( activity.distance ).num
import os
import sys
sys.path.insert(0,os.path.join('..','Resources','AccessInformation'))
from accessinformation import access_token
from flask import Flask, render_template,jsonify
from stravalib import Client , unithelper
import json
client = Client(access_token )
print(client.get_athlete())
print([float(unithelper.miles(i.distance)) for i in client.get_activities()])
print([i.segment_efforts for i in client.get_activities()])
with open('../Data/JSONData/MainDataset.json') as f:
data = json.load(f)
app = Flask(__name__)
@app.route("/")
def homepage():
return(render_template('index.html'))
@app.route("/data")
def dataset():
return(jsonify(data))
if __name__ == '__main__':
app.run()
from stravalib import Client
import matplotlib.pyplot as plt, numpy as np
import api
client = Client(access_token=api.access_token)
activities = list(client.get_activities()) # Get current athlete details
id = activities[0].id
types = ['time', 'altitude', 'latlng', 'moving', 'distance']
s = client.get_activity_streams(id, types=types)
distance = s['distance']
altitude = s['altitude']
latlng = s['latlng']
y, x = zip(*latlng.data)
fig, ax = plt.subplots(2)
ax[0].plot(distance.data, altitude.data, 'k') # elevation profile
ax[1].plot(x, y, 'k') # route overview
ax[1].set_aspect('equal')
plt.show()
# Elevation heatmap
fig, ax = plt.subplots()
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segments,
class artbot(PyBot):
def bot_init(self):
"""
Custom initialization. Specify any configuration options you want to
override, as in particular your OAuth credentials.
"""
#############################
# #
# Twitter OAuth Credentials #
# #
# FILL THESE IN! #
# #
#############################
self.config['api_key'] = 'your_api_key'
self.config['api_secret'] = 'your_api_secret'
self.config['access_key'] = 'your_access_key'
self.config['access_secret'] = 'your_access_secret'
#############################
# #
# Other config options #
# #
# Fill these in if you want #
# or otherwise need to. #
# #
#############################
self.config['strava_access_token'] = 'your_strava_token'
self.config['update_day'] = 0
self.config['update_hour'] = 13
self.config['update_minute'] = 13
self.config['tweet_interval'] = self._compute_interval
# Create the Strava client.
self.client = Client(access_token = self.config['strava_access_token'])
def on_tweet(self):
# First, pull in the stats from Strava.
current = datetime.datetime.now()
last_week = current + datetime.timedelta(weeks = -1)
after = datetime.datetime(last_week.year, last_week.month, last_week.day)
activities = self.client.get_activities(after = after)
# Second, filter by activity type and time frame.
lf = [a for a in activities if a.start_date_local.day != current.day]
num_activities = len(lf)
l = [a.id for a in lf if a.type == 'Run']
# Third, tabulate up the stats for mileage and calories.
mileage = 0.0
calories = 0.0
for activity_id in l:
activity = self.client.get_activity(activity_id)
distance = unithelper.miles(activity.distance)
mileage += round(distance.num, 2) # Rounds to 2 sig figs.
calories += activity.calories
calories = int(calories)
# Finally, use the stats to craft a tweet. This can be any format
# you want, but I'll use the example one from the start of the post.
tweet = "My training last week: {:d} workouts for {:.2f} miles and {:d} calories burned.".format(num_activities, mileage, calories)
self.update_status(tweet)
def _compute_interval(self):
"""
This is a little more sophisticated than the method in the original
blog post. This is to provide for *exactly* specifying when we want
a post to be made, down to the minute.
"""
now = datetime.datetime.now()
target = datetime.datetime(year = now.year, month = now.month, day = now.day,
hour = self.config['update_hour'], minute = self.config['update_minute'])
days_ahead = self.config['update_day'] - now.weekday()
if (days_ahead < 0) or (days_ahead == 0 and (target - now).days < 0):
days_ahead += 7
td = target + datetime.timedelta(days = days_ahead)
interval = int((td - datetime.datetime.now()).total_seconds())
return interval
def authorization(request):
client = Client()
code = request.GET['code']
access_token = client.exchange_code_for_token(
client_id=MY_STRAVA_CLIENT_ID,
client_secret=MY_STRAVA_CLIENT_SECRET,
code=code)
# making a global variable to be used across views. don't know how this will work in practice
client = Client(access_token=access_token)
athlete = client.get_athlete() # Get current athlete details
global athleteId
athleteId = athlete.id
# if athlete doesn't exist, add them
if len(Athlete.objects.filter(athleteId=athleteId)) == 0:
ath = Athlete.objects.create(
name=str(athlete.firstname + ' ' + athlete.lastname),
athleteId=athleteId,
profilePic=athlete.profile,
city=athlete.city,
country=athlete.country,
sex=athlete.sex,
premium=athlete.premium,
created_at=athlete.created_at,
updated_at=athlete.updated_at,
followers=athlete.follower_count,
friends=athlete.friend_count,
email=athlete.email,
weight=athlete.weight,
meas_pref=athlete.measurement_preference,
runsSummary=DataFrame({}).to_json(orient='records'),
fitLines=DataFrame({}).to_json(orient='records'),
masterList=DataFrame({}).to_json(orient='records'))
ath.profilePic.name = "rudyzPic"
ath.save(update_fields=['profilePic'])
# if athlete already exists, draw their file
elif len(Athlete.objects.filter(athleteId=athleteId)) == 1:
ath = Athlete.objects.get(athleteId=athleteId)
############################################
##### compiling new runs, updating summary
# athlete's existing runs summary
existingSummary = DataFrame(pd.read_json(ath.runsSummary))
existingFitlines = DataFrame(pd.read_json(ath.fitLines))
masterList = DataFrame(pd.read_json(ath.masterList))
activities = list(client.get_activities())
# activity IDs of runs already in the system
try:
ids = existingSummary.activityId
except AttributeError:
ids = []
for i in range(len(activities)):
#for i in range(30,37):
# Ignoring activities already in the system
if (len(ids) == 0) or (float(activities[i].id) not in list(ids)):
try:
# compiling df for raw json-ization
activityId = activities[i].id
run = client.get_activity_streams(activityId,
types=[
'time', 'latlng',
'distance', 'heartrate',
'altitude', 'cadence'
])
latlng = run['latlng'].data
time = run['time'].data
distance = run['distance'].data
heartrate = run['heartrate'].data
altitude = run['altitude'].data
cadence = run['cadence'].data
date = activities[i].start_date_local
activity = activityId
dfi = thresher.assemble(date, activityId, heartrate, distance,
time, altitude, latlng, cadence)
# basic cleanup, only removing totally unreasonable values
dfi = thresher.basicClean(dfi)
# if we ever want to try our hand at improving strava's speed data (ie by predicting speed when GPS blanks), intervene here:
#dfi = thresher.addDistDeltas(dfi)
try:
fitline = thresher.getFitlineLws(
dfi) # this adds speed-shifted columns
except:
fitline = pd.DataFrame({})
try:
mafScore = fitline[fitline.hr == 140.0].avgSpeed.iloc[0]
print "MAF "
print mafScore
except:
mafScore = np.nan
fitline_json = fitline.to_json(orient='records')
# getting summary info for run (as one-entry dict)
runSummary = thresher.getSingleSummaryDf(dfi)
# adding mafScore to summary
runSummary['mafScore'] = mafScore
print runSummary
# adding predicted hr and speed values
#dfi = thresher.getPred(dfi)
# saving entry to database
Activity.objects.create(act_id=activityId,
name=str(activities[i].name),
description=activities[i].description,
act_type=activities[i].type,
date=activities[i].start_date_local,
timezone=activities[i].timezone,
df=dfi.to_json(orient='records'),
avgHr=runSummary['avgHr'],
hrVar=runSummary['variation'],
realMiles=runSummary['realMiles'],
recovery=runSummary['recovery'],
easy=runSummary['easy'],
stamina=runSummary['stamina'],
impulse=runSummary['impulse'],
totalTime=runSummary['totalTime'],
totalDist=runSummary['totalDist'],
climb=runSummary['climb'],
fitline=fitline_json,
mafScore=mafScore,
athlete=ath)
# updating runs summary
existingSummary = existingSummary.append(runSummary,
ignore_index=True)
existingFitlines = existingFitlines.append(fitline,
ignore_index=True)
masterList = masterList.append(dfi, ignore_index=True)
except:
continue
# saving updated runs summary to athlete profile
ath.runsSummary = existingSummary.to_json(orient='records')
ath.save(update_fields=['runsSummary'])
existingSummary.to_pickle("runsSummary.txt")
# saving updated runs summary to athlete profile
ath.fitLines = existingFitlines.to_json(orient='records')
ath.save(update_fields=['fitLines'])
ath.masterList = masterList.to_json(orient='records')
ath.save(update_fields=['masterList'])
# testing...
existingSummary = pd.read_json(ath.runsSummary)
#print(existingSummary)
existingFitlines = pd.read_json(ath.fitLines)
#print(existingFitlines)
global path
path = os.path.dirname(__file__)
# updating dataframe, pickling for use in other views
#global df
#df = thresher.masterAssemble(client)
masterDf = pd.read_json(ath.masterList)
#print(masterDf)
masterDf.to_pickle(str(path) + "/" + str(athlete.id) + "masterDf.txt")
return render(request, 'stravaChimp/authorization.html', {
'code': code,
'access_token': access_token,
'athleteId': athleteId
})
