aadm/sportlog.md

## sportlog.md

      
    Raw
  

              sportlog.md
            
          
    This Python script is meant to be run on a journal file created with jrnl.sh where I log all my sports activities.
For example, if today I've run 7km in 40 minutes:
$ jrnl 40m 7km @CORSA

If I forgot to add last Sunday's bike ride and yesterday's run:
$ jrnl yesterday: 20m 5km @CORSA
$ jrnl sunday: 40km @BICI

The resulting jrnl file has this format:
2021-03-30 29m 5km @CORSA
2021-04-10 54km @BICI
2021-04-11 72m 12.5km @CORSA
2021-04-25 10km+800m @TRAIL
2021-04-25 18km @BICI
2021-04-27 39m 7.4km @CORSA

The names of the activities are derived from the tags assigned to each entry, in the example jrnl file above I have:

@CORSA for running
@BICI for biking
@TRAIL for trail running

In sportlog.py, the name of the jrnl file is hardcoded so remember to change it.

  
## sportlog.py
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import pandas as pd
from datetime import datetime, timedelta
import re
import sys

def read_jrnl_sport(jrnlfile, colormap='Pastel1'):
    # convert datafile to Pandas DataFrame
    df = pd.read_csv(jrnlfile, sep='@', names=['tmp', 'sport'])

    # extract date and copy to `date` column
    temp = df.tmp.str.extract('.*\[(.*)\].*')
    df['date'] = temp.astype('datetime64[ns]')

    # set date as index
    df.set_index('date', inplace=True)

    # extract description and copy to `desc` column
    df['desc'] = df['tmp'].str.slice(13)

    # set `sport` column to categorical
    df['sport'] = df.sport.astype('category')

    # make `sport_id` column with numerical ids
    # corresponding to categories
    df['sport_id'] = df.sport.cat.codes

    # assign one color to each sport activity
    allsports = df.sport.cat.categories
    list_of_colors = plt.cm.get_cmap(colormap).colors
    cdict = dict(zip(np.unique(allsports), list_of_colors))

    # remove `tmp` column
    return df.drop(['tmp'], axis=1), cdict


def select_period(df, year=None, date=None, days=30, forward=False):
    '''
    Select period either by specifying a single year
    or a specific date with an interval in days.

    > df_sel = select_period(df, year=2021)

    Select the last 30 days starting now:
    > df_sel = select_period(df, days=30)

    Select the last 30 days starting on a specific date:
    > df_sel = select_period(df, date='2020-06-19', days=30)
    '''
    if year is not None:
        mask = df.index.year == year
    else:
        if date is None:
            date = datetime.now()
        else:
            date = datetime.strptime(date, '%Y-%m-%d')
        if forward:
            start_date = date
            end_date = date + timedelta(days=days)
        else:
            start_date = date - timedelta(days=days)
            end_date = date
        mask = (df.index >= start_date) & (df.index <= end_date)
    return df.loc[mask]


