def from_lxml_element(cls, element: _Element) -> "FramedVehicleJourneyRef":
return cls(
data_frame_ref=element.findtext("x:DataFrameRef",
namespaces=_NSMAP),
dated_vehicle_journey_ref=element.findtext(
"x:DatedVehicleJourneyRef", namespaces=_NSMAP),
)
def from_lxml_element(cls, element: _Element) -> "ServiceDelivery":
producer_ref = element.findtext("x:ProducerRef", namespaces=_NSMAP)
response_timestamp = element.findtext("x:ResponseTimestamp",
namespaces=_NSMAP)
vmd_element = element.find("x:VehicleMonitoringDelivery",
namespaces=_NSMAP)
if vmd_element is None:
raise SiriParsingError("missing 'VehicleMonitoringDelivery'.")
vehicle_monitoring_delivery = VehicleMonitoringDelivery.from_lxml_element(
element=vmd_element)
return cls(
producer_ref=producer_ref,
response_timestamp=response_timestamp,
vehicle_monitoring_delivery=vehicle_monitoring_delivery,
)
def from_lxml_element(cls, element: _Element) -> "VehicleActivity":
mvj_element = element.find("x:MonitoredVehicleJourney",
namespaces=_NSMAP)
if mvj_element is None:
raise SiriParsingError("missing 'MonitoredVehicleJourney'.")
return cls(
recorded_at_time=element.findtext("x:RecordedAtTime",
namespaces=_NSMAP),
item_identifier=element.findtext("x:ItemIdentifier",
namespaces=_NSMAP),
valid_until_time=element.findtext("x:ValidUntilTime",
namespaces=_NSMAP),
monitored_vehicle_journey=MonitoredVehicleJourney.
from_lxml_element(mvj_element),
)
def _get_ocf_version(metadata: _Element) -> str:
"""
Extract OCF version from agent metadata XML
metadata -- metadata XML document
"""
version = metadata.findtext("./version")
return const.OCF_1_0 if version is None else version.strip()
def from_lxml_element(cls,
element: _Element) -> "VehicleMonitoringDelivery":
activites = [
VehicleActivity.from_lxml_element(element)
for element in element.findall("x:VehicleActivity",
namespaces=_NSMAP)
]
return cls(
request_message_ref=element.findtext("x:RequestMessageRef",
namespaces=_NSMAP),
response_timestamp=element.findtext("x:ResponseTimestamp",
namespaces=_NSMAP),
shortest_possible_cycle=element.findtext("x:ShortestPossibleCycle",
namespaces=_NSMAP),
valid_until=element.findtext("x:ValidUntil", namespaces=_NSMAP),
vehicle_activities=activites,
)
def parse_entry(context: Context, node: _Element):
entity_name = node.findtext("./Entity")
dob = node.findtext("./DateOfBirth")
schedule = node.findtext("./Schedule")
if schedule == "N/A":
schedule = ""
program = node.findtext("./Country")
item = node.findtext("./Item")
if entity_name is not None:
entity = context.make("LegalEntity")
entity.add("name", entity_name.split("/"))
else:
entity = context.make("Person")
given_name = node.findtext("./GivenName")
last_name = node.findtext("./LastName")
entity_name = h.make_name(given_name=given_name, last_name=last_name)
entity.add("name", entity_name)
entity.add("birthDate", dob)
country = program
if program is not None and "/" in program:
country, _ = program.split("/")
entity.add("country", country)
entity.id = context.make_slug(
schedule,
item,
entity.first("country"),
entity_name,
strict=False,
)
sanction = h.make_sanction(context, entity)
sanction.add("program", program)
sanction.add("reason", schedule)
sanction.add("authorityId", item)
names = node.findtext("./Aliases")
if names is not None:
for name in names.split(", "):
name = collapse_spaces(name)
entity.add("alias", name)
entity.add("topics", "sanction")
context.emit(entity, target=True)
context.emit(sanction)
def __init__(self, element: etree._Element, parent: 'Scene' = None):
self.parent = parent
self.n = element.get('n')
self.title = element.findtext('f:title', namespaces=config.namespaces)
self.level = element.tag[element.tag.index('}') + 1:]
self.subscenes = [
Scene(el, parent=self) for el in element.xpath('*[@n]')
]
self.first = element.get('first-verse')
self.last = element.get('last-verse')
if self.subscenes:
if self.first is None:
self.first = self.subscenes[0].first
if self.last is None:
self.last = self.subscenes[-1].last
if self.first:
self.first = int(self.first)
if self.last:
self.last = int(self.last)
def parse_entry(context: Context, entry: Element):
subject_type = entry.find("./subjectType")
schema = context.lookup_value(
"subject_type",
subject_type.get("code"),
dataset="eu_fsf",
)
if schema is None:
context.log.warning("Unknown subject type", type=subject_type)
return
entity = context.make(schema)
eu_ref = entry.get("euReferenceNumber")
if eu_ref is not None:
entity.id = context.make_slug(eu_ref, dataset="eu_fsf")
else:
entity.id = context.make_slug("logical", entry.get("logicalId"))
entity.add("notes", h.clean_note(entry.findtext("./remark")))
entity.add("topics", "sanction")
parse_sanctions(context, entity, entry)
for name in entry.findall("./nameAlias"):
is_weak = not as_bool(name.get("strong"))
h.apply_name(
entity,
full=name.get("wholeName"),
first_name=name.get("firstName"),
middle_name=name.get("middleName"),
last_name=name.get("lastName"),
is_weak=is_weak,
quiet=True,
)
entity.add("title", name.get("title"), quiet=True)
entity.add("position", name.get("function"), quiet=True)
entity.add("gender", name.get("gender"), quiet=True)
for node in entry.findall("./identification"):
type = node.get("identificationTypeCode")
schema = "Passport" if type == "passport" else "Identification"
passport = context.make(schema)
passport.id = context.make_id("ID", entity.id, node.get("logicalId"))
passport.add("holder", entity)
passport.add("authority", node.get("issuedBy"))
passport.add("type", node.get("identificationTypeDescription"))
passport.add("number", node.get("number"))
passport.add("number", node.get("latinNumber"))
passport.add("startDate", node.get("issueDate"))
passport.add("startDate", node.get("issueDate"))
passport.add("country", parse_country(node))
passport.add("country", node.get("countryDescription"))
for remark in node.findall("./remark"):
passport.add("summary", remark.text)
context.emit(passport)
for node in entry.findall("./address"):
address = parse_address(context, node)
h.apply_address(context, entity, address)
for child in node.getchildren():
if child.tag in ("regulationSummary"):
continue
elif child.tag == "remark":
entity.add("notes", child.text)
elif child.tag == "contactInfo":
prop = context.lookup_value(
"contact_info",
child.get("key"),
dataset="eu_fsf",
)
if prop is None:
context.log.warning("Unknown contact info", node=child)
else:
entity.add(prop, child.get("value"))
else:
context.log.warning("Unknown address component", node=child)
for birth in entry.findall("./birthdate"):
partialBirth = parse_parts(birth.get("year"), birth.get("month"),
birth.get("day"))
entity.add("birthDate", birth.get("birthdate"))
entity.add("birthDate", partialBirth)
address = parse_address(context, birth)
if address is not None:
entity.add("birthPlace", address.get("full"))
entity.add("country", address.get("country"))
for node in entry.findall("./citizenship"):
entity.add("nationality", parse_country(node), quiet=True)
entity.add("nationality", node.get("countryDescription"), quiet=True)
context.emit(entity, target=True)
def from_lxml_element(cls, element: _Element) -> "MonitoredVehicleJourney":
framed_vehicle_journey_ref = None
fvjr_element = element.find("x:FramedVehicleJourneyRef",
namespaces=_NSMAP)
if fvjr_element is not None:
framed_vehicle_journey_ref = FramedVehicleJourneyRef.from_lxml_element(
fvjr_element)
vehicle_location_element = element.find("x:VehicleLocation",
namespaces=_NSMAP)
if vehicle_location_element is None:
raise SiriParsingError("missing 'VehicleLocation'.")
return cls(
bearing=element.findtext("x:Bearing", namespaces=_NSMAP),
block_ref=element.findtext("x:BlockRef", namespaces=_NSMAP),
line_ref=element.findtext("x:LineRef", namespaces=_NSMAP),
direction_ref=element.findtext("x:DirectionRef",
namespaces=_NSMAP),
published_line_name=element.findtext("x:PublishedLineName",
namespaces=_NSMAP),
operator_ref=element.findtext("x:OperatorRef", namespaces=_NSMAP),
origin_ref=element.findtext("x:OriginRef", namespaces=_NSMAP),
origin_name=element.findtext("x:OriginName", namespaces=_NSMAP),
destination_ref=element.findtext("x:DestinationRef",
namespaces=_NSMAP),
destination_name=element.findtext("x:DestinationName",
namespaces=_NSMAP),
origin_aimed_departure_time=element.findtext(
"x:OriginAimedDepartureTime", namespaces=_NSMAP),
framed_vehicle_journey_ref=framed_vehicle_journey_ref,
vehicle_journey_ref=element.findtext("x:VehicleJourneyRef",
namespaces=_NSMAP),
vehicle_ref=element.findtext("x:VehicleRef", namespaces=_NSMAP),
vehicle_location=VehicleLocation.from_lxml_element(
vehicle_location_element),
)
def from_lxml_element(cls, element: _Element) -> "VehicleLocation":
return cls(
longitude=element.findtext("x:Longitude", namespaces=_NSMAP),
latitude=element.findtext("x:Latitude", namespaces=_NSMAP),
)
