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_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_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_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 _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 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_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 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_small_open():
assert open_time(0, 600,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T00:00'
assert open_time(10, 1000,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T00:18'
assert open_time(60, 400,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T01:46'
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_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_open_brev_other():
"""
Open_time tests using brevet distances between 200km and 600km
"""
assert acp_times.open_time(
300, 400, '2017-01-01 00:00') == '2017-01-01T09:00:00+00:00'
assert acp_times.open_time(
555, 600, '2017-01-01 00:00') == '2017-01-01T17:18:00+00:00'
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_big_open():
assert open_time(235, 200,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T05:53'
temp = open_time(609, 600, start).format('YYYY-MM-DDTHH:mm')
#print(temp)
assert temp == '2021-01-01T18:48'
assert open_time(1200, 1000,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-02T09:05'
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_control_open():
#testing opentime of a control by grabbing current time and shifting by known equation
begintime = arrow.utcnow()
assert open_time(
100, 400, begintime) == begintime.shift(hours=(100 / 34)).isoformat()
assert open_time(
200, 600, begintime) == begintime.shift(hours=(200 / 34)).isoformat()
assert open_time(850, 1000, begintime) == begintime.shift(
hours=(200 / 34 + 200 / 32 + 200 / 30 + 250 / 28)).isoformat()
def test_opening():
correct_open_time_1 = START_TIME
correct_open_time_2 = START_TIME.shift(hours=+7, minutes=+27)
output_open_1 = acp_times.open_time(0, 200, START_TIME)
output_open_2 = acp_times.open_time(250, 200, START_TIME)
assert correct_open_time_1 == output_open_1
assert correct_open_time_2 == output_open_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_open_normal():
for dist in brevet_dists:
print("testing dist: ", dist)
assert open_time(100, dist, start_time) == arrow.get(
'2021-02-20 16:56:00', 'YYYY-MM-DD HH:mm:ss')
assert open_time(456, 1000, start_time) == arrow.get(
'2021-02-21 04:00:00', 'YYYY-MM-DD HH:mm:ss')
assert open_time(889.6, 1000, start_time) == arrow.get(
'2021-02-21 19:09:00', 'YYYY-MM-DD HH:mm:ss')
def test_normal_open():
assert open_time(70, 200,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T02:04'
assert open_time(150, 200,
start).format('YYYY-MM-DDTHH:mm') == '2021-01-01T04:25'
temp = open_time(500, 600, start).format('YYYY-MM-DDTHH:mm')
#print("temp = ", temp)
assert temp == '2021-01-01T15:28'
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_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_open_brev_1000():
"""
Open_time tests using brevet distance of 1000km
"""
assert acp_times.open_time(
600, 1000, '2017-01-01 00:00') == '2017-01-01T18:48:00+00:00'
assert acp_times.open_time(
725, 1000, '2017-01-01 00:00') == '2017-01-01T23:16:00+00:00'
assert acp_times.open_time(
200, 1000, '2017-01-01 00:00') == '2017-01-01T05:53:00+00:00'
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_open_nonzero_start():
"""
Testing non-zero start times for open_time
"""
assert acp_times.open_time(
0, 200, '2017-01-01 18:30') == '2017-01-01T18:30:00+00:00'
assert acp_times.open_time(
150, 200, '2017-01-01 02:00') == '2017-01-01T06:25:00+00:00'
assert acp_times.open_time(
725, 1000, '2017-01-01 20:00') == '2017-01-02T19:16: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_20perc_open():
#Test to see if we're within 20%, including false cases
begintime = arrow.utcnow()
assert open_time(240, 200,
begintime) == begintime.shift(hours=200 / 34).isoformat()
assert open_time(241, 200, begintime) == False
assert open_time(360, 300,
begintime) == begintime.shift(hours=200 / 34 +
100 / 32).isoformat()
assert open_time(361, 300, begintime) == False
def test_open_brev_200():
"""
Open_time tests using brevet distance of 200km
"""
assert acp_times.open_time(
0, 200, '2017-01-01 00:00') == '2017-01-01T00:00:00+00:00'
assert acp_times.open_time(
150, 200, '2017-01-01 00:00') == '2017-01-01T04:25:00+00:00'
assert acp_times.open_time(
200, 200, '2017-01-01 00:00') == '2017-01-01T05:53:00+00: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)