def get_runs(df):
    #----------------------------------
    # FIRST, get trail runs
    trails = df[df.sport=='TRAIL']

    # extracts distances from `desc` column for trail runs
    kilometers = []
    for i, r in trails.iterrows():
        kk = re.search(r'([0-9]*[.])?[0-9]+km', r.desc)
        if kk is not None:
            kilometers.append(kk.group().replace('km',''))
        else:
            kilometers.append(None)
    kkarr = np.asarray(kilometers, dtype=np.float)
    trails = trails.assign(distance=kkarr)

    #----------------------------------
    # SECOND, get normal runs
    runs = df[df.sport=='CORSA']

    # extracts time and distances from `desc` column for runs
    minutes = []
    kilometers = []
    for i, r in runs.iterrows():
        mm = re.search(r'([0-9]*[.])?[0-9]+m', r.desc)
        kk = re.search(r'([0-9]*[.])?[0-9]+km', r.desc)
        if mm is not None:
            minutes.append(mm.group().replace('m',''))
        else:
            minutes.append(None)
        if kk is not None:
            kilometers.append(kk.group().replace('km',''))
        else:
            kilometers.append(None)
    mmarr = np.asarray(minutes, dtype=np.float)
    kkarr = np.asarray(kilometers, dtype=np.float)
    runs = runs.assign(distance=kkarr)
    runs = runs.assign(time=mmarr)

    # set up some filters
    nodist = pd.isna(runs.distance)
    notime = pd.isna(runs.time)
    both = ~notime & ~nodist

    # calculate speed for each activity
    # it will be NaN where either speed or distance is not registered
    runs['speed'] = runs['time'] / runs['distance']

    # calculate avg speed in minutes/km
    avgspeed = runs['speed'].mean()

    # fill in runs where only distance has been recorded
    # time is based on average speed, and speed = average speed
    onlydist = notime & ~nodist
    runs.loc[onlydist, 'time'] = runs[onlydist]['distance'] * avgspeed
    runs.loc[onlydist, 'speed'] = avgspeed

    # fill in runs where only time has been recorded
    # time is based on average speed, and speed = average speed
    onlytime = ~notime & nodist
    runs.loc[onlytime, 'distance'] = runs[onlytime]['time'] / avgspeed
    runs.loc[onlytime, 'speed'] = avgspeed

    #----------------------------------
    # LAST, append trails to the end of runs
    # speed and time is of no interest for trail runs
    # sorted on dates
    return runs.append(trails).sort_index()


def plot_sportpie(df, cdict, ax=None):
    def label_pie_slice(val):
        return f'{val/100*len(df):.0f} ({val:.0f}%)'

    grouped = df.groupby(df['sport'].cat.remove_unused_categories(), sort=False)
    sports = grouped['sport'].count().index.values.to_list()

    date_min = df.index.min().strftime('%Y-%m-%d')
    date_max = df.index.max().strftime('%Y-%m-%d')
    if ax is None:
        f, ax = plt.subplots(constrained_layout=True, num=1)
    grouped.size().plot(kind='pie', autopct=label_pie_slice,
                        colors=[cdict[key] for key in sports], ax=ax)
    ax.set_title('START: {}\nEND: {}'.format(date_min, date_max), fontsize='x-large')
    ax.set_ylabel('')


def plot_sportbar(df, cdict, ax=None):
    date_min = df.index.min().strftime('%Y-%m-%d')
    date_max = df.index.max().strftime('%Y-%m-%d')
    sports = df['sport'].cat.categories.to_list()

    if ax is None:
        f, ax = plt.subplots(constrained_layout=True, num=2)
    df['sport'].value_counts(sort=False).plot(kind='bar', rot=45, ax=ax,
        color=[cdict[key] for key in sports])
    ax.set_title('START: {}\nEND: {}'.format(date_min, date_max), fontsize='x-large')
    ax.set_ylabel('Number of activities')


def plot_runs_hist(df, ax=None):
    # calculate statistics
    mean = df.distance.mean()
    p25 = df.distance.describe().loc['25%']
    p75 = df.distance.describe().loc['75%']

    # selects only trail runs
    tt = df[df.sport=='TRAIL']

    # set plot options
    opt = dict(lw=2, alpha=0.5)
    opt_tr = dict(marker=2, color='g', ls='none', ms=10, label='Trail Runs')

    # make plot
    if ax is None:
        _, ax = plt.subplots(constrained_layout=True, figsize=(8,4), num=3)
    df.distance.plot.hist(bins=50, color='k', alpha=0.25, ax=ax, label='')
    ax.axvline(mean, color='r', ls='--', label='Mean: {:.1f} km'.format(mean), **opt)
    ax.axvline(p25, color='r', ls=':', label='P25: {:.1f} km'.format(p25), **opt)
    ax.axvline(p75, color='r', ls=':', label='P75: {:.1f} km'.format(p75), **opt)
    if tt.shape[0] > 0:
        ax.plot(tt.distance, np.zeros(tt.shape[0]), **opt_tr)
    ax.legend()
    ax.set_xlabel('Distance (km)')


