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))
Ejemplo n.º 2
0
    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)
Ejemplo n.º 3
0
    def test_get_segment(self):
        segment = self.client.get_segment(229781)
        self.assertIsInstance(segment, model.Segment)
        print(segment)
        self.assertEquals('Hawk Hill', segment.name)
        self.assertAlmostEqual(2.68, float(uh.kilometers(segment.distance)), places=2)

        # Fetch leaderboard
        lb = segment.leaderboard
        self.assertEquals(10, len(lb)) # 10 top results, 5 bottom results
Ejemplo n.º 4
0
def strava_lastact(bot, trigger, client):
    act = next(client.get_activities())

    name = act.name
    act_type = act.type
    distance = unithelper.kilometers(act.distance)
    start = act.start_date_local.strftime('%-d %B %-H:%m')
    time = '{:02}:{:02}:{:02}'.format(*seconds_to_time(act.moving_time.seconds))
    achievements = act.achievement_count

    tokens = [trigger.nick, name, act_type, distance, time, start, achievements]
    out = '{}\'s last activity: {} ({}) {} ({}) on {} ({} ☺️)'.format(*tokens)
    bot.say(out)
    bot.say('https://www.strava.com/activities/{}'.format(act.id))
Ejemplo n.º 5
0
    def test_distance_units(self):

        # Gear
        g = model.Gear()
        g.distance = 1000
        self.assertEquals(1.0, float(uh.kilometers(g.distance)))

        # Metric Split
        split = model.Split()
        split.distance = 1000  # meters
        split.elevation_difference = 1000  # meters
        self.assertIsInstance(split.distance, Quantity)
        self.assertIsInstance(split.elevation_difference, Quantity)
        self.assertEquals(1.0, float(uh.kilometers(split.distance)))
        self.assertEquals(1.0,
                          float(uh.kilometers(split.elevation_difference)))
        split = None

        # Segment
        s = model.Segment()
        s.distance = 1000
        s.elevation_high = 2000
        s.elevation_low = 1000
        s.pr_distance = 1000
        self.assertIsInstance(s.distance, Quantity)
        self.assertIsInstance(s.elevation_high, Quantity)
        self.assertIsInstance(s.elevation_low, Quantity)
        self.assertEquals(1.0, float(uh.kilometers(s.distance)))
        self.assertEquals(2.0, float(uh.kilometers(s.elevation_high)))
        self.assertEquals(1.0, float(uh.kilometers(s.elevation_low)))
        self.assertEquals(1.0, float(uh.kilometers(s.pr_distance)))

        # Activity
        a = model.Activity()
        a.distance = 1000  # m
        a.total_elevation_gain = 1000  # m
        self.assertIsInstance(a.distance, Quantity)
        self.assertIsInstance(a.total_elevation_gain, Quantity)
        self.assertEquals(1.0, float(uh.kilometers(a.distance)))
        self.assertEquals(1.0, float(uh.kilometers(a.total_elevation_gain)))
Ejemplo n.º 6
0
    def test_distance_units(self):

        # Gear
        g = model.Gear()
        g.distance = 1000
        self.assertEquals(1.0, float(uh.kilometers(g.distance)))

        # Metric Split
        split = model.Split()
        split.distance = 1000  # meters
        split.elevation_difference = 1000  # meters
        self.assertIsInstance(split.distance, Quantity)
        self.assertIsInstance(split.elevation_difference, Quantity)
        self.assertEquals(1.0, float(uh.kilometers(split.distance)))
        self.assertEquals(1.0, float(uh.kilometers(split.elevation_difference)))
        split = None

        # Segment
        s = model.Segment()
        s.distance = 1000
        s.elevation_high = 2000
        s.elevation_low = 1000
        s.pr_distance = 1000
        self.assertIsInstance(s.distance, Quantity)
        self.assertIsInstance(s.elevation_high, Quantity)
        self.assertIsInstance(s.elevation_low, Quantity)
        self.assertEquals(1.0, float(uh.kilometers(s.distance)))
        self.assertEquals(2.0, float(uh.kilometers(s.elevation_high)))
        self.assertEquals(1.0, float(uh.kilometers(s.elevation_low)))
        self.assertEquals(1.0, float(uh.kilometers(s.pr_distance)))

        # Activity
        a = model.Activity()
        a.distance = 1000  # m
        a.total_elevation_gain = 1000  # m
        self.assertIsInstance(a.distance, Quantity)
        self.assertIsInstance(a.total_elevation_gain, Quantity)
        self.assertEquals(1.0, float(uh.kilometers(a.distance)))
        self.assertEquals(1.0, float(uh.kilometers(a.total_elevation_gain)))
