def FetchGPSData(tokensFile,CPCdate,CPClen):
client = Client()
###To get the saved access tokens below, I did the following:
##1. Run the following lines:
#authorize_url = client.authorization_url(client_id=22380, redirect_uri='http://sustainability.leeds.ac.uk',approval_prompt='force')
#print(authorize_url)
##2. Paste the above url into a browser, accept the request,
## and copy the 'code' from the resulting url into the following line,
## along with the client_secret which can be found under air pollution9 account on strava:
#access_token = client.exchange_code_for_token(client_id=22380, client_secret='***',
# code='***')
##3. Extract token from the above variable:
#print(access_token)
###Saved access tokens:
f=open(tokensFile,'r')
myTokens=f.read().splitlines()
f.close()
#Find activity which most closely matches CPC start date/time and sample length
#All activities within 5 mins of the CPC start date are considered
#The activity with the closest-matching elapsed time to the CPC sample length is then chosen
validActs={}
for i,token in enumerate(myTokens):
client.access_token = token
#athlete = client.get_athlete()
#print(athlete.firstname,athlete.lastname+':')
myActivities=client.get_activities()
for activity in myActivities:
startDate=activity.start_date_local
#print(' '+activity.name+':',startDate,'Local time')
if abs((CPCdate-startDate).total_seconds()) < 60:
validActs.update({i:activity.id})
assert len(validActs) > 0, "No GPS activities with a start time within 5 minutes of the CPC data file start time"
DeltaT=1e10
for key,value in validActs.items():
client.access_token=myTokens[key]
activity=client.get_activity(value)
elap=activity.elapsed_time.seconds
thisDT=abs(CPClen-elap)
if thisDT < DeltaT:
DeltaT=thisDT
chosenAth=key
chosenAct=value
#Extract required data from chosen activity:
client.access_token=myTokens[chosenAth]
activity=client.get_activity(chosenAct)
startDate=activity.start_date_local
endDate=startDate+dt.timedelta(seconds=activity.elapsed_time.seconds)
endDateCPC=CPCdate+dt.timedelta(seconds=CPClen)
assert abs((endDateCPC-endDate).total_seconds()) < 60, "No valid GPS activities with an end time within 1 minute of the CPC data file end time"
myTypes = ['time', 'latlng']
myStream = client.get_activity_streams(chosenAct,types=myTypes)
latlon=myStream['latlng'].data
lat=[latlon[i][0] for i in range(len(latlon))]
lon=[latlon[i][1] for i in range(len(latlon))]
time=myStream['time'].data
dateTime=[startDate+dt.timedelta(seconds=i) for i in time]
GPSData=pd.DataFrame(data={'lon':lon,'lat':lat,'dateTime':dateTime})
return GPSData
def get_strava_client(user_id=None):
client = Client()
if user_id is None:
client.access_token = ConfigService.getConfigVar('strava.access_token')
else:
user = UserManager.get_user(user_id)
if user:
client.access_token = user.access_token
else:
print "[stravaM]: User {0} not found".format(user_id)
return False
return client
def api_profiles_activities_id(player_id, activity_id):
if not request.stream:
return '', 400
activity_id = int(activity_id) & 0xffffffffffffffff
activity = activity_pb2.Activity()
activity.ParseFromString(request.stream.read())
update_protobuf_in_db('activity', activity, activity_id)
response = '{"id":%s}' % activity_id
if request.args.get('upload-to-strava') != 'true':
return response, 200
try:
from stravalib.client import Client
except ImportError:
logger.warn(
"stravalib is not installed. Skipping Strava upload attempt.")
return response, 200
strava = Client()
try:
with open('%s/strava_token.txt' % STORAGE_DIR, 'r') as f:
strava.access_token = f.read().rstrip('\r\n')
except:
logger.warn(
"Failed to read %s/strava_token.txt. Skipping Strava upload attempt."
)
return response, 200
try:
# See if there's internet to upload to Strava
strava.upload_activity(BytesIO(activity.fit),
data_type='fit',
name=activity.name)
# XXX: assume the upload succeeds on strava's end. not checking on it.
except:
logger.warn("Strava upload failed. No internet?")
return response, 200
def handle(self, *args, **options):
self.stdout.write("Updating the Acacia event miles")
client = Client()
rides_after = datetime(2018, 9, 1)
rides_before = datetime(2018, 9, 3)
participants = BigBulletRider.objects.exclude(
access_token__isnull=True)
for particpant in participants:
self.stdout.write("Looking up activities for " +
str(particpant.name))
client.access_token = particpant.access_token
activities = client.get_activities(before=rides_before,
after=rides_after)
for activity in activities:
km = unithelper.kilometers(activity.distance).num
self.stdout.write("Got activity " + str(activity.id) +
" distance = " + str(km) + " = " +
str(activity))
ride, created = BigBulletRide.objects.get_or_create(
activity_id=activity.id,
bullet=particpant,
distance=km,
start_date=activity.start_date)
self.stdout.write("Created = " + str(created))
def rides(request):
if (not request.user.is_authenticated):
return JsonResponse({"user_auth": False})
client = Client()
user = AuthUser.objects.get(user_id=request.user.id)
client.access_token = user.auth_code
_before = datetime.now()
_after = datetime(2018, 4, 1)
batched_activities = client.get_activities(before=_before, after=_after)
list_activities = list(batched_activities)
rtn_activity_list = []
for a in list_activities:
detailed_activity = client.get_activity(a.id)
_new_activity = JsonActivity(detailed_activity.id, detailed_activity.map.polyline, a.distance, a.start_date)
rtn_activity_list.append(_new_activity.toJson())
rtn = {
"user_auth": True,
"activities": rtn_activity_list
}
return JsonResponse(rtn)
def create_client(self):
self.s3_file_manager.download_file('strava_auth.json',
'/tmp/strava_auth.json')
with open('/tmp/strava_auth.json') as auth_json:
data = json.load(auth_json)
access_token = data['access_token']
refresh_token = data['refresh_token']
expires_at = data['expires_at']
client = Client()
client.access_token = access_token
client.refresh_token = refresh_token
client.token_expires_at = expires_at
if time.time() > client.token_expires_at:
print('Token has expired - refreshing...')
refresh_response = client.refresh_access_token(
client_id=int(os.getenv('STRAVA_CLIENT_ID', None)),
client_secret=os.getenv('STRAVA_CLIENT_SECRET', None),
refresh_token=client.refresh_token)
with open('/tmp/strava_auth.json', 'w') as outfile:
json.dump(refresh_response, outfile)
self.s3_file_manager.upload_file('/tmp/strava_auth.json',
'strava_auth.json')
return client
def get_client_or_authorize_url():
"""Get strava client, or authorization URL if not authenticated"""
client = Client()
authorize_url = None
if "strava_refresh_token" in session.keys():
client.refresh_token = session["strava_refresh_token"]
LOGGER.debug("{} / {} / {}".format(
session["strava_access_token"],
session["strava_refresh_token"],
session["strava_expires_at"],
))
if ("strava_access_token" in session.keys()
and int(session["strava_expires_at"]) >
datetime.datetime.now().timestamp()):
client.access_token = session["strava_access_token"]
client.refresh_token = session["strava_refresh_token"]
client.token_expires_at = session["strava_expires_at"]
else:
authorize_url = get_authorization_url()
LOGGER.debug("Authorize URL: {}".format(authorize_url))
return client, authorize_url
def strava_upload(tcxfiles, login=None):
logging.basicConfig(level=logging.DEBUG)
client = Client()
creds = read_strava_auth_file()
if login == None:
if len(creds) > 0:
print("found strava credentials for: " )
n = 0
for email in creds.keys():
print(str(n) + " " + email)
n += 1
index_input = raw_input("enter the number corresponding to your email address. Or just press enter to use your default browser to login\n")
if re.match("\A\d+\Z", index_input):
index = int(index_input)
if index < len(creds):
login = creds.keys()[index]
if login and creds.has_key(login):
client.access_token = creds[login]
else:
strava_authorize(client)
for tcxfile in tcxfiles:
r = post_file_to_strava(client, tcxfile)
if(r.status_code == 401):
print("invalid auth token, rerequesting authorization")
strava_authorize(client)
r = post_file_to_strava(client, tcxfile)
if(r.status_code not in [200,201]):
print("error uploading file. HTTP response code: " + str(r.status_code))
print(str(r.text))
def send_run_to_strava():
'''Ask whether to send a run to strava if it hasn't already. Option to
add a description. Update on_strava field in database if successfully
sent or prompted to do so if not sent.'''
cfg.read(os.path.join(os.getenv('HOME'), '.config/strava.cfg'))
access_token = cfg.get('Strava', 'access_token')
client = Client()
client.access_token = access_token
runs = get_list_of_runs_not_on_strava()
for run in runs:
print run
send = raw_input("Send this run to Strava? (Y|N): ")
if (send[0] in ['Y', 'y']):
start_time = raw_input(
"What time did the activity start HH:MM:SS: ")
date_of_activity = "%sT%sZ", (run.run_date, start_time)
description = raw_input("Add an optional description: ")
client.create_activity(run.name,
ACTIVITY_TYPE,
date_of_activity,
run.time,
description,
unithelper.miles(run.distance))
mark_run_as_on_strava(run.run_date, run.route_id, run.athlete_id)
logging.info("Sent this activity to Strava: %s", run)
else:
update = raw_input("Update this run as on Strava (Y|N): ")
if (update[0] in ['Y', 'y']):
mark_run_as_on_strava(
run.run_date, run.route_id, run.athlete_id)
def collect_ride_data(self, challenge):
"""
Pull the latest ride data from Strava via the API
"""
client = Client()
client.access_token = self.strava_config['access-token']
#activities = client.get_club_activities(165009)
activities = client.get_club_activities(challenge.get_group_id())
act_list = []
for activity in activities:
if not activity.type == 'Ride' and not activity.type == 'VirtualRide':
print 'Non-ride activity: %s, type: %s' % (activity.name, activity.type)
continue
act = Activity(activity.id)
act.set_athlete(activity.athlete.id)
act.set_name(activity.name)
act.set_gmt_date(activity.start_date) # GMT Start date
act.set_elapsed_time(activity.elapsed_time)
act.set_distance(round(unithelper.kilometers(activity.distance).num, 2))
act.set_elevation(unithelper.meters(activity.total_elevation_gain).num)
act.set_ride_type(activity.type)
act.set_trainer_ride(activity.trainer)
act_list.append(act)
db_store = GTDataStore(challenge.get_db_path(), self.verbose)
db_store.store_if_new(act_list)
def handle(self, *args, **options):
settings_obj = Site.objects.get_current().settings
self.stdout.write("Updating the Strava cache...")
if settings.STRAVA_ACCESS_TOKEN == None:
self.stdout.write("You must set STRAVA_ACCESS_TOKEN")
return
client = Client()
client.access_token = settings.STRAVA_ACCESS_TOKEN
if settings.STRAVA_CYCLING_CLUB != 0:
cycling_club = client.get_club(settings.STRAVA_CYCLING_CLUB)
self.stdout.write("Got this many cyclists = " +
str(cycling_club.member_count))
settings_obj.cyclists = cycling_club.member_count
# self.stdout.write("Getting cycling activities")
# cycling_activities = client.get_club_activities(settings.STRAVA_CYCLING_CLUB) # Just get all of them, database can dedupe
# self.insert_into_db(cycling_activities, ActivityCache.RIDE)
if settings.STRAVA_RUNNING_CLUB != 0:
running_club = client.get_club(settings.STRAVA_RUNNING_CLUB)
self.stdout.write("Got this many runners = " +
str(running_club.member_count))
settings_obj.runners = running_club.member_count
# self.stdout.write("Getting running activities")
# running_activities = client.get_club_activities(settings.STRAVA_RUNNING_CLUB)
# self.insert_into_db(running_activities, ActivityCache.RUN)
settings_obj.save()
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 make_client(client_id, client_secret, refresh_token):
client = Client()
refresh_response = client.refresh_access_token(
client_id=client_id, client_secret=client_secret, refresh_token=refresh_token
)
client.access_token = refresh_response["access_token"]
return client
def __get_strava_client(request):
client = Client()
if request.user:
if request.user.social_auth:
provider = request.user.social_auth.get(provider='strava')
if provider:
if 'access_token' in provider.extra_data.keys():
client.access_token = provider.extra_data['access_token']
return client
def strava_client(client_id=None,
client_secret=None,
refresh_token=None,
access_token=None):
client = Client()
if access_token is None:
authorize_url = client.authorization_url(
client_id=client_id,
redirect_uri='http://localhost:8282/authorized',
scope='view_private,write')
logging.info("Go to %s" % (authorize_url))
code = raw_input("Code: ")
client.access_token = client.exchange_code_for_token(
client_id=client_id, client_secret=client_secret, code=code)
logging.info("Access Token = %s" % (client.access_token))
else:
client.access_token = access_token
return client
def get_images(segment_id):
access_token = request.cookies.get('access_token')
if not access_token:
return redirect("/")
client = Client(rate_limiter=limiter.DefaultRateLimiter())
client.access_token = access_token
# look into this: https://github.com/saimn/sigal/
images = get_images_from_segment(segment_id, client)
return render_template('test.html', images=images)
def pull_activities(access_token,
firstname,
lastname,
from_time="2018-01-01T00:00:00Z"):
# An authorized callback is coming. Process it and add
client = Client()
client.access_token = access_token
for activity in client.get_activities(after=from_time, limit=500):
process_activity(activity, firstname, lastname)
return True
def get_strava_client():
token_dict = current_token_dict()
if token_dict:
client = Client()
client.access_token = token_dict['access_token']
client.refresh_token = token_dict['refresh_token']
# If token is old, refresh it
if time.time() > token_dict['expires_at']:
app.server.logger.debug('Strava tokens expired, refreshing...')
refresh_response = client.refresh_access_token(client_id=client_id, client_secret=client_secret,
refresh_token=client.refresh_token)
# Save to db
save_strava_token(refresh_response)
# Update client
client.access_token = refresh_response['access_token']
client.refresh_token = refresh_response['refresh_token']
else:
client = Client()
return client
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_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_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 get_client():
client = Client()
authorize_url = client.authorization_url(
client_id=26273,
redirect_uri='https://localhost:8080',
scope=['read', 'read_all', 'activity:read_all'])
code = '299ad7943b6eb478247684620d87e341cfdcb6a2'
access_token = client.exchange_code_for_token(
client_id=26273,
client_secret='80f4236b6e958701dbeebb8c09c99e9d2fb71d1a',
code=code)
client.access_token = access_token['access_token']
return client
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 get_strava_activities(self, strava_social, from_date=None):
new_activities = []
provider_name = 'strava'
if self.relate_activities:
existing_ids = self.activities.filter(
provider=provider_name).values_list('original_id', flat=True)
else:
existing_ids = Activity.objects.filter(
provider=provider_name).values_list('original_id', flat=True)
# get access token
token = strava_social.get_access_token(load_strategy())
# get activity details
client = Client()
client.access_token = token
query = client.get_activities(after=from_date)
try:
for strava_activity in query:
strava_id = strava_activity.id
if not strava_id in existing_ids:
new_activity = Activity()
new_activity.original_id = strava_id
new_activity.provider = provider_name
else:
new_activity = self.activities.get(original_id=strava_id)
new_activity.date = strava_activity.start_date_local
new_activity.distance = strava_activity.distance
new_activity.duration = strava_activity.elapsed_time
new_activity.name = strava_activity.name
new_activity.type = strava_activity.type
if self.relate_activities:
new_activity.member = self
else:
new_activity.member = None
new_activity.save()
new_activities.append(new_activity)
except:
print('User f{self} ha no permissions on strava')
strava_social.delete()
return new_activities
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 strava_last_activity(request):
currentUser = User.objects.get(pk=request.user.id)
client = Client()
client.access_token = currentUser.profile.stravaAccessCode
activities = client.get_activities(before=datetime.datetime.now(), limit=1)
activityName = ''
for activity in activities:
activityName = activity.name
downloadedActivity = client.get_activity(activity.id)
activityStream = client.get_activity_streams(activity.id,
types=["time", "watts"])
averageCadence = downloadedActivity.average_cadence
return render(request, 'strava_last_activity.html',
{'activity_name': averageCadence})
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 get_activities(access_token, output_file):
"""Retrieving all user activities and output them in CSV format"""
client = Client()
client.access_token = access_token
filewriter = csv.writer(output_file, delimiter=",", quotechar="|", quoting=csv.QUOTE_MINIMAL)
filewriter.writerow(["ID", "Name", "Distance", "Type", "Workout type", "Start date", "Was manually added", "Is private", "Gear ID", "Description"])
activities_count = 0
for activity in client.get_activities():
filewriter.writerow([activity.id, activity.name, activity.distance, activity.type, activity.workout_type, activity.start_date, activity.manual, activity.private, activity.gear_id, activity.description])
activities_count += 1
print("[+] Number of saved activities: {}".format(activities_count))
def strava_upload(player_id, activity):
try:
from stravalib.client import Client
except ImportError:
logger.warn(
"stravalib is not installed. Skipping Strava upload attempt.")
return
profile_dir = '%s/%s' % (STORAGE_DIR, player_id)
strava = Client()
try:
with open('%s/strava_token.txt' % profile_dir, 'r') as f:
client_id = f.readline().rstrip('\r\n')
client_secret = f.readline().rstrip('\r\n')
strava.access_token = f.readline().rstrip('\r\n')
refresh_token = f.readline().rstrip('\r\n')
expires_at = f.readline().rstrip('\r\n')
except:
logger.warn(
"Failed to read %s/strava_token.txt. Skipping Strava upload attempt."
% profile_dir)
return
try:
if time.time() > int(expires_at):
refresh_response = strava.refresh_access_token(
client_id=client_id,
client_secret=client_secret,
refresh_token=refresh_token)
with open('%s/strava_token.txt' % profile_dir, 'w') as f:
f.write(client_id + '\n')
f.write(client_secret + '\n')
f.write(refresh_response['access_token'] + '\n')
f.write(refresh_response['refresh_token'] + '\n')
f.write(str(refresh_response['expires_at']) + '\n')
except:
logger.warn("Failed to refresh token. Skipping Strava upload attempt.")
return
try:
# See if there's internet to upload to Strava
strava.upload_activity(BytesIO(activity.fit),
data_type='fit',
name=activity.name)
# XXX: assume the upload succeeds on strava's end. not checking on it.
except:
logger.warn("Strava upload failed. No internet?")
def handle(self, *args, **options):
client = Client()
client.access_token = '20bf9e2864c1411d17d9cab8c11aa8dbe626aedd'
cityEntries = City.objects.all()
resetPlaceChanges = False
if not cityEntries:
cityEntries = createDefaultCitySegments()
resetPlaceChanges = True
for city in cityEntries:
updater = CityLeaderboardUpdater(city, client)
updater.update()
# Delete placement changes if data has just been reset
if resetPlaceChanges:
placementChanges = PlacementChange.objects.all()
for pc in placementChanges.iterator():
pc.delete()
print("Updated at " + str(timezone.now()))
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 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 fetch_stats():
client = Client()
refresh_response = client.refresh_access_token(client_id=client_id,
client_secret=client_secret,
refresh_token=refresh_token)
client.access_token = refresh_response['access_token']
stats = client.get_athlete_stats()
return textwrap.dedent(f"""\
#### Recent rides
{get_stat_values(stats.recent_ride_totals)}
#### YTD ride totals
{get_stat_values(stats.ytd_ride_totals)}
#### All ride totals
{get_stat_values(stats.all_ride_totals)}
""")
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Authenticate to the Strava API."""
from stravalib.client import Client
hass.http.register_view(StravaAuthCallbackView())
client_id = config.get(CONF_CLIENT_ID)
client_secret = config.get(CONF_CLIENT_SECRET)
client = Client()
config_path = hass.config.path(STRAVA_CONFIG_PATH)
@asyncio.coroutine
def _read_config():
if not os.path.isfile(config_path):
return None
with open(config_path, 'r') as auth_file:
config = json.load(auth_file)
if config['client_id'] == client_id:
return config['access_token']
@asyncio.coroutine
def _write_config():
with open(config_path, 'w') as auth_file:
json.dump(
{
'client_id': client_id,
'access_token': client.access_token,
}, auth_file)
@asyncio.coroutine
def _add_device():
strava = StravaSensor(hass, client)
yield from strava.async_update()
return async_add_devices([strava])
access_token = yield from _read_config()
if access_token is not None:
client.access_token = access_token
yield from _add_device()
else:
callback_url = '{}{}'.format(hass.config.api.base_url,
StravaAuthCallbackView.url)
authorize_url = client.authorization_url(client_id=client_id,
redirect_uri=callback_url)
configurator = hass.components.configurator
request_id = configurator.async_request_config(
'Strava',
description='Authorization required for Strava account.',
link_name='Authorize Home Assistant',
link_url=authorize_url,
entity_picture='/local/images/logo_strava.png')
@asyncio.coroutine
def initialize_callback(code):
"""Handle OAuth callback from Strava authorization flow."""
client.access_token = client.exchange_code_for_token(
client_id=client_id, client_secret=client_secret, code=code)
yield from _write_config()
yield from _add_device()
configurator.async_request_done(request_id)
hass.data[DATA_CALLBACK] = initialize_callback
return True
client_id = cfg.get("StravaClient", "ClientId")
client_secret = cfg.get("StravaClient", "ClientSecret")
port = int(cfg.get("Application", "Port"))
# setup webserver for authentication redirect
httpd = http.server.HTTPServer(('127.0.0.1', port), AuthHandler)
# The url to authorize from
authorize_url = client.authorization_url(client_id=client_id, redirect_uri='http://localhost:{port}/authorized'.format(port=port), scope='view_private,write')
# Open the url in your browser
webbrowser.open(authorize_url, new=0, autoraise=True)
# wait until you click the authorize link in the browser
httpd.handle_request()
code = httpd.code
# Get the token
token = client.exchange_code_for_token(client_id=client_id, client_secret=client_secret, code=code)
# Now store that access token in the config
cfg.set("UserAcct", "Token", token)
with open("stravamng.cfg", "w") as cfg_file:
cfg.write(cfg_file)
client.access_token = token
# do stuff
athlete = client.get_athlete()
print("For {id}, I now have an access token {token}".format(id=athlete.id, token=token))
## import libraries
from stravalib.client import Client
from cartodb import CartoDBAPIKey, CartoDBException
import numpy as np
import datetime
import time
from polyline.codec import PolylineCodec
from geojson import Feature, LineString
## Strava connection
client = Client()
client.access_token = 'd47099a29b2f3539e1c21af6d820e33a109a079e'
## CartoDB connection
API_KEY ='cad54ea0c580a0c554b9e9562157e7c9bd9f37b0'
cartodb_domain = 'geodarcy'
cl = CartoDBAPIKey(API_KEY, cartodb_domain)
## remove duplicate rows
cl.sql('DELETE FROM wbstrava WHERE cartodb_id IN (SELECT cartodb_id FROM (SELECT cartodb_id, ROW_NUMBER() OVER (partition BY segment_id ORDER BY cartodb_id) AS rnum FROM wbstrava) t WHERE t.rnum > 1);')
## find segments with no geometry
queryResult = cl.sql('select segment_id from wbstrava where the_geom is null')
currentSegments = [x['segment_id'] for x in queryResult['rows']]
for id in currentSegments:
try:
segmentGeojson = PolylineCodec().decode(client.get_segment(id).map.polyline)
flippedGeojson = [[x[1], x[0]] for x in segmentGeojson]
inputGeojson = '{"coordinates": ' + str(flippedGeojson) + ', "type": "LineString", "crs":{"type":"name","properties":{"name":"EPSG:4326"}}}'
cl.sql('UPDATE wbstrava SET the_geom = ST_GeomFromGeoJSON(\'' + inputGeojson + '\') WHERE segment_id=' + str(id))
except Exception as e:
from stravalib.client import Client
from stravalib import unithelper
import pandas as pd
import cPickle as pickle
from os.path import join, exists
from os import makedirs, getcwd
from datetime import datetime
client = Client()
client.access_token = "8ad469fc76e136a0d5a40f0ad10ea0e8282ef6e5"
me = client.get_athlete()
print me.email
def to_miles(dist):
return float(unithelper.miles(dist))
def to_mph(mps):
return float(unithelper.mph(act.average_speed))
def echo(v):
return v
#TODO Convert moving time properly, want in a timedelta really
#TODO To do proper clustering, need columns as lat then long, and rows as runs
# but how to deal with runs of different lengths?
# I think all streams have the same number of points?
# Which isn't going to be great, but givem that different routes, even if stretched out/shrunk, have different shapes
# then distinct ones should stay that way, so might be ok
#!/bin/python
import ConfigParser
import json
import io
from stravalib.client import Client
config = ConfigParser.ConfigParser()
client = Client()
config.read('config.ini')
client.access_token = config.get("access","access_token")
app_friends = config.get("app","friends")
redis_host = config.get("access", "redis_host")
# get my profile
#curr_athlete = client.get_athlete()
# inspect the athlete object
#print(type(curr_athlete))
#print(dir(curr_athlete))
# get another athlete profile
#curr_athlete = client.get_athlete(4658463)
#print(curr_athlete)
# get a segment
#curr_segment = client.get_segment(11493495)
#print(type(curr_segment))
#print(dir(curr_segment))
#print(curr_segment)
# get a segment leaderboard
#curr_segmentldr = client.get_segment_leaderboard(11493495)
from stravalib.client import Client
from stravalib.attributes import LatLon
import units
LOGIN = file("access_token").read().strip()
BIKES = {
"Madone": "b1258359",
"Secteur": "b1708741",
"Random": "b1209450",
}
# Strava rounds to two decimals which isn't terribly precise but at least easy
# for comparisons.
WORK = LatLon(lat=51.49, lon=-0.15)
client = Client()
client.access_token = LOGIN
def build_updates(act):
ret = {}
if act.type != act.RIDE:
if (act.start_latlng == WORK and
act.start_date_local.weekday() <= 4):
ret["name"] = "Walking commute"
ret["commute"] = True
ret["activity_type"] = act.WALK
# I don't record walks that often anyway.
return
segments = [se.segment.id for se in act.segment_efforts]
def scrape_strava():
# Scraper config:
# Enter your Strava API info here.
# You can find this at https://www.strava.com/settings/api
CLIENT_ID = 31337
CLIENT_SECRET = 'BA5ED60D'
# Strava auth callbacks will hit this host and port. Change the port if you
# need to avoid port conflicts with other servers.
CALLBACK_PORT = 36724
# Where to store your Strava activity info and the Strava auth token.
ACTIVITIES_TABLE = 'strava_activities'
TOKEN_TABLE = 'strava_token'
# Scraper body begins here.
import config
import webbrowser
import logging
from cgi import parse_qs
from wsgiref.simple_server import make_server
import dataset
from stravalib.client import Client
from stravalib import unithelper
from units import unit
# And here's the rest of the scraper.
def get_new_token():
authorize_url = client.authorization_url(
client_id=CLIENT_ID,
redirect_uri=('%s:%s' % (config.SERVER_HOST, CALLBACK_PORT))
)
webbrowser.open(authorize_url)
print('Click here to authorize me to access your Strava activities: %s'
% authorize_url)
make_server('localhost', CALLBACK_PORT, auth_listener).handle_request()
def auth_listener(environ, start_response):
start_response("200 OK", [('Content-Type', 'text/plain')])
parameters = parse_qs(environ.get('QUERY_STRING', ''))
code_received(parameters['code'][0])
return ['Got your authorization from Strava! '
'You can close this window now.'
.encode('utf-8')]
def code_received(code):
token = client.exchange_code_for_token(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
code=code)
tokens.insert({'token': token})
print('Got your authorization from Strava. Thanks!')
query_strava()
def avg_speed_to_mins(avg_speed):
sec_per_meter = unit('s') / unit('m')
min_per_mile = unit('min') / unit('mi')
pace = min_per_mile(sec_per_meter(avg_speed.get_num() ** -1))
return pace.get_num()
def query_strava():
print('Querying Strava...')
table = db[ACTIVITIES_TABLE]
activity_summaries = [a for a in client.get_activities()]
num_added = 0
for a_summary in activity_summaries:
if table.find_one(strava_id=a_summary.id):
break
a = client.get_activity(a_summary.id)
activity_data = {
'strava_id': a.id,
'name': a.name,
'type': a.type,
'start_date': a.start_date.isoformat(),
'distance_mi': float(unithelper.miles(a.distance)),
'elapsed_sec': a.elapsed_time.total_seconds(),
'pace_mins_per_mi': avg_speed_to_mins(a.average_speed),
'polyline': a.map.summary_polyline
}
print('Added %s: %s' % (a.type, a.name))
num_added += 1
table.insert(activity_data)
print('Done! %s activities added.' % num_added)
# Stravalib throws lots of warnings for schema issues on Strava's end.
# These warnings don't impact us so let's ignore them.
logger_names = [k for k in logging.Logger.manager.loggerDict.keys() if
k.startswith('stravalib')]
for logger_name in logger_names:
logging.getLogger(logger_name).setLevel(logging.ERROR)
client = Client()
db = dataset.connect(config.DB_URI)
tokens = db[TOKEN_TABLE]
token_obj = tokens.find_one()
if token_obj:
client.access_token = token_obj['token']
query_strava()
else:
get_new_token()
# id and port info
client_id = open('client.id')
client_secret = os.environ['STRAVA_CLIENT_SECRET']
access_token = os.environ['STRAVA_ACCESS_TOKEN']
port = 5000
url = 'http://localhost:%d/authorized' % port
if __name__ == '__main__':
# initialize stravalib client
client = Client()
authorize_url = client.authorization_url(client_id=client_id,
redirect_uri=url)
# get athlete
client.access_token = access_token
athlete = get_athlete(client)
# get activities for athlete
activities = get_activities(client, limit=10)
# initiate mongo database, connect, make collection
db_client = MongoClient(
'localhost', 27017) # Establish connection to persistent storage
db = db_client.Strava # Access/Initiate Database
coll_name = '{}_{}_user'.format(athlete.firstname, athlete.lastname)
collection = db[coll_name]
# write activities to mongodb
types = ['name', 'time', 'latlng', 'altitude', 'distance']
write_activities_to_mongo(activities, types, collection)
"""
Created on Sat Aug 1 11:08:17 2015
@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)}
