def test_stream(self):
        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'mine': [0.0, 1.0, 2.0, 3.0, 4.0],
            }))
        data = activity.mine.stream
        # data = activity.mine.stream('records')
        self.assertIs(data, activity.records['mine'])

        activity_not_mine = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'not_mine': [0.0, 1.0, 2.0, 3.0, 4.0],
            }))
        self.assertIsNone(activity_not_mine.mine.stream)
 def test_has(self):
     activity = heartandsole.Activity(
         pd.DataFrame.from_dict({
             'mine': [0.0, 1.0, 2.0, 3.0, 4.0],
         }))
     self.assertTrue(activity.has_streams('mine'))
     self.assertFalse(activity.has_streams('not_mine'))
    def test_loss(self):
        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({'elevation': [6.0, 0.0, 1.0, 0.0]}),
            summary=pd.Series({'elevation_loss': 100.0}),
            laps=pd.DataFrame.from_dict({'elevation_loss': [50.0, 75.0]}),
        )

        for src, expected in zip(('records', 'summary', 'laps'),
                                 (6.0, 100.0, 125.0)):
            result = activity.elevation.loss(src)
            self.assertIsInstance(result, float)
            self.assertEqual(result, expected)

        activity_blank = heartandsole.Activity(pd.DataFrame([]))
        for src in ['records', 'summary', 'laps']:
            # Might wanna raise a warning here, or something.
            self.assertIsNone(activity_blank.elevation.loss(src))
    def test_exists(self):
        self.assertIn('mine', heartandsole.Activity._fields)
        self.assertIn('mine', dir(heartandsole.Activity))
        self.assertIs(heartandsole.Activity.mine, MyField)

        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'mine': [0.0, 1.0, 2.0, 3.0, 4.0],
            }))
        self.assertIsInstance(activity.mine, MyField)
 def setUpClass(cls):
     cls.activity = heartandsole.Activity(
         pd.DataFrame.from_dict({
             'distance': [0.0, 25.0, 50.0, 75.0, 100.0],
             'lat': [40.0, 40.1, 40.2, 40.3, 40.4],
             'lon': [-105.0, -105.0, -105.0, -105.0, -105.0]
         }),
         summary=pd.Series({'distance': 100.0}),
         laps=pd.DataFrame.from_dict({'distance': [50.0, 50.0]}),
     )
    def test_time_from_timestamp(self):
        t0 = datetime.datetime.now()
        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'timestamp':
                [t0 + datetime.timedelta(seconds=s) for s in (0, 50, 75, 100)],
            }))

        result = activity.time.records_from_timestamps()
        expected = pd.Series([0, 50, 75, 100], name='time')
        tm.assert_series_equal(result, expected)
    def test_total(self):
        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'distance': [0.0, 25.0, 50.0, 75.0, 100.0],
                'lat': [40 + 0.00001 * i for i in range(5)],
                'lon': [-105.0, -105.0, -105.0, -105.0, -105.0]
            }),
            summary=pd.Series({'distance_total': 101.0}),
            laps=pd.DataFrame.from_dict({'distance_total': [50.0, 52.0]}),
        )
        for src, expected in zip(('records', 'summary', 'laps', 'position'),
                                 (100.0, 101.0, 102.0, 4 * 0.00001 * 111200)):
            result = activity.distance.total(src)
            self.assertIsInstance(result, float)
            self.assertAlmostEqual(result, expected, places=3)
            # print(self.activity.distance.total(src))

        activity_blank = heartandsole.Activity(pd.DataFrame([]))
        for src in ['records', 'summary', 'laps']:
            # Might wanna raise a warning here, or something.
            self.assertIsNone(activity_blank.distance.total(src))
    def test_convert_units(self):
        # Semicircle units
        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'lat': [40.0 * 2**31 / 180],
                'lon': [-105.0 * 2**31 / 180]
            }))

        activity.lat._convert_record_units(inplace=True)
        activity.lon._convert_record_units(inplace=True)

        self.assertEqual(activity.records['lat'].iloc[0], 40.0)
        self.assertEqual(activity.records['lon'].iloc[0], -105.0)
    def test_summary(self):
        activity = heartandsole.Activity(pd.DataFrame([]),
                                         summary=pd.Series({
                                             'mine_a': 'a',
                                             'mine_1': 1,
                                             'other_b': 'b',
                                             'c_mine': 'c',
                                         }))
        result = activity.mine.summary
        expected = pd.Series({'a': 'a', '1': 1, 'c': 'c'})
        tm.assert_series_equal(result, expected)

        result = activity.mine.summary_rows
        expected = pd.Index(['mine_a', 'mine_1', 'c_mine'])
        tm.assert_index_equal(result, expected)
    def test_tz(self):
        for tz_local in [
                dateutil.tz.gettz(name='UTC'),
                dateutil.tz.gettz(name='America/Denver'),
                # dateutil.tz.gettz(name='AEST-10AEDT-11,M10.1.0/2,M4.1.0/3'), # error
                'UTC',
                'America/Denver'
        ]:

            t0 = datetime.datetime.now()
            activity = heartandsole.Activity(
                pd.DataFrame.from_dict({
                    'timestamp': [
                        t0 + datetime.timedelta(seconds=s)
                        for s in (0, 50, 75, 100)
                    ],
                }),
                summary=pd.Series({
                    'timestamp_start':
                    t0,
                    'timestamp_end':
                    t0 + datetime.timedelta(seconds=101)
                }),
                laps=pd.DataFrame.from_dict({
                    'timestamp_start':
                    [t0, t0 + datetime.timedelta(seconds=49)],
                    'timestamp_end': [
                        t0 + datetime.timedelta(seconds=49),
                        t0 + datetime.timedelta(seconds=99)
                    ],
                }),
            )

            activity.timestamp.ensure_aware(tz_local)

            for series in [
                    activity.records['timestamp'],
                    activity.laps['timestamp_start'],
                    activity.laps['timestamp_end']
            ]:
                self.assertTrue(pd.api.types.is_datetime64tz_dtype(series))

            for row in [
                    activity.summary['timestamp_start'],
                    activity.summary['timestamp_end'],
            ]:
                self.assertIsNotNone(row.tz)
    def test_timer(self):
        activity = heartandsole.Activity(
            pd.DataFrame([]),
            summary=pd.Series({
                'time_timer': 300.0,
            }),
            laps=pd.DataFrame.from_dict({
                'time_timer': [200.0, 150.0],
            }),
        )

        self.assertEqual(activity.time.timer('summary'), 300)
        self.assertEqual(activity.time.timer('laps'), 350)

        activity_blank = Activity(pd.DataFrame([]))
        for src in ['summary', 'laps']:
            self.assertIsNone(activity_blank.time.timer(src))
    def test_elapsed(self):
        t0 = datetime.datetime.now()
        activity = heartandsole.Activity(
            pd.DataFrame.from_dict({
                'timestamp':
                [t0 + datetime.timedelta(seconds=s) for s in (0, 50, 75, 100)],
                'time': [0, 100, 200, 400],
            }),
            summary=pd.Series({
                'time_elapsed':
                300.0,
                'timestamp_start':
                t0,
                'timestamp_end':
                t0 + datetime.timedelta(seconds=101)
            }),
            laps=pd.DataFrame.from_dict({
                'time_elapsed': [200.0, 150.0],
                'timestamp_start': [t0, t0 + datetime.timedelta(seconds=49)],
                'timestamp_end': [
                    t0 + datetime.timedelta(seconds=49),
                    t0 + datetime.timedelta(seconds=99)
                ],
            }),
        )

        self.assertEqual(
            activity.timestamp.elapsed('records'),  # pd.Timedelta
            datetime.timedelta(seconds=100))
        self.assertEqual(
            activity.timestamp.elapsed('summary'),  # dt.timedelta
            datetime.timedelta(seconds=101))
        self.assertEqual(
            activity.timestamp.elapsed('laps'),  # pd.Timedelta
            datetime.timedelta(seconds=99))
        self.assertEqual(activity.time.elapsed('records'), 400)
        self.assertEqual(activity.time.elapsed('summary'), 300)
        self.assertEqual(activity.time.elapsed('laps'), 350)

        activity_blank = Activity(pd.DataFrame([]))
        for src in ['records', 'summary', 'laps']:
            self.assertIsNone(activity_blank.time.elapsed(src))
            self.assertIsNone(activity_blank.timestamp.elapsed(src))
    def test_laps(self):
        activity = heartandsole.Activity(pd.DataFrame([]),
                                         laps=pd.DataFrame.from_dict({
                                             'mine_a': ['a', 'a'],
                                             'mine_1': [1, 1],
                                             'other_b': ['b', 'b'],
                                             'c_mine': ['c', 'c']
                                         }))

        result = activity.mine.laps
        expected = pd.DataFrame.from_dict({
            'a': ['a', 'a'],
            '1': [1, 1],
            'c': ['c', 'c'],
        })
        tm.assert_frame_equal(result, expected)

        result = activity.mine.lap_cols
        expected = pd.Index(['mine_a', 'mine_1', 'c_mine'])
        tm.assert_index_equal(result, expected)
 def test_center(self):
     activity = heartandsole.Activity(
         pd.DataFrame.from_dict({'lat': [40.0, 40.1, 40.1, 45.0]}))
     self.assertEqual(activity.lat.center, 42.5)
 def setUpClass(cls):
     cls.activity = heartandsole.Activity(
         pd.DataFrame.from_dict({
             'elevation': [0.0, 1.0, 2.0, 1.0, 3.0],
         }))