def plot_runs_stats(df):
    # trim input dataframe to first sunday
    nn = df.index.day_name()=='Sunday'
    start_weekly_stats = df[nn].iloc[[0]].index.to_pydatetime()[0]
    mm = df.index >= start_weekly_stats
    weekly_runs = df[mm].resample('W', closed='left').sum()
    avg_weekd = weekly_runs.distance.mean()
    max_weekd = weekly_runs.distance.max()

    # calculate stats
    runs = df.shape[0]
    weeks = (df.index[-1]-df.index[0]).days//7
    freq = runs/weeks
    avgdst = df.describe().loc['mean', 'distance']
    pb_dst = df.describe().loc['max', 'distance']
    totdst = df['distance'].sum()
    tmp0 = df.describe().loc['mean', 'speed']
    avgs_min = int(tmp0)
    avgs_sec = np.round((tmp0 - int(tmp0))*60)
    avgspd = "{:.0f}'{:.0f}\"".format(avgs_min, avgs_sec)

    tmp1 = df.describe().loc['min', 'speed']
    pbs_min = int(tmp1)
    pbs_sec = np.round((tmp1 - int(tmp1))*60)
    pb_spd = "{:.0f}'{:.0f}\"".format(pbs_min, pbs_sec)


    textstr = f'''
    Runs: {runs}
    Frequency: {freq:.1f} runs/week
    Avg distance: {avgdst:.1f} km
    Avg speed: {avgspd} min/km
    PB distance: {pb_dst} km
    PB speed: {pb_spd} mins/km
    Total distance: {totdst:.0f} km

    Avg weekly: {avg_weekd:.1f} km
    Max weekly: {max_weekd:.1f} km
    '''

    opt = dict(color='k', marker='_', ls='none')
    f, ax = plt.subplots(nrows=3, num=4,
                         sharex=True, figsize=(10, 6))
    # first subplot: TIME
    ax[0].bar(df.index, height=df.time, width=1.5, alpha=0.2, color='b')
    ax[0].set_ylabel('Time (min)', color='b')
    ax[0].tick_params(axis='y', colors='b')
    axwt = ax[0].twinx()
    axwt.plot(weekly_runs.index, weekly_runs.time, **opt)
    axwt.set_ylabel('Weekly Avg', color='k')
    axwt.tick_params(axis='y', colors='k')

    # second subplot: DISTANCES
    ax[1].bar(df.index, height=df.distance, width=1.5, alpha=0.2, color='g')
    ax[1].set_ylabel('Distance (km)', color='g')
    ax[1].tick_params(axis='y', colors='g')
    axwd = ax[1].twinx()
    axwd.plot(weekly_runs.index, weekly_runs.distance, **opt)
    axwd.set_ylabel('Weekly Avg', color='k')
    axwd.tick_params(axis='y', colors='k')

    # third subplot: SPEED
    ax[2].bar(df.index, height=df.speed, width=1.5, alpha=0.2, color='r')
    ax[2].plot(df.rolling('7d').mean().speed, '-r')
    ax[2].set_ylabel('Speed (min/km)', color='r')
    ax[2].tick_params(axis='y', colors='r')
    ax[2].tick_params(axis='x', rotation=45)
    ax[2].set_ylim(np.floor(df.speed.min()), np.ceil(df.speed.max()))
    # turn on horizontal gridlines
    for aa in ax:
        aa.grid(axis='y')

    # add stats
    props = dict(boxstyle='round', facecolor='white', alpha=0.7)
    plt.figtext(0.78, 0.5, textstr, va='center', bbox=props)
    plt.subplots_adjust(right=0.7, left=0.1, top=0.95, bottom=0.1)


def make_plots(df, cdict):
    plot_sportpie(df, cdict)
    plot_sportbar(df, cdict)
    runs = get_runs(df)
    plot_runs_hist(runs)
    plot_runs_stats(runs)
    plt.show()


if len(sys.argv) == 1:
    print('Usage: python', sys.argv[0], '[year YYYY | days DD | all]')
    sys.exit(1)

if sys.argv[1]=='year':
    df, cdict = read_jrnl_sport('~/GOOGLEDRIVE/Apps/journal_sport.txt')
    selected_period = select_period(df, year=int(sys.argv[2]))
    make_plots(selected_period, cdict)

