def graphical_isochrones(self, request, instance):
req = request_pb2.Request()
req._current_datetime = date_to_timestamp(request["_current_datetime"])
journey_req = req.isochrone.journeys_request
isochrone_common(self, request, instance, journey_req)
req.requested_api = type_pb2.graphical_isochrone
journey_req = req.isochrone.journeys_request
if request.get("max_duration"):
journey_req.max_duration = request["max_duration"]
else:
journey_req.max_duration = max(request["boundary_duration[]"],
key=int)
if request.get("boundary_duration[]"):
if len(request["boundary_duration[]"]) > 10:
abort(400,
message=
"you cannot provide more than 10 'boundary_duration[]'")
for duration in sorted(request["boundary_duration[]"],
key=int,
reverse=True):
if request[
"min_duration"] < duration < journey_req.max_duration:
req.isochrone.boundary_duration.append(duration)
req.isochrone.boundary_duration.insert(0, journey_req.max_duration)
req.isochrone.boundary_duration.append(request["min_duration"])
resp = instance.send_and_receive(req)
return resp
def place_uri(self, request, instance):
autocomplete = instance.get_autocomplete(request.get('_autocomplete'))
request_id = request.get('request_id', flask.request.id)
try:
return autocomplete.get_by_uri(
uri=request["uri"],
request_id=request_id,
instances=[instance],
current_datetime=request['_current_datetime'],
)
except UnknownObject as e:
# the autocomplete have not found anything
# We'll check if we can find another autocomplete system that explictly handle stop_points
# because for the moment mimir does not have stoppoints, but kraken do
for autocomplete_system in instance.stop_point_fallbacks():
if autocomplete_system == autocomplete:
continue
res = autocomplete_system.get_by_uri(
uri=request["uri"],
request_id=request_id,
instances=[instance],
current_datetime=request['_current_datetime'],
)
if res.get("places"):
return res
# we raise the initial exception
raise e
def isochrone_common(isochrone, request, instance, journey_req):
if request.get("origin"):
origin = journey_req.origin.add()
origin.place = request["origin"]
origin.access_duration = 0
journey_req.clockwise = True
if request.get("destination"):
destination = journey_req.destination.add()
destination.place = request["destination"]
destination.access_duration = 0
journey_req.clockwise = False
journey_req.datetimes.append(request["datetime"])
journey_req.wheelchair = request["wheelchair"] or False
journey_req.realtime_level = get_pb_data_freshness(request)
updated_common_journey_request_with_default(request, instance)
sn_params = journey_req.streetnetwork_params
sn_params.max_walking_duration_to_pt = request["max_walking_duration_to_pt"]
sn_params.max_bike_duration_to_pt = request["max_bike_duration_to_pt"]
sn_params.max_bss_duration_to_pt = request["max_bss_duration_to_pt"]
sn_params.max_car_duration_to_pt = request["max_car_duration_to_pt"]
sn_params.walking_speed = request["walking_speed"]
sn_params.bike_speed = request["bike_speed"]
sn_params.car_speed = request["car_speed"]
sn_params.bss_speed = request["bss_speed"]
journey_req.max_transfers = request["max_transfers"]
isochrone.origin_modes = request["origin_mode"]
isochrone.destination_modes = request["destination_mode"]
if "forbidden_uris[]" in request and request["forbidden_uris[]"]:
for forbidden_uri in request["forbidden_uris[]"]:
journey_req.forbidden_uris.append(forbidden_uri)
journey_req.streetnetwork_params.origin_mode = isochrone.origin_modes[0]
journey_req.streetnetwork_params.destination_mode = isochrone.destination_modes[0]
def __on_ptref(self, resource_name, requested_type, request, instance):
req = request_pb2.Request()
req.requested_api = type_pb2.PTREFERENTIAL
req.ptref.requested_type = requested_type
req.ptref.filter = request.get("filter", '')
req.ptref.depth = request["depth"]
req.ptref.start_page = request["start_page"]
req.ptref.count = request["count"]
req.ptref.disable_geojson = request["disable_geojson"]
req._current_datetime = date_to_timestamp(request["_current_datetime"])
if request["odt_level"]:
req.ptref.odt_level = pb_odt_level[request["odt_level"]]
if request["forbidden_uris[]"]:
for forbidden_uri in request["forbidden_uris[]"]:
req.ptref.forbidden_uri.append(forbidden_uri)
if request['since']:
req.ptref.since_datetime = request['since']
if request['until']:
req.ptref.until_datetime = request['until']
req.ptref.realtime_level = get_pb_data_freshness(request)
req.disable_disruption = request["disable_disruption"]
resp = instance.send_and_receive(req)
build_pagination(request, resp)
return resp
def traffic_reports(self, request, instance):
req = request_pb2.Request()
req.requested_api = type_pb2.traffic_reports
req.traffic_reports.depth = request['depth']
req.traffic_reports.filter = request['filter']
req.traffic_reports.count = request['count']
req.traffic_reports.start_page = request['start_page']
req._current_datetime = date_to_timestamp(request['_current_datetime'])
if request["forbidden_uris[]"]:
for forbidden_uri in request["forbidden_uris[]"]:
req.traffic_reports.forbidden_uris.append(forbidden_uri)
since = request.get('since')
if since:
req.traffic_reports.application_period_begin = since
until = request.get('until')
if request['until']:
req.traffic_reports.application_period_end = until
resp = instance.send_and_receive(req)
return resp
def places_nearby(self, request, instance):
req = request_pb2.Request()
req.requested_api = type_pb2.places_nearby
req.places_nearby.uri = request["uri"]
req.places_nearby.distance = request["distance"]
req.places_nearby.depth = request["depth"]
req.places_nearby.count = request["count"]
req.places_nearby.start_page = request["start_page"]
req._current_datetime = date_to_timestamp(request["_current_datetime"])
if request["type[]"]:
for type in request["type[]"]:
if type not in places_type:
abort(422, message="{} is not an acceptable type".format(type))
req.places_nearby.types.append(places_type[type])
req.places_nearby.filter = request["filter"]
req.disable_disruption = request["disable_disruption"] if request.get("disable_disruption") else False
resp = instance.send_and_receive(req)
build_pagination(request, resp)
return resp
def places(self, request, instance):
request["request_id"] = request.get('request_id', flask.request.id)
return instance.get_autocomplete(request.get('_autocomplete')).get(request, instances=[instance])
def place_uri(self, request, instance):
autocomplete = instance.get_autocomplete(request.get('_autocomplete'))
return autocomplete.get_by_uri(
uri=request["uri"],
instances=[instance],
current_datetime=request['_current_datetime'])
def places(self, request, instance):
return instance.get_autocomplete(request.get('_autocomplete')).get(
request, instances=[instance])
