def get(self, region=None, lon=None, lat=None, uri=None):
self.region = i_manager.get_region(region, lon, lat)
timezone.set_request_timezone(self.region)
args = self.parsers["get"].parse_args()
if args['disable_geojson']:
g.disable_geojson = True
uris = []
if uri:
if uri[-1] == "/":
uri = uri[:-1]
uris = uri.split("/")
args["filter"] = self.get_filter(uris, args)
if args['since']:
args['since'] = date_to_timestamp(
self.convert_to_utc(args['since']))
if args['until']:
args['until'] = date_to_timestamp(
self.convert_to_utc(args['until']))
response = i_manager.dispatch(args,
"line_reports",
instance_name=self.region)
return response
def _update_passages(self, passages, route_point, template, next_realtime_passages):
if next_realtime_passages is None:
return
# filter passages with proxy method
pb_del_if(passages, lambda passage: self._filter_base_passage(passage, route_point))
# append the realtime passages
for rt_passage in next_realtime_passages:
new_passage = deepcopy(template)
new_passage.stop_date_time.arrival_date_time = date_to_timestamp(rt_passage.datetime)
new_passage.stop_date_time.departure_date_time = date_to_timestamp(rt_passage.datetime)
if rt_passage.is_real_time:
new_passage.stop_date_time.data_freshness = type_pb2.REALTIME
else:
new_passage.stop_date_time.data_freshness = type_pb2.BASE_SCHEDULE
# we also add the direction in the note
if rt_passage.direction:
new_passage.pt_display_informations.direction = rt_passage.direction
# we add physical mode from route
if len(route_point.pb_route.physical_modes) > 0:
new_passage.pt_display_informations.physical_mode = route_point.pb_route.physical_modes[0].name
passages.extend([new_passage])
def get(self, region=None, lon=None, lat=None, uri=None):
self.region = i_manager.get_region(region, lon, lat)
timezone.set_request_timezone(self.region)
args = self.parsers["get"].parse_args()
if args['disable_geojson']:
g.disable_geojson = True
args["filter"] = self.get_filter(split_uri(uri), args)
# change dt to utc
args['_current_datetime'] = self.convert_to_utc(
args['_current_datetime'])
if args['since']:
args['since'] = date_to_timestamp(
self.convert_to_utc(args['since']))
if args['until']:
args['until'] = date_to_timestamp(
self.convert_to_utc(args['until']))
response = i_manager.dispatch(args,
"line_reports",
instance_name=self.region)
return response
def get(self, region=None, lon=None, lat=None, uri=None, id=None):
args = self.parsers["get"].parse_args()
if args['disable_geojson']:
g.disable_geojson = True
# for retrocompatibility purpose
for forbid_id in args['__temporary_forbidden_id[]']:
args['forbidden_uris[]'].append(forbid_id)
if "odt_level" in args and args["odt_level"] != "all" and "lines" not in self.collection:
abort(404, message="bad request: odt_level filter can only be applied to lines")
if region is None and lat is None and lon is None:
if "external_code" in args and args["external_code"]:
type_ = collections_to_resource_type[self.collection]
for instance in i_manager.get_regions():
res = i_manager.instances[instance].has_external_code(type_, args["external_code"])
if res:
region = instance
id = res
break
if not region:
abort(404, message="Unable to find an object for the uri %s" % args["external_code"])
else:
abort(503, message="Not implemented yet")
self.region = i_manager.get_region(region, lon, lat)
# we store the region in the 'g' object, which is local to a request
set_request_timezone(self.region)
# change dt to utc
if args['since']:
args['_original_since'] = args['since']
args['since'] = date_to_timestamp(self.convert_to_utc(args['since']))
if args['until']:
args['_original_until'] = args['until']
args['until'] = date_to_timestamp(self.convert_to_utc(args['until']))
if not self.region:
return {"error": "No region"}, 404
uris = []
if uri:
if uri[-1] == "/":
uri = uri[:-1]
uris = uri.split("/")
if self.collection is None:
self.collection = uris[-1] if len(uris) % 2 != 0 else uris[-2]
args["filter"] = self.get_filter(uris, args)
if self.collection and id:
f = u'{o}.uri={v}'.format(o=collections_to_resource_type[self.collection], v=protect(id))
if args.get("filter"):
args["filter"] = '({}) and {}'.format(args["filter"], f)
else:
args["filter"] = f
response = i_manager.dispatch(args, self.collection, instance_name=self.region)
return response
def _update_passages(passages, route_point, template, next_realtime_passages):
if next_realtime_passages is None:
return
# filter passages with entries of the asked route_point
pb_del_if(passages,
lambda p: RoutePoint(p.route, p.stop_point) == route_point)
# append the realtime passages
for rt_passage in next_realtime_passages:
new_passage = deepcopy(template)
new_passage.stop_date_time.arrival_date_time = date_to_timestamp(
rt_passage.datetime)
new_passage.stop_date_time.departure_date_time = date_to_timestamp(
rt_passage.datetime)
new_passage.stop_date_time.data_freshness = type_pb2.REALTIME
# we also add the direction in the note
if rt_passage.direction:
new_passage.pt_display_informations.direction = rt_passage.direction
# we add physical mode from route
if len(route_point.pb_route.physical_modes) > 0:
new_passage.pt_display_informations.physical_mode = route_point.pb_route.physical_modes[
0].name
passages.extend([new_passage])
def get(self, region=None, lon=None, lat=None, uri=None):
self.region = i_manager.get_region(region, lon, lat)
timezone.set_request_timezone(self.region)
args = self.parsers["get"].parse_args()
if args['disable_geojson']:
g.disable_geojson = True
# for retrocompatibility purpose
for forbid_id in args['__temporary_forbidden_id[]']:
args['forbidden_uris[]'].append(forbid_id)
args["filter"] = self.get_filter(split_uri(uri), args)
since = args.get('since')
until = args.get('until')
if since and until and since > until:
abort(400, message='until must be >= since')
if since:
args['since'] = date_to_timestamp(self.convert_to_utc(since))
if until:
args['until'] = date_to_timestamp(self.convert_to_utc(until))
response = i_manager.dispatch(args,
"traffic_reports",
instance_name=self.region)
return response
def _process_data(self, data, stop_points_list):
"""
For each stop point within journeys response, the structure 'equipment_details' is updated if the corresponding code is present
:param data: equipments data received from the webservice
:param stop_points_list: list of stop_points from the protobuf response
"""
for st in stop_points_list:
for code in st.codes:
if SYTRAL_TYPE_PREFIX in code.type:
equipments_list = jmespath.search("equipments_details[?id=='{}']".format(code.value), data)
if equipments_list:
equipment = equipments_list[0]
# Fill PB
details = st.equipment_details.add()
details.id = equipment['id']
details.name = equipment['name']
details.embedded_type = type_pb2.EquipmentDetails.EquipmentType.Value(
'{}'.format(equipment['embedded_type'])
)
details.current_availability.status = type_pb2.CurrentAvailability.EquipmentStatus.Value(
'{}'.format(equipment['current_availaibity']['status'])
)
current_availaibity = equipment['current_availaibity']
for period in current_availaibity['periods']:
p = details.current_availability.periods.add()
p.begin = date_to_timestamp(parser.parse(period['begin']))
p.end = date_to_timestamp(parser.parse(period['end']))
details.current_availability.updated_at = current_availaibity['updated_at']
details.current_availability.cause.label = current_availaibity['cause']['label']
details.current_availability.effect.label = current_availaibity['effect']['label']
def get(self, uri=None, region=None, lon=None, lat=None):
args = self.parsers["get"].parse_args()
args["nb_stoptimes"] = args["count"]
args["interface_version"] = 1
if uri is None:
first_filter = args["filter"].lower().split("and")[0].strip()
parts = first_filter.lower().split("=")
if len(parts) != 2:
error = "Unable to parse filter {filter}"
return {"error": error.format(filter=args["filter"])}, 503
else:
self.region = i_manager.get_region(object_id=parts[1].strip())
else:
self.collection = 'schedules'
args["filter"] = self.get_filter(uri.split("/"), args)
self.region = i_manager.get_region(region, lon, lat)
timezone.set_request_timezone(self.region)
if not args["from_datetime"] and not args["until_datetime"]:
args['from_datetime'] = datetime.datetime.now()
if args["calendar"]: # if we have a calendar 00:00 is fine
args['from_datetime'] = args['from_datetime'].replace(hour=0,
minute=0)
else:
args['from_datetime'] = args['from_datetime'].replace(
hour=13, minute=37)
# we save the original datetime for debuging purpose
args['original_datetime'] = args['from_datetime']
if not args.get('calendar'):
#if a calendar is given all times will be given in local (because it might span over dst)
if args['from_datetime']:
new_datetime = self.convert_to_utc(args['from_datetime'])
args['from_datetime'] = utils.date_to_timestamp(new_datetime)
if args['until_datetime']:
new_datetime = self.convert_to_utc(args['until_datetime'])
args['until_datetime'] = utils.date_to_timestamp(new_datetime)
else:
args['from_datetime'] = utils.date_to_timestamp(
args['from_datetime'])
if not args["from_datetime"] and args["until_datetime"]\
and self.endpoint[:4] == "next":
self.endpoint = "previous" + self.endpoint[4:]
self._register_interpreted_parameters(args)
return i_manager.dispatch(args,
self.endpoint,
instance_name=self.region)
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 get(self, region=None, lon=None, lat=None, uri=None):
args = self.parsers['get'].parse_args()
self.region = i_manager.get_region(region, lon, lat)
args.update(self.parse_args(region, uri))
# We set default modes for fallback modes.
# The reason why we cannot put default values in parser_get.add_argument() is that, if we do so,
# fallback modes will always have a value, and traveler_type will never override fallback modes.
args['origin_mode'] = args.get('origin_mode') or ['walking']
args['destination_mode'] = args['destination_mode'] or ['walking']
if not (args['destination'] or args['origin']):
abort(400,
message="you should provide a 'from' or a 'to' argument")
if not args['max_duration']:
abort(400, message="you should provide a 'max_duration' argument")
if args['destination'] and args['origin']:
abort(400,
message="you cannot provide a 'from' and a 'to' argument")
if 'ridesharing' in args['origin_mode'] or 'ridesharing' in args[
'destination_mode']:
abort(400, message='ridesharing isn\'t available on heatmaps')
set_request_timezone(self.region)
original_datetime = args['original_datetime']
if original_datetime:
new_datetime = self.convert_to_utc(original_datetime)
args['datetime'] = date_to_timestamp(new_datetime)
response = i_manager.dispatch(args, "heat_maps", self.region)
return response
def get(self, region=None, uri=None):
args = self.parsers['get'].parse_args()
self.region = i_manager.get_region(region)
args.update(self.parse_args(region, uri))
if not (args['destination'] or args['origin']):
abort(400,
message="you should provide a 'from' or a 'to' argument")
if not args['max_duration']:
abort(400, message="you should provide a 'max_duration' argument")
if args['destination'] and args['origin']:
abort(400,
message="you cannot provide a 'from' and a 'to' argument")
set_request_timezone(self.region)
original_datetime = args['original_datetime']
if original_datetime:
new_datetime = self.convert_to_utc(original_datetime)
else:
new_datetime = args['_current_datetime']
args['datetime'] = date_to_timestamp(new_datetime)
response = i_manager.dispatch(args, "heat_maps", self.region)
return response
def get(self, region=None):
args = self.parsers['get'].parse_args()
if args.get('origin_mode') is None:
args['origin_mode'] = ['walking']
if args.get('destination_mode') is None:
args['destination_mode'] = ['walking']
self.region = i_manager.get_region(region)
if args['origin']:
args['origin'] = transform_id(args['origin'])
if args['destination']:
args['destination'] = transform_id(args['destination'])
if not (args['destination'] or args['origin']):
abort(400,
message="you should provide a 'from' or a 'to' argument")
if not args['max_duration']:
abort(400, message="you should provide a 'max_duration' argument")
if not args['datetime']:
args['datetime'] = args['_current_datetime']
set_request_timezone(self.region)
args['original_datetime'] = args['datetime']
original_datetime = args['original_datetime']
new_datetime = self.convert_to_utc(original_datetime)
args['datetime'] = date_to_timestamp(new_datetime)
response = i_manager.dispatch(args,
"graphical_isochrons",
instance_name=region)
return response
def _add_datetime(self, stop_schedule, passage, add_direction):
new_dt = stop_schedule.date_times.add()
# the midnight is calculated from passage.datetime and it keeps the same timezone as passage.datetime
midnight = passage.datetime.replace(hour=0,
minute=0,
second=0,
microsecond=0)
time = (passage.datetime - midnight).total_seconds()
new_dt.time = int(time)
new_dt.date = date_to_timestamp(midnight)
if passage.is_real_time:
new_dt.realtime_level = type_pb2.REALTIME
else:
new_dt.realtime_level = type_pb2.BASE_SCHEDULE
# we also add the direction in the note
if add_direction and passage.direction:
note = type_pb2.Note()
note.note = passage.direction
note_uri = hashlib.md5(
note.note.encode('utf-8', 'backslashreplace')).hexdigest()
note.uri = 'note:{md5}'.format(
md5=note_uri
) # the id is a md5 of the direction to factorize them
new_dt.properties.notes.extend([note])
def _update_stop_schedule(stop_schedule, next_realtime_passages):
"""
Update the stopschedule response with the new realtime passages
for the moment we remove all base schedule data and replace them with the realtime
If next_realtime_passages is None (and not if it's []) it means that the proxy failed,
so we use the base schedule
"""
if next_realtime_passages is None:
return
logging.getLogger(__name__).debug('next passages: : {}'
.format(["dt: {}".format(d.datetime) for d in next_realtime_passages]))
# we clean up the old schedule
del stop_schedule.date_times[:]
for passage in next_realtime_passages:
new_dt = stop_schedule.date_times.add()
midnight = datetime.datetime.combine(passage.datetime.date(), time=datetime.time(0))
pytz.utc.localize(midnight)
midnight = midnight.replace(tzinfo=pytz.UTC)
time = (passage.datetime - midnight).total_seconds()
new_dt.time = int(time)
new_dt.date = date_to_timestamp(midnight)
new_dt.realtime_level = type_pb2.REALTIME
# we also add the direction in the note
if passage.direction:
note = type_pb2.Note()
note.note = passage.direction
note_uri = hashlib.md5(note.note.encode('utf-8')).hexdigest()
note.uri = 'note:{md5}'.format(md5=note_uri) # the id is a md5 of the direction to factorize them
new_dt.properties.notes.extend([note])
def get_by_uri(self, uri, instance=None, current_datetime=None):
req = request_pb2.Request()
req.requested_api = type_pb2.place_uri
req.place_uri.uri = uri
if current_datetime:
req._current_datetime = date_to_timestamp(current_datetime)
return instance.send_and_receive(req)
def pt_objects(self, request, instance):
req = request_pb2.Request()
req.requested_api = type_pb2.pt_objects
req.pt_objects.q = request['q']
req.pt_objects.depth = request['depth']
req.pt_objects.disable_geojson = request['disable_geojson']
req.pt_objects.count = request['count']
req.pt_objects.search_type = request['search_type']
req._current_datetime = date_to_timestamp(request['_current_datetime'])
if request["type[]"]:
for type in request["type[]"]:
req.pt_objects.types.append(pt_object_type[type])
if request["admin_uri[]"]:
for admin_uri in request["admin_uri[]"]:
req.pt_objects.admin_uris.append(admin_uri)
req.disable_disruption = request["disable_disruption"]
req.pt_objects.filter = request['filter']
resp = instance.send_and_receive(req)
# The result contains places but not pt_objects,
# object place is transformed to pt_object afterwards.
if len(resp.places) == 0 and request['search_type'] == 0:
request["search_type"] = 1
return self.pt_objects(request, instance)
build_pagination(request, resp)
return resp
def fill_journeys(self, stat_request, call_result):
"""
Fill journeys and sections for each journey (datetimes are all UTC)
"""
journey_request = stat_request.journey_request
if hasattr(g, 'stat_interpreted_parameters'
) and g.stat_interpreted_parameters['original_datetime']:
tz = utils.get_timezone()
dt = g.stat_interpreted_parameters['original_datetime']
if dt.tzinfo is None:
dt = tz.normalize(tz.localize(dt))
journey_request.requested_date_time = utils.date_to_timestamp(
dt.astimezone(pytz.utc))
journey_request.clockwise = g.stat_interpreted_parameters[
'clockwise']
if 'journeys' in call_result[0] and call_result[0]['journeys']:
first_journey = call_result[0]['journeys'][0]
origin = find_origin_admin(first_journey)
if origin[0]:
journey_request.departure_admin = origin[0]
if origin[1]:
journey_request.departure_insee = origin[1]
if origin[2]:
journey_request.departure_admin_name = origin[2]
destination = find_destination_admin(first_journey)
if destination[0]:
journey_request.arrival_admin = destination[0]
if destination[1]:
journey_request.arrival_insee = destination[1]
if destination[2]:
journey_request.arrival_admin_name = destination[2]
for resp_journey in call_result[0]['journeys']:
stat_journey = stat_request.journeys.add()
self.fill_journey(stat_journey, resp_journey)
self.fill_sections(stat_journey, resp_journey)
def get(self, request, instance):
req = request_pb2.Request()
req.requested_api = type_pb2.places
req.places.q = request['q']
req.places.depth = request['depth']
req.places.count = request['count']
req.places.search_type = request['search_type']
req._current_datetime = date_to_timestamp(request['_current_datetime'])
if request["type[]"]:
for type in request["type[]"]:
if type not in pb_type:
abort(422,
message="{} is not an acceptable type".format(type))
req.places.types.append(pb_type[type])
if request["admin_uri[]"]:
for admin_uri in request["admin_uri[]"]:
req.places.admin_uris.append(admin_uri)
resp = instance.send_and_receive(req)
if len(resp.places) == 0 and request['search_type'] == 0:
req.places.search_type = 1
resp = instance.send_and_receive(req)
build_pagination(request, resp)
return resp
def get(self, region=None, lon=None, lat=None, uri=None):
args = self.parsers['get'].parse_args()
self.region = i_manager.get_region(region, lon, lat)
args.update(self.parse_args(region, uri))
if not (args['destination'] or args['origin']):
abort(400,
message="you should provide a 'from' or a 'to' argument")
if not args['max_duration'] and not args["boundary_duration[]"]:
abort(
400,
message=
"you should provide a 'boundary_duration[]' or a 'max_duration' argument"
)
if args['destination'] and args['origin']:
abort(400,
message="you cannot provide a 'from' and a 'to' argument")
if 'ridesharing' in args['origin_mode'] or 'ridesharing' in args[
'destination_mode']:
abort(400, message='ridesharing isn\'t available on isochrone')
set_request_timezone(self.region)
original_datetime = args['original_datetime']
if original_datetime:
new_datetime = self.convert_to_utc(original_datetime)
args['datetime'] = date_to_timestamp(new_datetime)
response = i_manager.dispatch(args, "graphical_isochrones",
self.region)
return response
def get(self, request, instances):
if len(instances) != 1:
raise InvalidArguments('kraken autocomplete works only for one (and only one) instance')
instance = instances[0]
req = request_pb2.Request()
req.requested_api = type_pb2.places
req.places.q = request['q']
req.places.depth = request['depth']
req.places.count = request['count']
req.places.search_type = request['search_type']
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.types.append(places_type[type])
if request["admin_uri[]"]:
for admin_uri in request["admin_uri[]"]:
req.places.admin_uris.append(admin_uri)
resp = instance.send_and_receive(req)
if len(resp.places) == 0 and request['search_type'] == 0:
req.places.search_type = 1
resp = instance.send_and_receive(req)
build_pagination(request, resp)
return resp
def __stop_times(self, request, api, departure_filter="", arrival_filter=""):
req = request_pb2.Request()
req.requested_api = api
req._current_datetime = utils.date_to_timestamp(request['_current_datetime'])
st = req.next_stop_times
st.disable_geojson = request["disable_geojson"]
st.departure_filter = departure_filter
st.arrival_filter = arrival_filter
if request["from_datetime"]:
st.from_datetime = request["from_datetime"]
if request["until_datetime"]:
st.until_datetime = request["until_datetime"]
st.duration = request["duration"]
st.depth = request["depth"]
if "nb_stoptimes" not in request:
st.nb_stoptimes = 0
else:
st.nb_stoptimes = request["nb_stoptimes"]
st.count = request.get("count", 10)
if "start_page" not in request:
st.start_page = 0
else:
st.start_page = request["start_page"]
if request["items_per_schedule"]:
st.items_per_schedule = request["items_per_schedule"]
if request["forbidden_uris[]"]:
for forbidden_uri in request["forbidden_uris[]"]:
st.forbidden_uri.append(forbidden_uri)
if request.get("calendar"):
st.calendar = request["calendar"]
st.realtime_level = utils.realtime_level_to_pbf(request['data_freshness'])
resp = self.instance.send_and_receive(req)
return resp
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 __to_timestamp(self, str):
try: # first we try with only a time
time = datetime.datetime.strptime(str, "T%H%M")
dt = datetime.datetime.combine(self._default_date, time.time())
except ValueError: # else we try with the date
dt = datetime.datetime.strptime(str, "%Y%m%dT%H%M%S")
return date_to_timestamp(dt)
def _fill_equipment_details(self, equipment_form_web_service,
equipment_details):
equipment_details.id = equipment_form_web_service['id']
equipment_details.name = equipment_form_web_service['name']
equipment_details.embedded_type = type_pb2.EquipmentDetails.EquipmentType.Value(
equipment_form_web_service['embedded_type'])
equipment_details.current_availability.status = type_pb2.CurrentAvailability.EquipmentStatus.Value(
equipment_form_web_service['current_availaibity']['status'])
current_availaibity = equipment_form_web_service['current_availaibity']
for period in current_availaibity['periods']:
p = equipment_details.current_availability.periods.add()
p.begin = date_to_timestamp(parser.parse(period['begin']))
p.end = date_to_timestamp(parser.parse(period['end']))
equipment_details.current_availability.updated_at = current_availaibity[
'updated_at']
equipment_details.current_availability.cause.label = current_availaibity[
'cause']['label']
equipment_details.current_availability.effect.label = current_availaibity[
'effect']['label']
def get_by_uri(self, uri, instances=None, current_datetime=None):
if len(instances) != 1:
raise InvalidArguments('kraken search by uri works only for one (and only one) instance')
instance = instances[0]
req = request_pb2.Request()
req.requested_api = type_pb2.place_uri
req.place_uri.uri = uri
if current_datetime:
req._current_datetime = date_to_timestamp(current_datetime)
return instance.send_and_receive(req)
def heat_maps(self, request, instance):
req = request_pb2.Request()
req._current_datetime = date_to_timestamp(request["_current_datetime"])
journey_req = req.heat_map.journeys_request
isochrone_common(self, request, instance, journey_req)
req.requested_api = type_pb2.heat_map
max_resolution = 1000
req.heat_map.resolution = min(request["resolution"], max_resolution)
req.heat_map.journeys_request.max_duration = request["max_duration"]
resp = instance.send_and_receive(req)
return resp
def _create_parameters(request, isochrone_center, request_type):
from jormungandr.pt_planners.pt_planner import (
JourneyParameters,
GraphicalIsochronesParameters,
StreetNetworkParameters,
)
if request_type == type_pb2.graphical_isochrone:
# Yes, graphical_isochrones needs that...
sn_params = StreetNetworkParameters(
origin_mode=request["origin_mode"][0],
destination_mode=request["destination_mode"][0],
walking_speed=request["walking_speed"],
bike_speed=request["bike_speed"],
car_speed=request["car_speed"],
bss_speed=request["bss_speed"],
car_no_park_speed=request["car_no_park_speed"],
)
journey_parameters = JourneyParameters(
max_duration=request.get('max_duration', None),
forbidden_uris=request['forbidden_uris[]'],
allowed_id=request['allowed_id[]'],
isochrone_center=isochrone_center,
sn_params=sn_params,
)
return GraphicalIsochronesParameters(
journeys_parameters=journey_parameters,
min_duration=request.get("min_duration"),
boundary_duration=request.get("boundary_duration[]"),
)
else:
return JourneyParameters(
max_duration=request['max_duration'],
max_transfers=request['max_transfers'],
wheelchair=request['wheelchair'] or False,
realtime_level=request['data_freshness'],
max_extra_second_pass=request['max_extra_second_pass'],
arrival_transfer_penalty=request['_arrival_transfer_penalty'],
walking_transfer_penalty=request['_walking_transfer_penalty'],
forbidden_uris=request['forbidden_uris[]'],
allowed_id=request['allowed_id[]'],
night_bus_filter_max_factor=request['_night_bus_filter_max_factor'],
night_bus_filter_base_factor=request['_night_bus_filter_base_factor'],
min_nb_journeys=request['min_nb_journeys'],
timeframe=request['timeframe_duration'],
depth=request['depth'],
isochrone_center=isochrone_center,
current_datetime=date_to_timestamp(request['_current_datetime']),
)
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)
resp = instance.send_and_receive(req)
return resp
def _update_stop_schedule(self, stop_schedule, next_realtime_passages):
"""
Update the stopschedule response with the new realtime passages
By default we remove all base schedule data and replace them with the realtime
Each proxy can define is own way to merge passages
If next_realtime_passages is None (and not if it's []) it means that the proxy failed,
so we use the base schedule
"""
if next_realtime_passages is None:
return
logging.getLogger(__name__).debug('next passages: : {}'.format(
["dt: {}".format(d.datetime) for d in next_realtime_passages]))
# we clean up the old schedule
pb_del_if(stop_schedule.date_times, self._filter_base_stop_schedule)
for passage in next_realtime_passages:
new_dt = stop_schedule.date_times.add()
# the midnight is calculated from passage.datetime and it keeps the same timezone as passage.datetime
midnight = passage.datetime.replace(hour=0,
minute=0,
second=0,
microsecond=0)
time = (passage.datetime - midnight).total_seconds()
new_dt.time = int(time)
new_dt.date = date_to_timestamp(midnight)
if passage.is_real_time:
new_dt.realtime_level = type_pb2.REALTIME
else:
new_dt.realtime_level = type_pb2.BASE_SCHEDULE
# we also add the direction in the note
if passage.direction:
note = type_pb2.Note()
note.note = passage.direction
note_uri = hashlib.md5(
note.note.encode('utf-8', 'backslashreplace')).hexdigest()
note.uri = 'note:{md5}'.format(
md5=note_uri
) # the id is a md5 of the direction to factorize them
new_dt.properties.notes.extend([note])
stop_schedule.date_times.sort(key=lambda dt: dt.date + dt.time)
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"]
resp = instance.send_and_receive(req)
build_pagination(request, resp)
return resp
