def test_400():
assert open_time(200, 400, time) == arrow.get('2021-01-01T06:54',
'YYYY-MM-DDTHH:mm')
assert close_time(200, 400, time) == arrow.get('2021-01-01T14:21',
'YYYY-MM-DDTHH:mm')
assert open_time(250, 400, time) == arrow.get('2021-01-01T08:28',
'YYYY-MM-DDTHH:mm')
assert close_time(250, 400, time) == arrow.get('2021-01-01T17:41',
'YYYY-MM-DDTHH:mm')
assert open_time(300, 400, time) == arrow.get('2021-01-01T10:01',
'YYYY-MM-DDTHH:mm')
assert close_time(300, 400, time) == arrow.get('2021-01-01T21:01',
'YYYY-MM-DDTHH:mm')
assert open_time(350, 400, time) == arrow.get('2021-01-01T11:35',
'YYYY-MM-DDTHH:mm')
assert close_time(350, 400, time) == arrow.get('2021-01-02T00:21',
'YYYY-MM-DDTHH:mm')
assert open_time(400, 400, time) == arrow.get('2021-01-01T13:09',
'YYYY-MM-DDTHH:mm')
assert close_time(400, 400, time) == arrow.get('2021-01-02T04:01',
'YYYY-MM-DDTHH:mm')
def test_incorrect_short_control():
'''
An incorrect implementation will make all closing times later/or equal
to the starting point's closing time.
'''
assert not close_time(10, BREVET_DISTANCES[0], START_TIME) >= close_time(
0, BREVET_DISTANCES[0], START_TIME)
def test_200():
assert open_time(0, 200, time) == arrow.get('2021-01-01T01:01',
'YYYY-MM-DDTHH:mm')
assert close_time(0, 200, time) == arrow.get('2021-01-01T02:01',
'YYYY-MM-DDTHH:mm')
assert open_time(50, 200, time) == arrow.get('2021-01-01T02:29',
'YYYY-MM-DDTHH:mm')
assert close_time(50, 200, time) == arrow.get('2021-01-01T04:31',
'YYYY-MM-DDTHH:mm')
assert open_time(100, 200, time) == arrow.get('2021-01-01T03:57',
'YYYY-MM-DDTHH:mm')
assert close_time(100, 200, time) == arrow.get('2021-01-01T07:41',
'YYYY-MM-DDTHH:mm')
assert open_time(150, 200, time) == arrow.get('2021-01-01T05:26',
'YYYY-MM-DDTHH:mm')
assert close_time(150, 200, time) == arrow.get('2021-01-01T11:01',
'YYYY-MM-DDTHH:mm')
assert open_time(200, 200, time) == arrow.get('2021-01-01T06:54',
'YYYY-MM-DDTHH:mm')
assert close_time(200, 200, time) == arrow.get('2021-01-01T14:31',
'YYYY-MM-DDTHH:mm')
def test_300():
assert open_time(50, 300, time) == arrow.get('2021-01-01T02:29',
'YYYY-MM-DDTHH:mm')
assert close_time(50, 300, time) == arrow.get('2021-01-01T04:31',
'YYYY-MM-DDTHH:mm')
assert open_time(100, 300, time) == arrow.get('2021-01-01T03:57',
'YYYY-MM-DDTHH:mm')
assert close_time(100, 300, time) == arrow.get('2021-01-01T07:41',
'YYYY-MM-DDTHH:mm')
assert open_time(200, 300, time) == arrow.get('2021-01-01T06:54',
'YYYY-MM-DDTHH:mm')
assert close_time(200, 300, time) == arrow.get('2021-01-01T14:21',
'YYYY-MM-DDTHH:mm')
assert open_time(290, 400, time) == arrow.get('2021-01-01T09:43',
'YYYY-MM-DDTHH:mm')
assert close_time(290, 400, time) == arrow.get('2021-01-01T20:21',
'YYYY-MM-DDTHH:mm')
assert open_time(300, 300, time) == arrow.get('2021-01-01T10:01',
'YYYY-MM-DDTHH:mm')
assert close_time(300, 300, time) == arrow.get('2021-01-01T21:01',
'YYYY-MM-DDTHH:mm')
def test_600():
assert open_time(400, 600, time) == arrow.get('2021-01-01T13:09',
'YYYY-MM-DDTHH:mm')
assert close_time(400, 600, time) == arrow.get('2021-01-02T03:41',
'YYYY-MM-DDTHH:mm')
assert open_time(450, 600, time) == arrow.get('2021-01-01T14:49',
'YYYY-MM-DDTHH:mm')
assert close_time(450, 600, time) == arrow.get('2021-01-02T07:01',
'YYYY-MM-DDTHH:mm')
assert open_time(500, 600, time) == arrow.get('2021-01-01T16:29',
'YYYY-MM-DDTHH:mm')
assert close_time(500, 600, time) == arrow.get('2021-01-02T10:21',
'YYYY-MM-DDTHH:mm')
assert open_time(550, 600, time) == arrow.get('2021-01-01T18:09',
'YYYY-MM-DDTHH:mm')
assert close_time(550, 600, time) == arrow.get('2021-01-02T13:41',
'YYYY-MM-DDTHH:mm')
assert open_time(600, 600, time) == arrow.get('2021-01-01T19:49',
'YYYY-MM-DDTHH:mm')
assert close_time(600, 600, time) == arrow.get('2021-01-02T17:01',
'YYYY-MM-DDTHH:mm')
def test_1000():
assert open_time(600, 1000, time) == arrow.get('2021-01-01T19:49',
'YYYY-MM-DDTHH:mm')
assert close_time(600, 1000, time) == arrow.get('2021-01-02T17:01',
'YYYY-MM-DDTHH:mm')
assert open_time(700, 1000, time) == arrow.get('2021-01-01T23:23',
'YYYY-MM-DDTHH:mm')
assert close_time(700, 1000, time) == arrow.get('2021-01-03T01:46',
'YYYY-MM-DDTHH:mm')
assert open_time(800, 1000, time) == arrow.get('2021-01-02T02:58',
'YYYY-MM-DDTHH:mm')
assert close_time(800, 1000, time) == arrow.get('2021-01-03T10:31',
'YYYY-MM-DDTHH:mm')
assert open_time(900, 1000, time) == arrow.get('2021-01-02T06:32',
'YYYY-MM-DDTHH:mm')
assert close_time(900, 1000, time) == arrow.get('2021-01-03T19:16',
'YYYY-MM-DDTHH:mm')
assert open_time(1000, 1000, time) == arrow.get('2021-01-02T10:06',
'YYYY-MM-DDTHH:mm')
assert close_time(1000, 1000, time) == arrow.get('2021-01-04T04:01',
'YYYY-MM-DDTHH:mm')
def test_difclosetime(): # checks close time for short control dist
ans = bday.shift(hours=18)
ans = ans.isoformat()
print("ans: ", ans)
print("what calc is returning: ", acp_times.close_time(150, 1000, bday))
#print("is same?", acp_times.close_time(60, 200, bday) == ans)
assert acp_times.close_time(150, 1000, bday) == ans
def test_oddities():
# test 1-hour window at 0
for dist in brevet_dists:
assert open_time(0, dist, start_time) == arrow.get(
'2021-02-20 14:00:00', 'YYYY-MM-DD HH:mm:ss')
assert close_time(0, dist, start_time) == arrow.get(
'2021-02-20 15:00:00', 'YYYY-MM-DD HH:mm:ss')
# by the rules the time for a 200km brevet is 13H30
assert close_time(200, 200, start_time) == arrow.get(
'2021-02-21 03:30:00', 'YYYY-MM-DD HH:mm:ss')
# there seems to be a similar extension at 400km
assert close_time(400, 400, start_time) == arrow.get(
'2021-02-21 17:00:00', 'YYYY-MM-DD HH:mm:ss')
# just guessing this is another oddity
assert close_time(1000, 1000, start_time) == arrow.get(
'2021-02-23 17:00:00', 'YYYY-MM-DD HH:mm:ss')
# final controle can be up through 20% longer than brevet distance
assert close_time(310, 300, start_time) == arrow.get(
'2021-02-21 10:00:00', 'YYYY-MM-DD HH:mm:ss')
# TODO: this is super-weird - even when this is broken in acp_times.py, it passes
assert open_time(301, 300, start_time) == arrow.get(
'2021-02-20 23:00:00', 'YYYY-MM-DD HH:mm:ss')
assert open_time(1005, 1000, start_time) == arrow.get(
'2021-02-21 23:05:00', 'YYYY-MM-DD HH:mm:ss')
assert close_time(1005, 1000, start_time) == arrow.get(
'2021-02-23 17:00:00', 'YYYY-MM-DD HH:mm:ss')
# test French system for short controle points
assert close_time(10, 200, start_time) == arrow.get(
'2021-02-20 15:30:00', 'YYYY-MM-DD HH:mm:ss')
assert close_time(59, 200, start_time) == arrow.get(
'2021-02-20 17:57:00', 'YYYY-MM-DD HH:mm:ss')
assert close_time(60, 200, start_time) == arrow.get(
'2021-02-20 18:00:00', 'YYYY-MM-DD HH:mm:ss')
assert close_time(61, 200, start_time) == arrow.get(
'2021-02-20 18:04:00', 'YYYY-MM-DD HH:mm:ss')
def test_near_dists():
"""Tests control distances slightly over each possible total brevet distance to make sure calculator follows brevet rules and keeps open/close times
at the same predetermined value when the control distance exceeds the brevet distance. Should be the same values as the previous tests, which were
controls placed exactly at the brevet distances themselves.
"""
#200km brevet, 206km control. Starts at 14:30
assert nearly(acp.open_time(206, 200, "2017-10-20T14:30"),
"2017-10-20T20:23")
assert nearly(acp.close_time(206, 200, "2017-10-20T14:30"),
"2017-10-21T04:00")
#400km brevet, 407km control. Starts at 13:30
assert nearly(acp.open_time(407, 400, "2017-10-20T13:30"),
"2017-10-21T01:38")
assert nearly(acp.close_time(407, 400, "2017-10-20T13:30"),
"2017-10-21T16:30")
#600km brevet, 605km control. Starts at 17:34
assert nearly(acp.open_time(605, 600, "2017-10-20T17:34"),
"2017-10-21T12:22")
assert nearly(acp.close_time(605, 600, "2017-10-20T17:34"),
"2017-10-22T09:34")
#1000km brevet, 1005km control. Starts at 21:21
assert nearly(acp.open_time(1005, 1000, "2017-10-20T21:21"),
"2017-10-22T06:26")
assert nearly(acp.close_time(1005, 1000, "2017-10-20T21:21"),
"2017-10-24T00:21")
def test_at_dists():
#Tests control distances exactly at each possible brevet distance to make sure the calculator behaves according to rules.
#varying times are used.
#200km brevet, 200km control. Starts at 14:30
assert nearly(acp.open_time(200, 200, "2017-10-20T14:30"),
"2017-10-20T20:23")
assert nearly(acp.close_time(200, 200, "2017-10-20T14:30"),
"2017-10-21T04:00")
#400km brevet, 400km control. Starts at 13:30
assert nearly(acp.open_time(400, 400, "2017-10-20T13:30"),
"2017-10-21T01:38")
assert nearly(acp.close_time(400, 400, "2017-10-20T13:30"),
"2017-10-21T16:30")
#600km brevet, 600km control. Starts at 17:34
assert nearly(acp.open_time(600, 600, "2017-10-20T17:34"),
"2017-10-21T12:22")
assert nearly(acp.close_time(600, 600, "2017-10-20T17:34"),
"2017-10-22T09:34")
#1000km brevet, 1000km control. Starts at 21:21
assert nearly(acp.open_time(1000, 1000, "2017-10-20T21:21"),
"2017-10-22T06:26")
assert nearly(acp.close_time(1000, 1000, "2017-10-20T21:21"),
"2017-10-24T00:21")
def test_over_total():
assert open_time(215,200,'2021-01-01T00:00').format('YYYY-MM-DDTHH:mm') == '2021-01-01T05:53'
assert close_time(215, 200, '2021-01-01T00:00').format('YYYY-MM-DDTHH:mm') == '2021-01-01T13:30'
assert open_time(500, 400, '2021-01-01T00:00').format('YYYY-MM-DDTHH:mm') == '2021-01-01T12:08'
assert close_time(500, 400, '2021-01-01T00:00').format('YYYY-MM-DDTHH:mm') == '2021-01-02T03:00'
assert open_time(1050, 1000, '2021-01-01T00:00').format('YYYY-MM-DDTHH:mm') == '2021-01-02T09:05'
assert close_time(1050, 1000, '2021-01-01T00:00').format('YYYY-MM-DDTHH:mm') == '2021-01-04T03:00'
def _calc_times():
"""
Calculates open/close times from miles, using rules
described at https://rusa.org/octime_alg.html.
Expects one URL-encoded argument, the number of miles.
"""
app.logger.debug("Got a JSON request")
km = request.args.get('km', 999, type=float)
app.logger.debug("km={}".format(km))
app.logger.debug("request.args: {}".format(request.args))
# FIXME: These probably aren't the right open and close times
# and brevets may be longer than 200km
distance_ = request.args.get('data_dis', '', type=int)
date_ = request.args.get('data_date', '', type=str)
time_ = request.args.get('data_time', '', type=str)
time_format = date_ + 'T' + time_ + ':00.000000-08:00'
time_arrow = arrow.get(time_format)
open_time = acp_times.open_time(km, distance_, time_arrow)
close_time = acp_times.close_time(km, distance_, time_arrow)
assert (acp_times.open_time(2000, 200, time_arrow) == "Wrong")
assert (acp_times.open_time(
34, 200, time_arrow) == time_arrow.shift(hours=+1).isoformat())
assert (acp_times.close_time(
15, 600, time_arrow) == time_arrow.shift(hours=+1).isoformat())
result = {"open": open_time, "close": close_time}
return flask.jsonify(result=result)
def third_section_close():
start_time = arrow.now()
assert close_time(400, 600,
start_time) == start_time.shift(hours=26,
minutes=40).isoformat()
assert close_time(550, 600,
start_time) == start_time.shift(hours=36,
minutes=40).isoformat()
def second_section_close():
start_time = arrow.now()
assert close_time(200, 400,
start_time) == start_time.shift(hours=13,
minutes=20).isoformat()
assert close_time(350, 400,
start_time) == start_time.shift(hours=23,
minutes=20).isoformat()
def test_normal_close():
assert close_time(70, 200,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T04:40'
assert close_time(150, 200,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T10:00'
temp = close_time(500, 600, start).format('YYYY-MM-DDTHH:mm')
#print(temp)
assert temp == '2021-01-02T9:20'
def test_differentBrevets():
# Different brevets with same start + distance should not change the times
start = "2017-01-01T00:00"
distance = 50
assert a.open_time(distance, 90000,
start) == a.open_time(distance, 2, start)
assert a.close_time(distance, 3942,
start) == a.close_time(distance, 0.2, start)
def test_small_close():
assert close_time(0, 600,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T01:00'
t = close_time(10, 1000, start).format('YYYY-MM-DDTHH:mm')
#print(t)
assert t == '2021-01-01T01:30'
assert close_time(60, 400,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T04:00'
def test_big_close():
assert close_time(235, 200,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T13:30'
temp = close_time(609, 600, start).format('YYYY-MM-DDTHH:mm')
#print(temp)
assert temp == '2021-01-02T16:00'
assert close_time(1200, 1000,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-04T03:00'
def test_control_close():
#testing closetime of control by getting current time and shifting by known equation
closetime = arrow.utcnow()
assert close_time(100, 800, closetime) == closetime.shift(hours=100 /
15).isoformat()
assert close_time(500, 1000, closetime) == closetime.shift(hours=500 /
15).isoformat()
assert close_time(625, 1000, closetime) == closetime.shift(
hours=200 / 15 + 200 / 15 + 200 / 15 + 25 / 11.428).isoformat()
def test_high_1():
"""
Tests non-overkill values (where control distance = brevet distance)
"""
# Should have no effect on either set
assert a_same(open_time(200, 200, d_arrow), arrow.get('2000-01-01 05:53:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(open_time(400, 400, d_arrow), arrow.get('2000-01-01 12:08:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(close_time(1000, 1000, d_arrow), arrow.get('2000-01-04 03:00:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(close_time(600, 600, d_arrow), arrow.get('2000-01-02 16:00:00', 'YYYY-MM-DD HH:mm:ss'))
def test_high_3():
"""
Tests overkill values that exceed brevet distance by only one
"""
# Both should be identical to high_1 results
assert a_same(open_time(201, 200, d_arrow), arrow.get('2000-01-01 05:53:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(open_time(401, 400, d_arrow), arrow.get('2000-01-01 12:08:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(close_time(1001, 1000, d_arrow), arrow.get('2000-01-04 03:00:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(close_time(601, 600, d_arrow), arrow.get('2000-01-02 16:00:00', 'YYYY-MM-DD HH:mm:ss'))
def test_200():
assert str(acp_times.open_time(60, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T01:46"
assert str(acp_times.close_time(60, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T04:00"
assert str(acp_times.open_time(120, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T03:32"
assert str(acp_times.close_time(120, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T08:00"
assert str(acp_times.open_time(175, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T05:09"
assert str(acp_times.close_time(175, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T11:40"
assert str(acp_times.open_time(205, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T05:53"
assert str(acp_times.close_time(205, 200, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T13:30"
def test_300():
assert str(acp_times.open_time(70, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T02:04"
assert str(acp_times.close_time(70, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T04:40"
assert str(acp_times.open_time(125, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T03:41"
assert str(acp_times.close_time(125, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T08:20"
assert str(acp_times.open_time(265, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T07:55"
assert str(acp_times.close_time(265, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T17:40"
assert str(acp_times.open_time(340, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T09:00"
assert str(acp_times.close_time(340, 300, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T20:00"
def test_closing():
correct_close_time_1 = START_TIME.shift(hour=+1)
correct_close_time_2 = START_TIME.shift(hours=+16, minutes=+40)
output_close_1 = acp_times.close_time(0, 200, START_TIME)
output_close_2 = acp_times.close_time(250, 200, START_TIME)
assert correct_close_time_1 == output_close_1
assert correct_close_time_2 == output_close_2
def test_more_than_20_percent_longer():
test_open = acp_times.open_time(300, 200,
"2017-01-01 00:00") == acp_times.open_time(
200, 200, "2017-01-01 00:00")
test_close = acp_times.close_time(
300, 200,
"2017-01-01 00:00") == acp_times.close_time(200, 200,
"2017-01-01 00:00")
assert not test_open and not test_close
def test_ending_control():
"""
A control that is larger than the total brevet distance but smaller than
total distance + 10% should return the same open/close times as the total distance
"""
assert nearly(close_time(200, 200, "2018-01-01T23:00:00+00:00"),
close_time(210, 200, "2018-01-01T23:00:00+00:00"))
assert nearly(open_time(200, 200, "2018-01-01T23:00:00+00:00"),
open_time(210, 200, "2018-01-01T23:00:00+00:00"))
def test_high_2():
"""
Tests overkill values (control values that exceed
the brevet distance by 20% or less)
"""
# Both should be identical to high_1 results
assert a_same(open_time(240, 200, d_arrow), arrow.get('2000-01-01 05:53:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(open_time(480, 400, d_arrow), arrow.get('2000-01-01 12:08:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(close_time(1200, 1000, d_arrow), arrow.get('2000-01-04 03:00:00', 'YYYY-MM-DD HH:mm:ss'))
assert a_same(close_time(720, 600, d_arrow), arrow.get('2000-01-02 16:00:00', 'YYYY-MM-DD HH:mm:ss'))
def test_close_time2():
ans = bday.shift(hours=39, minutes=20)
ans = ans.isoformat()
print("ans: ", ans)
print("what calc is returning: ", acp_times.close_time(470, 1000, bday))
print("is same?",
acp_times.close_time(470, 1000, bday) == ans, "\nans: ", ans,
"\nwhat I'm returning: ", acp_times.close_time(470, 1000, bday))
assert acp_times.close_time(470, 1000, bday) == ans
def test_different_brevets():
test_open_300 = acp_times.open_time(
210, 300, "2017-01-01 00:00") == "2017-01-01T06:11:41.470588+00:00"
test_close_300 = acp_times.close_time(
210, 300, "2017-01-01 00:00") == "2017-01-01T14:00:00+00:00"
test_open_400 = acp_times.open_time(
310, 400, "2017-01-01 00:00") == "2017-01-01T09:19:11.470588+00:00"
test_close_400 = acp_times.close_time(
310, 400, "2017-01-01 00:00") == "2017-01-01T20:40:00+00:00"
assert test_open_300 and test_close_300 and test_open_400 and test_close_400
def test_400():
assert str(acp_times.open_time(90, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T02:39"
assert str(acp_times.close_time(90, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T06:00"
assert str(acp_times.open_time(175, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T05:09"
assert str(acp_times.close_time(175, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T11:40"
assert str(acp_times.open_time(240, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T07:08"
assert str(acp_times.close_time(240, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T16:00"
assert str(acp_times.open_time(390, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T11:49"
assert str(acp_times.close_time(390, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-02T02:00"
assert str(acp_times.open_time(460, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-01T12:08"
assert str(acp_times.close_time(460, 400, arrow.get('2021-01-01T00:00')).format('YYYY-MM-DDTHH:mm')) == "2021-01-02T03:00"
def _calc_times():
"""
Calculates open/close times from miles, using rules
described at https://rusa.org/octime_alg.html.
Expects one URL-encoded argument, the number of miles.
"""
app.logger.debug("Got a JSON request")
km = request.args.get("km", 999, type=float)
app.logger.debug("km={}".format(km))
app.logger.debug("request.args: {}".format(request.args))
# FIXME: These probably aren't the right open and close times
open_time = acp_times.open_time(km, 200, arrow.now().isoformat)
close_time = acp_times.close_time(km, 200, arrow.now().isoformat)
result = {"open": open_time, "close": close_time}
return jsonify(result=result)
