def test_record_pp_fit():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
record_pp = RecordPowerProfile(max_duration_profile=1, cyclist_weight=None)
record_pp.fit(ride_pp_list)
data = np.array([
0., 750., 741., 731.66666667, 719.5, 712.2, 705., 694.85714286, 684.,
669.22222222, 652.9, 634.36363636, 616.75, 601.84615385, 584.92857143,
562.6, 540.3125, 520.64705882, 502.44444444, 480.57894737, 467.05,
460.28571429, 452.45454545, 447.60869565, 442.625, 436.6, 433.76923077,
430.07407407, 424.96428571, 422.03448276, 419.16666667, 415.5483871,
412.65625, 408.87878788, 405.70588235, 403.37142857, 400.16666667,
397.91891892, 395.57894737, 393.56410256, 392.15, 388.90243902,
385.80952381, 384.11627907, 382.29545455, 380.64444444, 378.93478261,
376.89361702, 375.89583333, 375.18367347, 373.24, 371.50980392, 369.25,
367.64150943, 366.51851852, 365.47272727, 364.17857143, 362.87719298,
361.70689655, 361.27118644
])
assert_allclose(record_pp.data_, data)
assert_equal(record_pp.data_norm_, None)
assert_equal(record_pp.max_duration_profile, 1)
assert_equal(record_pp.cyclist_weight, None)
assert_equal(record_pp.date_profile_,
(date(2014, 5, 7), date(2014, 7, 26)))
def test_rider_add_rides_path_overwrite():
filename_list = load_toy()[:2]
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
rider = Rider(cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
assert_equal(len(rider.rides_pp_), 2)
path_fit = load_toy(returned_type='path')
rider.add_rides(path_fit, overwrite=True)
assert_equal(len(rider.rides_pp_), 3)
def test_rider_delete_ride_warning_nothing():
filename = load_toy()[0]
rider = Rider(cyclist_weight=60., max_duration_profile=1)
rider.add_rides(filename)
rider.delete_ride(date(2014, 5, 7))
assert_warns(UserWarning, rider.delete_ride, date(2014, 5, 7))
assert_equal(len(rider.rides_pp_), 0)
def test_load_power_if_no_power():
filenames = load_toy(set_data='corrupted')
pattern = '2014-05-17-10-44-53.fit'
for f in filenames:
if pattern in f:
filename = f
assert_warns(UserWarning, load_power_from_fit, filename)
def test_record_pp_fit_date():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1, cyclist_weight=60.)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
record_pp = RecordPowerProfile(max_duration_profile=1, cyclist_weight=60.)
record_pp.fit(ride_pp_list,
date_profile=(date(2014, 5, 7), date(2014, 5, 11)))
data = np.array([
0., 717., 717., 590., 552.25, 552.6, 551.83333333, 550.42857143, 547.,
540.44444444, 539.8, 535.09090909, 529.75, 520.15384615, 509.85714286,
502.13333333, 495.125, 489.82352941, 482.72222222, 474.78947368,
467.05, 460.28571429, 452.45454545, 447.60869565, 442.625, 436.6,
433.76923077, 430.07407407, 424.96428571, 422.03448276, 419.16666667,
415.5483871, 412.65625, 408.87878788, 405.70588235, 403.37142857,
400.16666667, 397.91891892, 395.57894737, 393.56410256, 392.15,
388.90243902, 385.80952381, 384.11627907, 382.29545455, 380.64444444,
378.93478261, 376.89361702, 375.89583333, 375.18367347, 373.24,
371.50980392, 369.25, 367.64150943, 366.51851852, 365.47272727,
364.17857143, 362.87719298, 361.70689655, 361.27118644
])
assert_allclose(record_pp.data_, data)
assert_allclose(record_pp.data_norm_, data / 60.)
assert_equal(record_pp.max_duration_profile, 1)
assert_allclose(record_pp.cyclist_weight, 60.)
assert_equal(record_pp.date_profile_,
(date(2014, 5, 7), date(2014, 5, 11)))
def test_save_load_rider():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
rider = Rider(cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
rider.compute_record_pp()
# temporary directory
tmp_dir = mkdtemp()
try:
filename = os.path.join(tmp_dir, 'rider.pkl')
rider.save_to_pickles(filename)
obj = rider.load_from_pickles(filename)
assert_array_equal(rider.rides_pp_[0].data_, obj.rides_pp_[0].data_)
assert_array_equal(rider.record_pp_.data_, obj.record_pp_.data_)
assert_equal(rider.max_duration_profile, obj.max_duration_profile)
assert_equal(rider.cyclist_weight, obj.cyclist_weight)
finally:
shutil.rmtree(tmp_dir)
def test_record_pp_fit_forget_fitting():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
record_pp = RecordPowerProfile(max_duration_profile=1)
assert_raises(ValueError, record_pp.fit, ride_pp_list)
def test_load_toy_list_file_corrupted():
filenames = load_toy(set_data='corrupted')
gt_filenames = sorted([
'2013-04-24-22-22-25.fit', '2014-05-17-10-44-53.fit',
'2015-11-27-18-54-57.fit'
])
for f, gt in zip(filenames, gt_filenames):
assert_true(gt in f)
def test_load_power_if_no_record():
filenames = load_toy(set_data='corrupted')
pattern = '2015-11-27-18-54-57.fit'
for f in filenames:
if pattern in f:
filename = f
assert_raises_regex(ValueError, "There is no data to treat in that file.",
load_power_from_fit, filename)
def test_load_toy_list_file():
filenames = load_toy()
gt_filenames = sorted([
'2014-05-11-11-39-38.fit', '2014-05-07-14-26-22.fit',
'2014-07-26-18-50-56.fit'
])
for f, gt in zip(filenames, gt_filenames):
assert_true(gt in f)
def test_rpp_parallel():
pattern = '2014-05-07-14-26-22.fit'
filename_list = load_toy()
for f in filename_list:
if pattern in f:
filename = f
power_rec = load_power_from_fit(filename)
val = _rpp_parallel(power_rec, 1)
assert_allclose(val, 500.)
def test_load_power_normal_file():
filenames = load_toy(set_data='corrupted')
pattern = '2013-04-24-22-22-25.fit'
for f in filenames:
if pattern in f:
filename = f
power, date_loaded = load_power_from_fit(filename)
assert_allclose(power, ride)
assert_equal(date_loaded, date(2013, 4, 24))
def test_record_pp_fit_different_max_duration():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=i + 1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
record_pp = RecordPowerProfile(max_duration_profile=1)
assert_raises(ValueError, record_pp.fit, ride_pp_list)
def test_mmp_wrong_type():
assert_raises(ValueError, maximal_mean_power, 1)
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=i + 1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
ride_pp_list.append(1)
assert_raises(ValueError, maximal_mean_power, ride_pp_list)
def test_rider_init_rides_not_init():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
assert_raises_regex(ValueError, "One of the ride never has been fitted."
" Fit before to compute the record rpp.",
Rider,
cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
def test_record_pp_fit_wrong_pp_list_type():
pattern = '2014-05-07-14-26-22.fit'
filename_list = load_toy()
for f in filename_list:
if pattern in f:
filename = [f]
ride_pp_list = [
RidePowerProfile(max_duration_profile=1, cyclist_weight=60.)
for i in range(len(filename))
]
ride_pp_list[0].fit(filename[0])
ride_pp_list.insert(1, 1)
record_pp = RecordPowerProfile(max_duration_profile=1, cyclist_weight=60.)
assert_raises(ValueError, record_pp.fit, ride_pp_list)
def test_rider_add_rides_path():
rider = Rider(cyclist_weight=60., max_duration_profile=1)
path_fit = load_toy(returned_type='path')
rider.add_rides(path_fit)
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
# Initialize the rider
rider2 = Rider(cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
# Check the consistency between the two riders
for r1, r2 in zip(rider.rides_pp_, rider2.rides_pp_):
assert_array_equal(r1.data_, r2.data_)
def test_rider_init_rides():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
rider = Rider(cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
assert_equal(rider.cyclist_weight, 60.)
assert_equal(rider.max_duration_profile, 1)
def test_rider_init_rides_wrong_duration():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=2)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
assert_raises_regex(ValueError, "The maximum duration of the profile"
" should be the same for all the data",
Rider,
cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
def test_rider_add_ride_fit():
filename_list = load_toy()
# rider and add up all files
rider = Rider(cyclist_weight=60., max_duration_profile=1)
for filename in filename_list:
rider.add_rides(filename)
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
rider2 = Rider(cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
assert_array_equal(rider.rides_pp_[0].data_, rider2.rides_pp_[0].data_)
def test_rider_init_rides_wrong_type_in_list():
filename_list = load_toy()
ride_pp_list = [
RidePowerProfile(max_duration_profile=1)
for i in range(len(filename_list))
]
for ride, filename in zip(ride_pp_list, filename_list):
ride.fit(filename)
# Add something random
ride_pp_list.append(1)
assert_raises_regex(ValueError, "The object in the list need"
" to be from the type RidePowerProfile",
Rider,
cyclist_weight=60.,
max_duration_profile=1,
rides_pp=ride_pp_list)
def test_compute_record_pp():
path_fit = load_toy(returned_type='path')
rider = Rider(cyclist_weight=60., max_duration_profile=1)
rider.add_rides(path_fit)
rider.compute_record_pp()
record_pp = np.array([
0., 750., 741., 731.66666667, 719.5, 712.2, 705., 694.85714286, 684.,
669.22222222, 652.9, 634.36363636, 616.75, 601.84615385, 584.92857143,
562.6, 540.3125, 520.64705882, 502.44444444, 480.57894737, 467.05,
460.28571429, 452.45454545, 447.60869565, 442.625, 436.6, 433.76923077,
430.07407407, 424.96428571, 422.03448276, 419.16666667, 415.5483871,
412.65625, 408.87878788, 405.70588235, 403.37142857, 400.16666667,
397.91891892, 395.57894737, 393.56410256, 392.15, 388.90243902,
385.80952381, 384.11627907, 382.29545455, 380.64444444, 378.93478261,
376.89361702, 375.89583333, 375.18367347, 373.24, 371.50980392, 369.25,
367.64150943, 366.51851852, 365.47272727, 364.17857143, 362.87719298,
361.70689655, 361.27118644
])
assert_allclose(rider.record_pp_.data_, record_pp)
def test_save_load_ride_pp():
filename = load_toy()[0]
my_ride_rpp = RidePowerProfile(max_duration_profile=1)
my_ride_rpp.fit(filename)
tmp_dir = mkdtemp()
try:
store_filename = os.path.join(tmp_dir, 'ride_rpp.pkl')
my_ride_rpp.save_to_pickles(store_filename)
obj = RidePowerProfile.load_from_pickles(store_filename)
assert_array_equal(my_ride_rpp.data_, obj.data_)
assert_equal(my_ride_rpp.data_norm_, obj.data_norm_)
assert_equal(my_ride_rpp.cyclist_weight, obj.cyclist_weight)
assert_equal(my_ride_rpp.max_duration_profile,
obj.max_duration_profile)
assert_equal(my_ride_rpp.date_profile_, obj.date_profile_)
assert_equal(my_ride_rpp.filename_, obj.filename_)
finally:
shutil.rmtree(tmp_dir)
def test_compute_record_pp_date():
path_fit = load_toy(returned_type='path')
rider = Rider(cyclist_weight=60., max_duration_profile=1)
rider.add_rides(path_fit)
rider.compute_record_pp(date_start_finish=(date(2014, 5, 7),
date(2014, 5, 11)))
record_pp = np.array([
0., 717., 717., 590., 552.25, 552.6, 551.83333333, 550.42857143, 547.,
540.44444444, 539.8, 535.09090909, 529.75, 520.15384615, 509.85714286,
502.13333333, 495.125, 489.82352941, 482.72222222, 474.78947368,
467.05, 460.28571429, 452.45454545, 447.60869565, 442.625, 436.6,
433.76923077, 430.07407407, 424.96428571, 422.03448276, 419.16666667,
415.5483871, 412.65625, 408.87878788, 405.70588235, 403.37142857,
400.16666667, 397.91891892, 395.57894737, 393.56410256, 392.15,
388.90243902, 385.80952381, 384.11627907, 382.29545455, 380.64444444,
378.93478261, 376.89361702, 375.89583333, 375.18367347, 373.24,
371.50980392, 369.25, 367.64150943, 366.51851852, 365.47272727,
364.17857143, 362.87719298, 361.70689655, 361.27118644
])
assert_allclose(rider.record_pp_.data_, record_pp)
def test_ridepp_fit_w_weight():
filename = load_toy()[0]
ride_rpp = RidePowerProfile(max_duration_profile=1, cyclist_weight=60.)
ride_rpp.fit(filename)
data = np.array([
0., 500., 475.5, 469.33333333, 464., 463., 462.33333333, 461.71428571,
455.875, 450.55555556, 447.3, 444.81818182, 442.08333333, 439.53846154,
435.71428571, 432.06666667, 428.75, 424.35294118, 420.44444444,
413.78947368, 409.9, 407.23809524, 402.5, 399.91304348, 396.45833333,
394.76, 392.19230769, 388.62962963, 384.75, 380., 373.8, 367.70967742,
362.96875, 357.90909091, 354.02941176, 349.68571429, 345.83333333,
342.18918919, 338.36842105, 335.02564103, 331.375, 328.95121951,
325.64285714, 322.37209302, 318.09090909, 315.15555556, 312.23913043,
309.59574468, 307.08333333, 304.55102041, 301.9, 300.70588235, 300.5,
299.90566038, 300.03703704, 298.92727273, 298.10714286, 297.56140351,
296.48275862, 296.30508475
])
assert_allclose(ride_rpp.data_, data)
assert_allclose(ride_rpp.data_norm_, data / 60.)
assert_allclose(ride_rpp.cyclist_weight, 60.)
assert_equal(ride_rpp.max_duration_profile, 1)
assert_equal(ride_rpp.date_profile_, date(2014, 5, 7))
assert_equal(ride_rpp.filename_, filename)
def test_record_pp_fit_date_wrong_tuple():
pattern = ['2014-05-07-14-26-22.fit', '2014-05-11-11-39-38.fit']
filename_list = load_toy()
filename = []
for prod_pf in product(pattern, filename_list):
if prod_pf[0] in prod_pf[1]:
filename.append(prod_pf[1])
ride_pp_list = [
RidePowerProfile(max_duration_profile=1, cyclist_weight=60.)
for i in range(len(filename))
]
for ride, f in zip(ride_pp_list, filename):
ride.fit(f)
record_pp = RecordPowerProfile(max_duration_profile=1, cyclist_weight=60.)
assert_raises(ValueError, record_pp.fit, ride_pp_list, date_profile=[1, 1])
assert_raises(ValueError,
record_pp.fit,
ride_pp_list,
date_profile=(1, 2, 3))
assert_raises(ValueError, record_pp.fit, ride_pp_list, date_profile=(1, 2))
assert_raises(ValueError,
record_pp.fit,
ride_pp_list,
date_profile=(date(2014, 1, 2), date(2014, 1, 1)))
def test_save_load_ride_pp():
filename = load_toy()[0]
my_ride_rpp = RidePowerProfile(max_duration_profile=1)
my_ride_rpp.fit(filename)
val = my_ride_rpp.resampling_rpp(.5)
assert_allclose(val, 376.9)
def test_save_load_ride_pp_wrong_norm():
filename = load_toy()[0]
my_ride_rpp = RidePowerProfile(max_duration_profile=1, cyclist_weight=None)
my_ride_rpp.fit(filename)
assert_raises(ValueError, my_ride_rpp.resampling_rpp, .5, normalized=True)
def test_save_load_ride_pp_weight():
filename = load_toy()[0]
my_ride_rpp = RidePowerProfile(max_duration_profile=1, cyclist_weight=60.)
my_ride_rpp.fit(filename)
val = my_ride_rpp.resampling_rpp(.5, normalized=True)
assert_allclose(val, 6.281666666666666)
def test_rider_delete_ride_no_date():
filename = load_toy()[0]
rider = Rider(cyclist_weight=60., max_duration_profile=1)
rider.add_rides(filename)
assert_raises_regex(ValueError, "The date should be a date object",
rider.delete_ride, '2014, 5, 11')
