# perform Strava OAuth authorization...

#

# note: passing the client_id and client_secret in the url

# isn't recommended!

url = client.authorization_url(

client_id = client_id,

# redirect_uri = 'http://localhost:{0}/auth?client_id={1}&client_secret={2}'.format(port,client_id,client_secret), # nasty hack, bad idea!

redirect_uri = 'http://localhost:{0}/auth'.format(port),

scope = ['read_all','activity:write']);

# open url in the default browser

webbrowser.open_new_tab(url);

# launch the flask backend to catch the OAuth redirect from strava.com

# tag activities with specified gearId

id = getattr(args,'gearId');

if id is None:

# list all bikes

athlete = client.get_athlete();

for id in athlete.bikes:

logging.info("Bike: %s (%s) %ikm",id.name,id.id,id.distance/1e3);

return

cnt = [0,0];

for activity in client.get_activities(after = getattr(args,'after'),

before = getattr(args,'before')):

if activity.gear_id is None:

if not getattr(args,'dryrun'):

client.update_activity(activity_id = activity.id,gear_id = id);

dt = random.expovariate(1.0/1.5); # rate limiting...

logging.info("Sleeping %fs", dt);

time.sleep(dt);

cnt[1] += 1;

cnt[0] += 1;

logging.info("Total activities: %i, Updated activities: %i.",cnt[0],cnt[1]);

# tag activities as commutes

# for our purposes, we define a commute as a sequence of rides starting at

# orig (e.g., home) and ending at dest (e.g., work)

import config; # see config.py

orig = getattr(args,'orig');

if orig is None:

try:

orig = config.orig[getattr(args,'user')]

except AttributeError:

raise;

dest = getattr(args,'dest');

if dest is None:

try:

dest = config.dest[getattr(args,'user')]

except AttributeError:

raise;

tol = getattr(args,'tol');

if tol is None:

try:

tol = config.tol;

except AttributeError:

tol = 1e3; # default: 1km

ride = []; # empty list

# loop over activities, getting id, date, start and end coords

for activity in client.get_activities(after = getattr(args,'after'),

before = getattr(args,'before')):

info = {"id": None, "date": None, "start": None, "end": None}; info["id"] = activity.id;

info["date"] = activity.start_date_local;

info["name"] = activity.name;

info["distance"] = activity.distance;

for latlng in [orig, dest]:

if distance(latlng,activity.start_latlng) <= tol:

info["start"] = latlng;

if distance(latlng,activity.end_latlng) <= tol:

info["end"] = latlng;

ride.append(info);

commute = getCommutes(ride,orig,dest);

if args.rtrn:

commute.extend(getCommutes(ride,dest,orig));

# also flag dest-dest rides as commutes...?

# TODO: this is a hack, fix this (shaun)

for r in ride:

if r["start"] == dest and r["end"] == dest:

commute.append(r);

# commute.sort(key = lambda x: x["date"]);

logging.debug("Found %i/%i activities that look like commutes...",

len(commute),len(ride));

for activity in commute:

logging.debug("{0}: {1} {2} [{3}]".format(activity["date"],activity["name"],activity["distance"],activity["id"]));

if not getattr(args,'dryrun'):

client.update_activity(activity_id = activity["id"],commute = True);

dt = random.expovariate(1.0/1.5); # rate limiting...

logging.info("Sleeping %fs", dt);

time.sleep(dt);

logging.info("Total activities: %i, Updated activities: %i.",

# sort by date/time... newest to oldest

ride.sort(key = lambda x: x["date"], reverse = True);

commute = []; # empty list

for ii in range(len(ride)):

# print "{0}: {1}".format(ii,ride[ii]);

if ride[ii]["start"] != latlng0:

continue

# a candidate commute

if ride[ii]["end"] == latlng0:

continue # not a commute...

if ride[ii]["end"] == latlng1:

commute.append(ride[ii]);

continue

# ride could be part of a "multi-ride" commute

commute_ = [ride[ii]];

jj = 1;

while True:

if ride[ii-jj]["date"].date() != ride[ii]["date"].date():

# not a commute

# TODO: could be multi-day commute?

commute_ = [];

break

if ride[ii-jj]["start"] == latlng0 or ride[ii-jj]["end"] == latlng0:

# not a commute

commute_ = [];

break

if ride[ii-jj]["end"] == latlng1:

commute_.extend(ride[ii-jj:ii]);

break

jj += 1;

commute.extend(commute_);

logging.basicConfig(stream = sys.stderr,

format='%(levelname)s:%(message)s',

level = args.loglevel or logging.INFO);

logging.debug("args = %s", args);

import config; # see config.py

if getattr(args,'action') == "auth":

# perform OAuth authorization...

auth(config.CLIENT_ID,config.CLIENT_SECRET,port = getattr(args,'port'))

return

try:

client.access_token = config.users[getattr(args,'user')];

except KeyError:

logging.error("Unknown user %s!", getattr(args,'user'));

return;

# parse filter arguments...

before = getattr(args,'before')

if before is not None:

try:

args.before = datetime.strptime(before,'%Y-%m-%d')

except ValueError:

logging.error("Invalid date format %s.",before);

return

after = getattr(args,'after')

if after is not None:

try:

args.after = datetime.strptime(after,'%Y-%m-%d')

except ValueError:

logging.error("Invalid date format %s.",after);

return

# this is where we break out to handle different actions...

from geographiclib.geodesic import Geodesic;

geod = Geodesic.WGS84 # use the WGS84 ellipsoid??

g = geod.Inverse(latlng0[0], latlng0[1], latlng1[0], latlng1[1])