elif sys.argv[1]=='days':
    df, cdict = read_jrnl_sport('~/GOOGLEDRIVE/Apps/journal_sport.txt')
    selected_period = select_period(df, days=int(sys.argv[2]))
    make_plots(selected_period, cdict)

elif sys.argv[1]=='all':
    df, cdict = read_jrnl_sport('~/GOOGLEDRIVE/Apps/journal_sport.txt')
    make_plots(df, cdict)
	import numpy as np
	import matplotlib.pyplot as plt
	import matplotlib.dates as mdates
	import pandas as pd
	from datetime import datetime, timedelta
	import re
	import sys

	def read_jrnl_sport(jrnlfile, colormap='Pastel1'):
	# convert datafile to Pandas DataFrame
	df = pd.read_csv(jrnlfile, sep='@', names=['tmp', 'sport'])

	# extract date and copy to `date` column
	temp = df.tmp.str.extract('.\[(.)\].*')
	df['date'] = temp.astype('datetime64[ns]')

	# set date as index
	df.set_index('date', inplace=True)

	# extract description and copy to `desc` column
	df['desc'] = df['tmp'].str.slice(13)

	# set `sport` column to categorical
	df['sport'] = df.sport.astype('category')

	# make `sport_id` column with numerical ids
	# corresponding to categories
	df['sport_id'] = df.sport.cat.codes

	# assign one color to each sport activity
	allsports = df.sport.cat.categories
	list_of_colors = plt.cm.get_cmap(colormap).colors
	cdict = dict(zip(np.unique(allsports), list_of_colors))

	# remove `tmp` column
	return df.drop(['tmp'], axis=1), cdict


	def select_period(df, year=None, date=None, days=30, forward=False):
	'''
	Select period either by specifying a single year
	or a specific date with an interval in days.

	> df_sel = select_period(df, year=2021)

	Select the last 30 days starting now:
	> df_sel = select_period(df, days=30)

	Select the last 30 days starting on a specific date:
	> df_sel = select_period(df, date='2020-06-19', days=30)
	'''
	if year is not None:
	mask = df.index.year == year
	else:
	if date is None:
	date = datetime.now()
	else:
	date = datetime.strptime(date, '%Y-%m-%d')
	if forward:
	start_date = date
	end_date = date + timedelta(days=days)
	else:
	start_date = date - timedelta(days=days)
	end_date = date
	mask = (df.index >= start_date) & (df.index <= end_date)
	return df.loc[mask]


	def get_runs(df):
	#----------------------------------
	# FIRST, get trail runs
	trails = df[df.sport=='TRAIL']

	# extracts distances from `desc` column for trail runs
	kilometers = []
	for i, r in trails.iterrows():
	kk = re.search(r'([0-9]*[.])?[0-9]+km', r.desc)
	if kk is not None:
	kilometers.append(kk.group().replace('km',''))
	else:
	kilometers.append(None)
	kkarr = np.asarray(kilometers, dtype=np.float)
	trails = trails.assign(distance=kkarr)

	#----------------------------------
	# SECOND, get normal runs
	runs = df[df.sport=='CORSA']

	# extracts time and distances from `desc` column for runs
	minutes = []
	kilometers = []
	for i, r in runs.iterrows():
	mm = re.search(r'([0-9]*[.])?[0-9]+m', r.desc)
	kk = re.search(r'([0-9]*[.])?[0-9]+km', r.desc)
	if mm is not None:
	minutes.append(mm.group().replace('m',''))
	else:
	minutes.append(None)
	if kk is not None:
	kilometers.append(kk.group().replace('km',''))
	else:
	kilometers.append(None)
	mmarr = np.asarray(minutes, dtype=np.float)
	kkarr = np.asarray(kilometers, dtype=np.float)
	runs = runs.assign(distance=kkarr)
	runs = runs.assign(time=mmarr)

	# set up some filters
	nodist = pd.isna(runs.distance)
	notime = pd.isna(runs.time)
	both = ~notime & ~nodist

	# calculate speed for each activity
	# it will be NaN where either speed or distance is not registered
	runs['speed'] = runs['time'] / runs['distance']

	# calculate avg speed in minutes/km
	avgspeed = runs['speed'].mean()

	# fill in runs where only distance has been recorded
	# time is based on average speed, and speed = average speed
	onlydist = notime & ~nodist
	runs.loc[onlydist, 'time'] = runs[onlydist]['distance'] * avgspeed
	runs.loc[onlydist, 'speed'] = avgspeed

	# fill in runs where only time has been recorded
	# time is based on average speed, and speed = average speed
	onlytime = ~notime & nodist
	runs.loc[onlytime, 'distance'] = runs[onlytime]['time'] / avgspeed
	runs.loc[onlytime, 'speed'] = avgspeed

	#----------------------------------
	# LAST, append trails to the end of runs
	# speed and time is of no interest for trail runs
	# sorted on dates
	return runs.append(trails).sort_index()


	def plot_sportpie(df, cdict, ax=None):
	def label_pie_slice(val):
	return f'{val/100*len(df):.0f} ({val:.0f}%)'

	grouped = df.groupby(df['sport'].cat.remove_unused_categories(), sort=False)
	sports = grouped['sport'].count().index.values.to_list()

	date_min = df.index.min().strftime('%Y-%m-%d')
	date_max = df.index.max().strftime('%Y-%m-%d')
	if ax is None:
	f, ax = plt.subplots(constrained_layout=True, num=1)
	grouped.size().plot(kind='pie', autopct=label_pie_slice,
	colors=[cdict[key] for key in sports], ax=ax)
	ax.set_title('START: {}\nEND: {}'.format(date_min, date_max), fontsize='x-large')
	ax.set_ylabel('')


	def plot_sportbar(df, cdict, ax=None):
	date_min = df.index.min().strftime('%Y-%m-%d')
	date_max = df.index.max().strftime('%Y-%m-%d')
	sports = df['sport'].cat.categories.to_list()

	if ax is None:
	f, ax = plt.subplots(constrained_layout=True, num=2)
	df['sport'].value_counts(sort=False).plot(kind='bar', rot=45, ax=ax,
	color=[cdict[key] for key in sports])
	ax.set_title('START: {}\nEND: {}'.format(date_min, date_max), fontsize='x-large')
	ax.set_ylabel('Number of activities')


	def plot_runs_hist(df, ax=None):
	# calculate statistics
	mean = df.distance.mean()
	p25 = df.distance.describe().loc['25%']
	p75 = df.distance.describe().loc['75%']

	# selects only trail runs
	tt = df[df.sport=='TRAIL']

	# set plot options
	opt = dict(lw=2, alpha=0.5)
	opt_tr = dict(marker=2, color='g', ls='none', ms=10, label='Trail Runs')

	# make plot
	if ax is None:
	_, ax = plt.subplots(constrained_layout=True, figsize=(8,4), num=3)
	df.distance.plot.hist(bins=50, color='k', alpha=0.25, ax=ax, label='')
	ax.axvline(mean, color='r', ls='--', label='Mean: {:.1f} km'.format(mean), **opt)
	ax.axvline(p25, color='r', ls=':', label='P25: {:.1f} km'.format(p25), **opt)
	ax.axvline(p75, color='r', ls=':', label='P75: {:.1f} km'.format(p75), **opt)
	if tt.shape[0] > 0:
	ax.plot(tt.distance, np.zeros(tt.shape[0]), **opt_tr)
	ax.legend()
	ax.set_xlabel('Distance (km)')


	def plot_runs_stats(df):
	# trim input dataframe to first sunday
	nn = df.index.day_name()=='Sunday'
	start_weekly_stats = df[nn].iloc[[0]].index.to_pydatetime()[0]
	mm = df.index >= start_weekly_stats
	weekly_runs = df[mm].resample('W', closed='left').sum()
	avg_weekd = weekly_runs.distance.mean()
	max_weekd = weekly_runs.distance.max()

	# calculate stats
	runs = df.shape[0]
	weeks = (df.index[-1]-df.index[0]).days//7
	freq = runs/weeks
	avgdst = df.describe().loc['mean', 'distance']
	pb_dst = df.describe().loc['max', 'distance']
	totdst = df['distance'].sum()
	tmp0 = df.describe().loc['mean', 'speed']
	avgs_min = int(tmp0)
	avgs_sec = np.round((tmp0 - int(tmp0))*60)
	avgspd = "{:.0f}'{:.0f}\"".format(avgs_min, avgs_sec)

	tmp1 = df.describe().loc['min', 'speed']
	pbs_min = int(tmp1)
	pbs_sec = np.round((tmp1 - int(tmp1))*60)
	pb_spd = "{:.0f}'{:.0f}\"".format(pbs_min, pbs_sec)


	textstr = f'''
	Runs: {runs}
	Frequency: {freq:.1f} runs/week
	Avg distance: {avgdst:.1f} km
	Avg speed: {avgspd} min/km
	PB distance: {pb_dst} km
	PB speed: {pb_spd} mins/km
	Total distance: {totdst:.0f} km

	Avg weekly: {avg_weekd:.1f} km
	Max weekly: {max_weekd:.1f} km
	'''

	opt = dict(color='k', marker='_', ls='none')
	f, ax = plt.subplots(nrows=3, num=4,
	sharex=True, figsize=(10, 6))
	# first subplot: TIME
	ax[0].bar(df.index, height=df.time, width=1.5, alpha=0.2, color='b')
	ax[0].set_ylabel('Time (min)', color='b')
	ax[0].tick_params(axis='y', colors='b')
	axwt = ax[0].twinx()
	axwt.plot(weekly_runs.index, weekly_runs.time, **opt)
	axwt.set_ylabel('Weekly Avg', color='k')
	axwt.tick_params(axis='y', colors='k')

	# second subplot: DISTANCES
	ax[1].bar(df.index, height=df.distance, width=1.5, alpha=0.2, color='g')
	ax[1].set_ylabel('Distance (km)', color='g')
	ax[1].tick_params(axis='y', colors='g')
	axwd = ax[1].twinx()
	axwd.plot(weekly_runs.index, weekly_runs.distance, **opt)
	axwd.set_ylabel('Weekly Avg', color='k')
	axwd.tick_params(axis='y', colors='k')

	# third subplot: SPEED
	ax[2].bar(df.index, height=df.speed, width=1.5, alpha=0.2, color='r')
	ax[2].plot(df.rolling('7d').mean().speed, '-r')
	ax[2].set_ylabel('Speed (min/km)', color='r')
	ax[2].tick_params(axis='y', colors='r')
	ax[2].tick_params(axis='x', rotation=45)
	ax[2].set_ylim(np.floor(df.speed.min()), np.ceil(df.speed.max()))
	# turn on horizontal gridlines
	for aa in ax:
	aa.grid(axis='y')

	# add stats
	props = dict(boxstyle='round', facecolor='white', alpha=0.7)
	plt.figtext(0.78, 0.5, textstr, va='center', bbox=props)
	plt.subplots_adjust(right=0.7, left=0.1, top=0.95, bottom=0.1)


	def make_plots(df, cdict):
	plot_sportpie(df, cdict)
	plot_sportbar(df, cdict)
	runs = get_runs(df)
	plot_runs_hist(runs)
	plot_runs_stats(runs)
	plt.show()


	if len(sys.argv) == 1:
	print('Usage: python', sys.argv[0], '[year YYYY \| days DD \| all]')
	sys.exit(1)

	if sys.argv[1]=='year':
	df, cdict = read_jrnl_sport('~/GOOGLEDRIVE/Apps/journal_sport.txt')
	selected_period = select_period(df, year=int(sys.argv[2]))
	make_plots(selected_period, cdict)

	elif sys.argv[1]=='days':
	df, cdict = read_jrnl_sport('~/GOOGLEDRIVE/Apps/journal_sport.txt')
	selected_period = select_period(df, days=int(sys.argv[2]))
	make_plots(selected_period, cdict)

	elif sys.argv[1]=='all':
	df, cdict = read_jrnl_sport('~/GOOGLEDRIVE/Apps/journal_sport.txt')
	make_plots(df, cdict)