Ejemplo n.º 7
0
    def test_get_activity(self):
        """ Test basic activity fetching. """
        activity = self.client.get_activity(96089609)
        self.assertEquals('El Dorado County, CA, USA', activity.location_city)

        self.assertIsInstance(activity.start_latlng, attributes.LatLon)
        self.assertAlmostEquals(-120.4357631, activity.start_latlng.lon, places=2)
        self.assertAlmostEquals(38.74263759999999, activity.start_latlng.lat, places=2)

        self.assertIsInstance(activity.map, model.Map)

        self.assertIsInstance(activity.athlete, model.Athlete)
        self.assertEquals(1513, activity.athlete.id)

        #self.assertAlmostEqual(first, second, places, msg, delta)
        # Ensure that iw as read in with correct units
        self.assertEquals(22.5308, float(uh.kilometers(activity.distance)))
Ejemplo n.º 8
0
def strava_koms(bot, trigger, client):
    athlete = client.get_athlete()
    koms = client.get_athlete_koms(athlete.id)

    for kom in koms:
        name = kom.name
        kom_type = kom.segment.activity_type
        distance = unithelper.kilometers(kom.distance)
        time = kom.moving_time
        printtime = '{:02}:{:02}:{:02}'.format(*seconds_to_time(time.seconds))
        efforts = kom.segment.leaderboard.effort_count
        if len(kom.segment.leaderboard.entries) > 1:
            next_time = kom.segment.leaderboard.entries[1].moving_time
            diff = next_time - time
        else:
            diff = time - time
        printdiff = '{:02}:{:02}:{:02}'.format(*seconds_to_time(diff.seconds))

        tokens = [name, kom_type, efforts, distance, printtime, printdiff]
        bot.say('{} ({}): 1/{} - {} in {} - {} faster'.format(*tokens))
Ejemplo n.º 9
0
    def post_activity(self, activity):
        payload = {}
        if (activity.athlete.firstname is None):
            activity.athlete = self.client.get_athlete(activity.athlete.id)

        first_name = activity.athlete.firstname
        last_name = activity.athlete.lastname
        distance = kilometers(activity.distance)
        activity_duration = activity.moving_time
        speed = kilometers_per_hour(activity.average_speed)
        climbing = meters(activity.total_elevation_gain)
        activity_id = activity.id
        description = activity.name

        if (len(description) > 100):
            description = description[:97] + "..."

        payload = {'username': '******', 'icon_url': 'https://raw.githubusercontent.com/patoupatou/pymatterstrava/master/icon-strava.png', 'text': u':bicyclist: *{} {} : distance: {}, moving time duration: {}, speed: {}, climbing: {}* [{}](http://strava.com/activities/{}) :bicyclist:'.format(first_name, last_name, distance, activity_duration, speed, climbing, description, activity_id)}
        r = self.http.request('POST', self.mattermostUrl, headers={'Content-Type': 'application/json'}, body=json.dumps(payload))
        print(time.ctime() + ': New activity posted')
        print('payload: ' + str(payload) + '\n')
Ejemplo n.º 10
0
client = Client()
authorize_url = client.authorization_url(
    clientid, redirect_uri='http://127.0.0.0.0:8100/authorized')
# Have the user click the authorization URL, a 'code' param will be added to the redirect_uri

client = Client(access_token=token_entry)

# Currently-authenticated (based on provided token) athlete
curr_athlete = client.get_athlete()  # This is now me

# Saying hello
athlete = client.get_athlete()
print("Hello, {}".format(athlete.firstname))

# Showing the friends
athlete = client.get_athlete_clubs()
for a in athlete:
    print("{} is your club.".format(a))

# Testing the activities
# setting the athlete specific activity
activity_1 = client.get_activity(activity)

# method to take more activities and its informations
for activity in client.get_activities(after="2010-01-01T00:00:00Z", limit=1):
    print(
        "{0.name} {0.moving_time}".format(activity),
        "type={0.type} distance={1} ".format(
            activity, unithelper.kilometers(activity.distance)))
Ejemplo n.º 11
0
def strava_bikes(bot, trigger, client):
    athlete = client.get_athlete()

    for i in athlete.bikes:
        bot.say('{}: {}'.format(i.name, unithelper.kilometers(i.distance)))
