class FareSerializer(PbNestedSerializer):
found = jsonschema.BoolField()
total = CostSerializer()
links = jsonschema.MethodField(schema_type=LinkSchema(many=True),
attr='ticket_id',
display_none=True)
def get_links(self, obj):
if not hasattr(obj, 'ticket_id'):
return []
return [
create_internal_link(id=value, rel='tickets', _type='ticket')
for value in obj.ticket_id
]
# TODO check that retro compatibility is really useful
def to_value(self, value):
if value is None:
return {
'found': False,
'links': [],
'total': {
'currency': '',
'value': '0.0'
}
}
return super(FareSerializer, self).to_value(value)
class JourneysCommon(PbNestedSerializer):
error = ErrorSerializer(display_none=False)
feed_publishers = FeedPublisherSerializer(many=True, display_none=True)
links = MethodField(schema_type=LinkSchema(many=True), display_none=True)
def get_links(self, obj):
# note: some request args can be there several times,
# but when there is only one elt, flask does not want lists
response = []
for value in obj.links:
args = {}
for e in value.kwargs:
if len(e.values) > 1:
args[e.key] = [v for v in e.values]
else:
args[e.key] = e.values[0]
args["_type"] = value.type
args["templated"] = value.is_templated
args["description"] = value.description
args["rel"] = value.rel
response.append(
create_external_link('v1.{}'.format(value.ressource_name),
**args))
return response
class HeaderSerializer(PbNestedSerializer):
additional_informations = EnumListField(attr='additional_informations', display_none=True)
display_informations = pt.VJDisplayInformationSerializer(attr='pt_display_informations')
links = jsonschema.MethodField(schema_type=LinkSchema(many=True))
def get_links(self, obj):
return _get_links(obj)
class DateTimeTypeSerializer(PbNestedSerializer):
date_time = jsonschema.MethodField(schema_type=TimeOrDateTimeType,
display_none=True)
base_date_time = DateTimeField()
additional_informations = pt.AdditionalInformation(
attr='additional_informations', display_none=True)
links = jsonschema.MethodField(schema_type=LinkSchema(many=True),
display_none=True)
data_freshness = EnumField(attr="realtime_level", display_none=True)
occupancy = jsonschema.MethodField(schema_type=str, display_none=False)
def get_occupancy(self, obj):
return obj.occupancy if obj.HasField('occupancy') else None
def get_links(self, obj):
disruption_links = [
create_internal_link(_type="disruption", rel="disruptions", id=uri)
for uri in obj.impact_uris
]
properties_links = pt.make_properties_links(obj.properties)
return properties_links + disruption_links
def get_date_time(self, obj):
__date_time_null_value__ = 2**64 - 1
if obj.time == __date_time_null_value__:
return ""
if obj.HasField('date'):
return timestamp_to_str(obj.date + obj.time)
return datetime.utcfromtimestamp(obj.time).strftime('%H%M%S')
class CoveragesSerializer(serpy.DictSerializer):
regions = CoverageSerializer(many=True)
links = DescribedField(schema_type=LinkSchema(many=True))
context = MethodField(schema_type=ContextSerializer(), display_none=False)
def get_context(self, obj):
return ContextSerializer(obj, is_utc=True, display_none=False).data
class PTReferentialSerializerNoContext(serpy.Serializer):
pagination = PaginationSerializer(attr='pagination', display_none=True)
error = ErrorSerializer(display_none=False)
feed_publishers = FeedPublisherSerializer(many=True, display_none=True)
disruptions = pt.DisruptionSerializer(attr='impacts', many=True, display_none=True)
notes = DescribedField(schema_type=NoteSerializer(many=True))
links = DescribedField(schema_type=LinkSchema(many=True))
class PassageSerializer(PbNestedSerializer):
route = pt.RouteSerializer()
stop_point = pt.StopPointSerializer()
stop_date_time = pt.StopDateTimeSerializer()
display_informations = pt.VJDisplayInformationSerializer(attr='pt_display_informations')
links = jsonschema.MethodField(schema_type=LinkSchema(many=True))
def get_links(self, obj):
return _get_links(obj)
class RouteScheduleSerializer(PbNestedSerializer):
table = TableSerializer()
display_informations = pt.RouteDisplayInformationSerializer(attr='pt_display_informations')
geojson = MultiLineStringField(display_none=False)
additional_informations = EnumField(attr="response_status", display_none=True)
links = jsonschema.MethodField(schema_type=LinkSchema(many=True))
def get_links(self, obj):
return _get_links(obj)
class PtObjectsSerializer(serpy.Serializer):
error = ErrorSerializer(display_none=False)
feed_publishers = FeedPublisherSerializer(many=True, display_none=True)
disruptions = pt.DisruptionSerializer(attr='impacts', many=True, display_none=True)
pt_objects = pt.PtObjectSerializer(many=True, attr='places')
links = DescribedField(schema_type=LinkSchema(many=True))
context = MethodField(schema_type=ContextSerializer(), display_none=False)
def get_context(self, obj):
return ContextSerializer(obj, False, display_none=False).data
class StopScheduleSerializer(PbNestedSerializer):
stop_point = pt.StopPointSerializer()
route = pt.RouteSerializer()
additional_informations = EnumField(attr="response_status", display_none=True)
display_informations = pt.RouteDisplayInformationSerializer(attr='pt_display_informations')
date_times = DateTimeTypeSerializer(many=True, display_none=True)
links = jsonschema.MethodField(schema_type=LinkSchema(many=True))
def get_links(self, obj):
return _get_links(obj)
class SectionSerializer(PbNestedSerializer):
id = jsonschema.Field(schema_type=str, display_none=True)
duration = jsonschema.Field(schema_type=int, display_none=True,
description='Duration of the section (seconds)')
co2_emission = AmountSerializer(display_none=True)
transfer_type = EnumField()
departure_date_time = DateTimeField(attr='begin_date_time',
description='Departure date and time of the section')
arrival_date_time = DateTimeField(attr='end_date_time',
description='Arrival date and time of the section')
base_departure_date_time = DateTimeField(attr='base_begin_date_time',
description='Base-schedule departure date and time of the section')
base_arrival_date_time = DateTimeField(attr='base_end_date_time',
description='Base-schedule arrival date and time of the section')
to = jsonschema.MethodField(schema_type=PlaceSerializer(), attr='destination')
def get_to(self, obj):
if obj.HasField(str('type')):
enum = obj.DESCRIPTOR.fields_by_name['type'].enum_type.values_by_number
ret_value = enum[getattr(obj, 'type')].name
if ret_value == 'WAITING':
return None
return PlaceSerializer(obj.destination).data
_from = jsonschema.MethodField(schema_type=PlaceSerializer(), attr='origin', label='from')
def get__from(self, obj):
if obj.HasField(str('type')):
enum = obj.DESCRIPTOR.fields_by_name['type'].enum_type.values_by_number
ret_value = enum[getattr(obj, 'type')].name
if ret_value == 'WAITING':
return None
return PlaceSerializer(obj.origin).data
additional_informations = EnumListField(attr='additional_informations', pb_type=SectionAdditionalInformationType)
geojson = SectionGeoJsonField(display_none=False, description='GeoJSON of the shape of the section')
mode = NestedEnumField(attr='street_network.mode')
type = SectionTypeEnum()
display_informations = VJDisplayInformationSerializer(attr='pt_display_informations', display_none=False)
links = jsonschema.MethodField(display_none=True, schema_type=LinkSchema(many=True))
def get_links(self, obj):
response = []
if obj.HasField(str("uris")):
for type_, value in obj.uris.ListFields():
response.append({"type": type_.name, "id": value})
if obj.HasField(str('pt_display_informations')):
response.extend(base.make_notes(obj.pt_display_informations.notes))
return response
stop_date_times = StopDateTimeSerializer(many=True)
path = PathSerializer(attr="street_network.path_items", many=True, display_none=False)
class TicketSerializer(PbNestedSerializer):
id = jsonschema.Field(schema_type=str, display_none=True, description='Identifier of the object')
name = jsonschema.Field(schema_type=str, display_none=True, description='Name of the object')
comment = jsonschema.Field(schema_type=str)
found = jsonschema.BoolField()
cost = CostSerializer()
links = jsonschema.MethodField(schema_type=LinkSchema(many=True))
def get_links(self, obj):
if not hasattr(obj, 'section_id'):
return None
return [create_internal_link(id=value, rel='sections', _type='section') for value in obj.section_id]
class JourneysSerializer(PbNestedSerializer):
journeys = JourneySerializer(many=True)
error = ErrorSerializer(display_none=False, attr='error')
tickets = TicketSerializer(many=True, display_none=True)
disruptions = pt.DisruptionSerializer(attr='impacts',
many=True,
display_none=True)
feed_publishers = FeedPublisherSerializer(many=True, display_none=True)
links = MethodField(schema_type=LinkSchema(many=True), display_none=True)
context = MethodField(schema_type=ContextSerializer(), display_none=True)
notes = DescribedField(schema_type=NoteSerializer(many=True))
exceptions = DescribedField(schema_type=ExceptionSerializer(many=True))
def get_context(self, obj):
if obj.HasField(str('car_co2_emission')):
return ContextSerializer(obj, display_none=False).data
else:
return {
'car_direct_path': {
'co2_emission': {
'unit': '',
'value': 0.0
}
}
}
def get_links(self, obj):
# note: some request args can be there several times,
# but when there is only one elt, flask does not want lists
response = []
for value in obj.links:
args = {}
for e in value.kwargs:
if len(e.values) > 1:
args[e.key] = [v for v in e.values]
else:
args[e.key] = e.values[0]
response.append(
create_external_link('v1.{}'.format(value.ressource_name),
rel=value.rel,
_type=value.type,
templated=value.is_templated,
description=value.description,
**args))
return response
class JourneySerializer(PbNestedSerializer):
duration = jsonschema.Field(
schema_type=int,
display_none=True,
description='Duration of the journey (seconds)')
nb_transfers = jsonschema.Field(
schema_type=int,
display_none=True,
description='Number of transfers along the journey')
departure_date_time = DateTimeField(
description='Departure date and time of the journey')
arrival_date_time = DateTimeField(
description='Arrival date and time of the journey')
requested_date_time = DateTimeField(deprecated=True)
to = PlaceSerializer(deprecated=True, attr='destination')
_from = PlaceSerializer(deprecated=True, attr='origin', label='from')
type = jsonschema.Field(
schema_type=str,
display_none=True,
description=
'Used to qualify the journey (can be "best", "comfort", "non_pt_walk", ...',
)
status = jsonschema.Field(
schema_type=str,
attr="most_serious_disruption_effect",
display_none=True,
description='Status from the whole journey taking into account the most '
'disturbing information retrieved on every object used '
'(can be "NO_SERVICE", "SIGNIFICANT_DELAYS", ...',
)
tags = StringListField(display_none=True)
co2_emission = AmountSerializer(display_none=True)
durations = DurationsSerializer()
distances = DistancesSerializer()
fare = FareSerializer(display_none=True)
calendars = CalendarSerializer(many=True, display_none=False)
sections = SectionSerializer(many=True, display_none=False)
debug = jsonschema.MethodField(schema_type=JourneyDebugSerializer(),
display_none=False)
links = base.DescribedField(schema_type=LinkSchema(many=True))
def get_debug(self, obj):
if not hasattr(g, 'debug') or not g.debug:
return None
return JourneyDebugSerializer(obj, display_none=False).data
class SectionSerializer(PbNestedSerializer):
id = jsonschema.Field(schema_type=str, display_none=True)
duration = jsonschema.Field(
schema_type=int, display_none=True, description='Duration of the section (seconds)'
)
co2_emission = AmountSerializer(display_none=True)
transfer_type = EnumField(attr='transfer_type', pb_type=TransferType)
departure_date_time = DateTimeField(
attr='begin_date_time', description='Departure date and time of the section'
)
arrival_date_time = DateTimeField(attr='end_date_time', description='Arrival date and time of the section')
base_departure_date_time = DateTimeField(
attr='base_begin_date_time', description='Base-schedule departure date and time of the section'
)
base_arrival_date_time = DateTimeField(
attr='base_end_date_time', description='Base-schedule arrival date and time of the section'
)
data_freshness = EnumField(attr="realtime_level", pb_type=RTLevel, display_none=False)
to = jsonschema.MethodField(schema_type=PlaceSerializer(), attr='destination')
def get_to(self, obj):
if obj.HasField(str('type')):
enum = obj.DESCRIPTOR.fields_by_name['type'].enum_type.values_by_number
ret_value = enum[getattr(obj, 'type')].name
if ret_value == 'WAITING':
return None
return PlaceSerializer(obj.destination).data
_from = jsonschema.MethodField(schema_type=PlaceSerializer(), attr='origin', label='from')
def get__from(self, obj):
if obj.HasField(str('type')):
enum = obj.DESCRIPTOR.fields_by_name['type'].enum_type.values_by_number
ret_value = enum[getattr(obj, 'type')].name
if ret_value == 'WAITING':
return None
return PlaceSerializer(obj.origin).data
additional_informations = EnumListField(
attr='additional_informations', pb_type=SectionAdditionalInformationType
)
geojson = SectionGeoJsonField(display_none=False, description='GeoJSON of the shape of the section')
mode = NestedEnumField(attr='street_network.mode', pb_type=StreetNetworkMode)
type = SectionTypeEnum(attr='type', pb_type=SectionType)
display_informations = VJDisplayInformationSerializer(attr='pt_display_informations', display_none=False)
links = jsonschema.MethodField(display_none=True, schema_type=LinkSchema(many=True))
def get_links(self, obj):
response = []
if obj.HasField(str("uris")):
for type_, value in obj.uris.ListFields():
response.append({"type": type_.name, "id": value})
if obj.HasField(str('pt_display_informations')):
response.extend(base.make_notes(obj.pt_display_informations.notes))
if obj.HasField(str('ridesharing_information')):
response.extend(
[
{"type": "ridesharing_ad", "rel": l.key, "href": l.href, "internal": False}
for l in obj.ridesharing_information.links
]
)
return response
stop_date_times = StopDateTimeSerializer(many=True)
path = PathSerializer(attr="street_network.path_items", many=True, display_none=False)
ridesharing_informations = RidesharingInformationSerializer(
attr='ridesharing_information', display_none=False
)
ridesharing_journeys = jsonschema.MethodField(
schema_type=lambda: JourneySerializer(display_none=False, many=True)
)
def get_ridesharing_journeys(self, obj):
if not hasattr(obj, 'ridesharing_journeys') or not obj.ridesharing_journeys:
return None
return JourneySerializer(obj.ridesharing_journeys, display_none=False, many=True).data
cycle_lane_length = PbIntField(display_none=False)
elevations = ElevationSerializer(attr="street_network.elevations", many=True, display_none=False)
dynamic_speeds = DynamicSpeedSerializer(attr="street_network.dynamic_speeds", many=True, display_none=False)
vias = PathWaySerializer(many=True, display_none=False)
street_informations = StreetInformationSerializer(
attr="street_network.street_information", many=True, display_none=False
)