The newbie cloud architect diary

• Obviously I already have a Strava account and my activities uploaded
• You need to register a new API client which returns an application ID and a secret key
• Python project with the following requirements.txt

chardet
matplotlib
pandas
requests
stravalib
urllib3

• Python virtual environment creation

virtualenv -p $(which python3) venv 
source venv/bin/activate 
pip3 install -r requirements.txt

# get temporary access_code or access_token (depending on input parameters)
import requests, webbrowser
from stravalib import Client
client = Client()

# obtain a new access token if a refresh token is available
if args.refresh_token is not None:
    token_url = "https://www.strava.com/api/v3/oauth/token"
    token_opt = {'client_id': args.client_id, 'client_secret': args.client_secret, 'grant_type': 'refresh_token', 'refresh_token': args.refresh_token}
    x = requests.post(token_url, data = token_opt)
    print(x.text)
    sys.exit("You are ready to use app.py")

# have the user sign in to strava and authorize
if args.access_code is None:
    url = client.authorization_url(client_id=args.client_id,
        redirect_uri='http://127.0.0.1:5000/authorization')
    # authorize (you might have to login first)
    webbrowser.open(url, new=2)
    args.access_code = input("Copy your authorization code from response URL here: ").strip()

# get access_token from access_code
if args.access_code is not None:
    access_dict = client.exchange_code_for_token(
        client_id=args.client_id,
        client_secret=args.client_secret,
        code=args.access_code
    )
    print(access_dict)
    os.putenv("STRAVA_ACCESS_TOKEN", access_dict['access_token'])
    os.putenv("STRAVA_REFRESH_TOKEN", access_dict['refresh_token'])
    print("You are ready to use app.py")
    os.system('bash') # just a tweak, creating a subprocess for re-using env
    sys.exit()

# setup program usage and parse arguments
import os, sys, argparse
parser = argparse.ArgumentParser()
parser.add_argument("--access_token", "-t", help="Access Token")
args = parser.parse_args()
# terminate if access token is not set
if args.access_token is None:
    sys.exit("Please specify an Access Token (--access_token) or read Usage (--help)")

# instanciate strava client
from stravalib import Client, exc
# stop at wrong token
try:
    # https://pythonhosted.org/stravalib/api.html#stravalib.client.Client
    client = Client(access_token=args.access_token)
except exc.AccessUnauthorized:
    sys.exit("Your token is not valid. Please run login.py to get one.")
# stop at API rate limit
try:
    athlete = client.get_athlete()
    print("Hello ", athlete.firstname.strip(), " ", athlete.lastname.strip(), "!")
except exc.RateLimitExceeded:
    sys.exit("API rate limit exceeded. Please retry in a bit.")

# prepare data collection
import pandas as pd
# start/end index might be usefull later to identify effort position in activity stream
df = pd.DataFrame(columns=['start_index','end_index','dist','avg_grade','date','avg_power','duration'])
# stop at API rate limit
try:
    # work on last activity only
    activities = client.get_activities(limit=1) # request last activity only
except exc.RateLimitExceeded:
    sys.exit("API rate limit exceeded. Please retry in a bit.")

Let's assume last activity is a ride that we want to analyze. The data model of activity/effort differenciates Summary from Detail objects, where Details are only viewable by the object owner.

# work on last activity only
act_summary = next(activities)
# stop at API rate limit
try:
    # https://developers.strava.com/docs/reference/#api-models-SummaryActivity
    act_detail = client.get_activity(act_summary.id, include_all_efforts="true")
except exc.RateLimitExceeded:
    sys.exit("API rate limit exceeded. Please retry in a bit.")

Persist Activity metadata in a text file.

# https://developers.strava.com/docs/reference/#api-models-DetailedActivity
# store activity summary
with open(str(act_summary.id) + ".txt", "w") as text_file:
    print("Name: {}".format(act_summary.name), file=text_file)
    print("Date: {}".format(act_summary.start_date_local), file=text_file)
    print("Dist: {} km".format(str(act_summary.distance / 1000).split(' ')[0]), file=text_file)
    print("Elevation: {}".format(act_summary.total_elevation_gain), file=text_file)
    print("Time: {}".format(act_summary.moving_time), file=text_file)
    print("Speed: {} km/h".format(str(act_summary.average_speed * 3.6).split(' ')[0]), file=text_file)
    print("Power: {} w".format(act_summary.average_watts), file=text_file)

# get segment efforts
for seg_effort_summary in act_detail.segment_efforts:
    try:
        # https://developers.strava.com/docs/reference/#api-models-SummarySegmentEffort
        seg_effort_detail = client.get_segment_effort(seg_effort_summary.id)
        # https://developers.strava.com/docs/reference/#api-models-DetailedSegmentEffort
        # https://developers.strava.com/docs/reference/#api-models-SummarySegment
        seg_summary = client.get_segment(seg_effort_detail.segment.id)
        df.loc[len(df)] = [
            seg_effort_detail.start_index, seg_effort_detail.end_index, 
            seg_effort_summary.distance,
            seg_summary.average_grade,
            seg_effort_detail.start_date_local,
            seg_effort_detail.average_watts,
            seg_effort_detail.elapsed_time
        ]
    except exc.RateLimitExceeded:
        print ("API rate limit exceeded. Data collected until now will be persisted.")
        break

$ cat *.txt 
Name: Morning Ride
Date: 2020-05-31 10:27:14
Dist: 70.20 km
Elevation: 463.90 m
Time: 2:28:41
Speed: 28.33 km/h
Power: 140.5 w

# result overview and serialization
print(df)
df.to_pickle(str(act_summary.id) + '.pkl')

import pandas as pd

# read and filter previously serialized data
df = pd.read_pickle("./efforts.pkl")
df = df[(df.avg_grade > -3) & (df.avg_grade < 24)]
print(df.head())

import matplotlib.pyplot as plt

# draw bar chart of power per elevation grade
plt.bar(df['avg_grade'],df['avg_power'], 0.2, alpha=0.5)
plt.xlabel('Grade (%)')
plt.ylabel('Power (W)')
plt.title('Activity efforts')
plt.show()