Ejemplo n.º 12
0
def activity_dict(athlete, a):
    elapsed_time = unithelper.seconds(a.elapsed_time.total_seconds())
    if athlete.measurement_preference == 'feet':
        distance = str(unithelper.miles(a.distance))
        gain = str(unithelper.feet(a.total_elevation_gain))
        if a.type == 'Ride':
            speed = str(unithelper.mph(a.average_speed))
            elapsed_speed = str(unithelper.mph(a.distance / elapsed_time))
        else:
            try:
                speed = "{0:.2f} /mi".format(
                    60 / (unithelper.mph(a.average_speed).num))
                elapsed_speed = "{0:.2f} /mi".format(
                    60 / unithelper.mph(a.distance / elapsed_time).num)
            except ZeroDivisionError:
                speed = 'NaN'
                elapsed_speed = 'NaN'
    else:
        distance = str(unithelper.kilometers(a.distance))
        gain = str(unithelper.meters(a.total_elevation_gain))
        if a.type == 'Ride':
            speed = str(unithelper.kph(a.average_speed))
            elapsed_speed = str(unithelper.kph(a.distance / elapsed_time))
        else:
            try:
                speed = "{0:.2f} /km".format(
                    60 / (unithelper.kph(a.average_speed).num))
                elapsed_speed = "{0:.2f} /km".format(
                    60 / unithelper.kph(a.distance / elapsed_time).num)
            except ZeroDivisionError:
                speed = 'NaN'
                elapsed_speed = 'NaN'

    date = a.start_date_local.strftime(athlete.date_preference
                                       or "%a, %d %b %Y")
    weekday = calendar.day_name[a.start_date_local.weekday()]

    workout_type = ''
    if a.type == 'Run':
        workout_type = ['', 'Race', 'Long Run', 'Workout'][int(a.workout_type
                                                               or 0)]

    garmin_link = ''
    if a.external_id:
        if a.external_id.startswith('garmin_push_'):
            garmin_id = a.external_id.split('_')[2]
            garmin_link = 'https://connect.garmin.com/modern/activity/{}'.format(
                garmin_id)

    return {
        'id': a.id,
        'link': url_for('query.show_activity', id=a.id),
        'strava_link': 'https://www.strava.com/activities/{}'.format(a.id),
        'garmin_link': garmin_link,
        'name': a.name,
        'type': a.type,
        'workout_type': workout_type,
        'date': date,
        'weekday': weekday,
        'distance': distance,
        'gain': gain,
        'elapsed_time': str(a.elapsed_time),
        'moving_time': str(a.moving_time),
        'speed': speed,
        'elapsed_speed': elapsed_speed,
        'start_latlng': [a.start_latitude, a.start_longitude],
        'polyline': a.map.polyline or a.map.summary_polyline
    }
Ejemplo n.º 13
0
def create_club_workbook(filename: str, athlete_map: dict):
    workbook = Workbook(filename, {'default_date_format':'dd/mm/yy'})
    worksheet = workbook.add_worksheet()

    bold = workbook.add_format({'bold': True})

    row = 0
    col = 0

    worksheet.write(row, col, 'Name', bold)
    worksheet.write(row, col+1, 'Distance (km)', bold)
    worksheet.write(row, col+2, 'Moving Time (s)', bold)
    worksheet.write(row, col+3, 'Elapsed Time (s)', bold)
    worksheet.write(row, col+4, 'Total Elevation Gain (m)', bold)
    worksheet.write(row, col+5, 'Activity Type', bold)

    worksheet.set_column('A:A', 14)
    worksheet.set_column('B:B', 20)
    worksheet.set_column('C:C', 20)
    worksheet.set_column('D:D', 20)
    worksheet.set_column('E:E', 28)
    worksheet.set_column('F:F', 18)

    row += 1

    total_distance_kilometers = float(0)

    for key in athlete_map:

        athlete_distance_kilometers = 0
        athlete_moving_time_seconds = 0
        athlete_elapsed_time_seconds = 0
        athlete_total_elevation_gain_meters = 0

        for idx, activity in enumerate(athlete_map[key]):
            distance_kilometers = unithelper.kilometers(activity['distance'])
            athlete_distance_kilometers += float(distance_kilometers)
            moving_time = activity['moving_time']
            athlete_moving_time_seconds += moving_time.seconds
            elapsed_time = activity['elapsed_time']
            athlete_elapsed_time_seconds += elapsed_time.seconds
            total_elevation_gain_meters = unithelper.meters(activity['total_elevation_gain'])
            athlete_total_elevation_gain_meters += float(total_elevation_gain_meters)

            worksheet.write(row, col, key)
            worksheet.write(row, col+1, round(float(distance_kilometers), util.DEFAULT_DECIMAL_PLACES))
            worksheet.write(row, col+2, moving_time.seconds)
            worksheet.write(row, col+3, elapsed_time.seconds)
            worksheet.write(row, col+4, float(total_elevation_gain_meters))
            worksheet.write(row, col+5, activity['type'])

            row += 1
            col = 0

        total_distance_kilometers += athlete_distance_kilometers

    print(
        '=> Total distance is {total_distance_kilometers} km'.format(
            total_distance_kilometers=round(total_distance_kilometers, util.DEFAULT_DECIMAL_PLACES),
        )
    )

    workbook.close()
    print(
        '\n=> Wrote "{filename}"\n'.format(
            filename=filename,
        )
    )
Ejemplo n.º 14
0
def add_run(user, activity):
    return add_activity(user, RUN_GOAL_SLUG, activity, unithelper.kilometers(activity.distance))