datex2-xml2json 0.0.1__py3-none-any.whl

datex2_xml2json/transform/geojson_geometry_transformer.py

@@ -0,0 +1,159 @@
+import logging
+
+from .base import SituationRecordTransformer
+
+logger = logging.getLogger(__name__)
+
+
+class GeoJSONGeometryTransformer(SituationRecordTransformer):
+    def __init__(
+        self,
+        situation_record_json_pointer: str = 'payload/sitSituationPublication/situation/situationRecord',
+        geom_container_element_json_point: str | None = None,
+    ):
+        super().__init__(situation_record_json_pointer)
+        self.geom_container_element_json_point = geom_container_element_json_point
+
+    def _extract_coordinates_from_gmlLineString(self, gmlLineString: dict) -> list:
+        # Coordinate Order Confusion
+        # There is often some confusion regarding the correct ordering of coordinate values.
+        # While EPSG:4326 usually uses lat,lon ordering, and CRS84 (and GeoJSON) use lon/lat,
+        # older GIS software might use lon/lat also for EPSG:4326.
+        #
+        # Assuming lat,lon in GML's posList when "WGS84 EPSG 4326" is set as srsName,
+        # we swap coordinates for GeoJSON.
+        is_lat_lon_order = False
+        srsName = gmlLineString.get('srsName')
+        if srsName is not None:
+            if srsName not in {'WGS84 EPSG 4326', 'WGS84'}:
+                logger.warning('Unhandled srsName %s, might need reprojection/ latlon order handling.', srsName)
+            else:
+                logger.info('Detected srsName "%s". We assume  latlon gmlLineString coordinates ordering for these.', srsName)
+                is_lat_lon_order = True
+        posList = gmlLineString.get('posList', '')
+
+        zipped_coords = zip(*[iter(map(float, posList.split()))] * 2)
+        if is_lat_lon_order:
+            return [[lon, lat] for lat, lon in zipped_coords]
+        else:
+            return [[lon, lat] for lon, lat in zipped_coords]
+
+    def _extract_line_geom(self, linearExtended: dict) -> None | dict:
+        gmlLineString = linearExtended.get('gmlLineString')
+        if gmlLineString is None:
+            logger.warning('No linearExtended/gmlLineString')
+            return None
+        else:
+            geometry = {
+                'type': 'LineString',
+                'coordinates': self._extract_coordinates_from_gmlLineString(gmlLineString),
+            }
+            return geometry
+
+    def _extract_point_geom(self, pointCoordinates: dict | None) -> dict | None:
+        if pointCoordinates is None:
+            logger.warning('No pointCoordinates')
+            return None
+        else:
+            geometry = {
+                'type': 'Point',
+                'coordinates': [
+                    pointCoordinates.get('longitude'),
+                    pointCoordinates.get('latitude'),
+                ],
+            }
+            return geometry
+
+    def _extract_multi_line_string(self, locationReference: dict) -> dict:
+        locations = locationReference.get('locationContainedInGroup', {})
+
+        lineStrings = []
+        for location in locations:
+            location_type = location.get('type')
+            if not location_type == 'Linear':
+                logger.warning(
+                    'Unexpected location type %s, location is ignored',
+                    location.get('type'),
+                )
+                continue
+            coordinates = self._extract_coordinates_from_gmlLineString(location.get('gmlLineString', {}))
+            if coordinates:
+                lineStrings.append(coordinates)
+
+        return {'type': 'MultiLineString', 'coordinates': lineStrings}
+
+    def _extract_extendedLinear_geom(self, locationReference: dict) -> dict:
+        """
+        Some publications use a custom extension extendedLinear to provide linear geometries using a verbose
+        xml encoding.
+        We construct geojson geometries from these.
+        Note: as this extension is not defined in standard XML schemas, we need to handle some type and cardinality issues,
+        e.g. only a single intermediate point vs a list and lat/lon not beeing converted to floats during xml2json conversion.
+        """
+        linearByCoordinates = locationReference.get('extendedLinear', {}).get('linearByCoordinates', {})
+        coordinates = []
+        coordinates.append(
+            [
+                float(linearByCoordinates.get('start').get('longitude')),
+                float(linearByCoordinates.get('start').get('latitude')),
+            ]
+        )
+        intermediates = (
+            [linearByCoordinates.get('intermediate')]
+            if isinstance(linearByCoordinates.get('intermediate'), dict)
+            else linearByCoordinates.get('intermediate', [])
+        )
+        for intermediate in intermediates:
+            coordinates.append(
+                [
+                    float(intermediate.get('pointCoordinates').get('longitude')),
+                    float(intermediate.get('pointCoordinates').get('latitude')),
+                ]
+            )
+        coordinates.append(
+            [
+                float(linearByCoordinates.get('end').get('longitude')),
+                float(linearByCoordinates.get('end').get('latitude')),
+            ]
+        )
+
+        return {'type': 'LineString', 'coordinates': coordinates}
+
+    def process_situation_record(self, situation_record: dict) -> None:
+        locationReference = situation_record.get('locationReference')
+        if locationReference is None:
+            return
+
+        geom_container_element = (
+            locationReference.get(self.geom_container_element_json_point)
+            if self.geom_container_element_json_point is not None
+            else locationReference
+        )
+        if isinstance(geom_container_element, dict):
+            geoJsonGeometry = None
+            if 'gmlLineString' in geom_container_element:
+                geoJsonGeometry = self._extract_line_geom(geom_container_element)
+            elif 'pointByCoordinates' in geom_container_element:
+                geoJsonGeometry = self._extract_point_geom(geom_container_element.get('pointByCoordinates', {}).get('pointCoordinates'))
+            elif 'locationContainedInGroup' in geom_container_element:
+                geoJsonGeometry = self._extract_multi_line_string(geom_container_element)
+            elif 'extendedLinear' in geom_container_element:
+                geoJsonGeometry = self._extract_extendedLinear_geom(geom_container_element)
+            elif 'coordinatesForDisplay' in geom_container_element:
+                geoJsonGeometry = self._extract_point_geom(geom_container_element.get('coordinatesForDisplay'))
+
+            if geoJsonGeometry is not None:
+                geom_container_element['geoJsonGeometry'] = geoJsonGeometry
+
+
+class GeoJSONGeometryTransformer_DATEXII_3_7(GeoJSONGeometryTransformer):
+    def __init__(self):
+        super().__init__(
+            'payload/sitSituationPublication/situation/situationRecord',
+            'linearExtended',
+        )
+
+
+class GeoJSONGeometryTransformer_Simplified(GeoJSONGeometryTransformer):
+    def __init__(self):
+        super().__init__('payload/situation/situationRecord', None)

datex2_xml2json/transform/geoparquet_transformer.py

@@ -0,0 +1,160 @@
+import json
+import logging
+from datetime import datetime, timezone
+from tempfile import NamedTemporaryFile
+
+import geoparquet_io as gpio
+import pyarrow as pa
+
+logger = logging.getLogger(__name__)
+
+fields: list[tuple[str, pa.DataType]] = [
+    ('publicationTime', pa.timestamp('ms', tz='UTC')),
+    ('publicationCreator', pa.string()),
+    ('publicationIdentifier', pa.string()),
+    ('sourceIdentification', pa.string()),
+    ('situationId', pa.string()),
+    ('situationVersionTime', pa.timestamp('ms', tz='UTC')),
+    ('overallSeverity', pa.string()),
+    ('confidentiality', pa.string()),
+    ('informationStatus', pa.string()),
+    ('id', pa.string()),
+    ('version', pa.string()),
+    ('situationRecordCreationTime', pa.timestamp('ms', tz='UTC')),
+    ('situationRecordVersionTime', pa.timestamp('ms', tz='UTC')),
+    ('overallStartTime', pa.timestamp('ms', tz='UTC')),
+    ('overallEndTime', pa.timestamp('ms', tz='UTC')),
+    ('probabilityOfOccurrence', pa.string()),
+    ('type', pa.string()),
+    ('complianceOption', pa.string()),
+    ('validityStatus', pa.string()),
+    ('severity', pa.string()),
+    ('description', pa.string()),
+    ('roadworksType', pa.string()),
+    ('roadworksName', pa.string()),
+    ('heavyDutyTransportRestriction', pa.string()),
+    ('routeRecommendation', pa.string()),
+    ('applicableForTrafficDirection', pa.string()),
+    ('placesAtWhichApplicable', pa.string()),
+    ('cause', pa.string()),
+    ('numberOfLanesRestricted', pa.int8()),
+    ('numberOfOperationalLanes', pa.int8()),
+    ('residualRoadWidth', pa.float32()),
+    ('trafficConstrictionType', pa.string()),
+    ('situationRecordSubtype', pa.string()),
+    ('actionPlanIdentifier', pa.string()),
+    ('operatorActionStatus', pa.string()),
+    ('laneRestriction', pa.string()),  # TODO should be json
+    ('laneStatusCoded', pa.string()),
+    ('extendedLaneStatusCoded', pa.string()),
+    ('hardShoulderStatus', pa.string()),
+    ('residualHeight', pa.float64()),
+    ('maxVehicleWeight', pa.float64()),  # TODO should only be set if valid for allCariageWays
+    ('capacityRemaining', pa.int32()),
+    ('originalNumberOfLanes', pa.int32()),
+    ('numberOfObstructions', pa.int32()),
+    ('forVehiclesWithCharacteristicsOf', pa.string()),  # TODO should be json
+    ('validPeriods', pa.string()),  # TODO should be json
+    ('subjectTypeOfWorks', pa.string()),
+    ('applicableForTrafficType', pa.string()),
+    ('roadworksDurationClassification', pa.string()),
+    ('mobilityType', pa.string()),
+    ('roadworksLayout', pa.string()),
+    ('urlLinkAddress', pa.string()),
+    ('roadNumber', pa.string()),
+    ('roadName', pa.string()),
+    ('fromASBSegmentStation', pa.float64()),
+    ('fromASBSegmentFromNode', pa.string()),
+    ('fromASBSegmentTowardsNode', pa.string()),
+    ('toASBSegmentStation', pa.float64()),
+    ('toASBSegmentFromNode', pa.string()),
+    ('toASBSegmentTowardsNode', pa.string()),
+    ('lengthAffected', pa.float64()),
+    ('temporarySpeedLimit', pa.float32()),
+    ('geometry', pa.binary()),
+]
+
+MOSTLY_FLAT_SITUATION_RECORD_TARGET_SCHEMA = pa.schema(fields)
+
+
+class GeoparquetRenderer:
+    """
+    GeoparquetRenderer renders a GeoJSON file as a geoparquet file.
+    Only properties matchting the supplied target_schema (default ist OSTLY_FLAT_SITUATION_RECORD_TARGET_SCHEMA)
+    are exported.
+
+    Note: As a workaround for https://github.com/geoparquet/geoparquet-io/issues/1152, all timestamp properties
+      (according to the supplied target_schema) are converted to UTC strings. Note also, that this modification
+      happend in situ, no deep copy of the GeoJSON dict is created.
+    """
+
+    def __init__(self, target_schema=MOSTLY_FLAT_SITUATION_RECORD_TARGET_SCHEMA):
+        self.target_schema = target_schema
+
+    def _get_timestamp_fieldnames(self):
+        """
+        Return a list of all fieldnames of self.target_schema, whose type is pyarrow.TimestampType.
+        """
+        fieldnames = []
+        for index, field in enumerate(self.target_schema.types):
+            if isinstance(field, pa.TimestampType):
+                fieldnames.append(self.target_schema.names[index])
+        return fieldnames
+
+    def _set_timestamps_to_UTC(self, a_geojson_dict: dict):
+        """
+        Adds/subtracts optional timezone offset for
+        all timestamp properties to assure they are in UTC.
+        Note: timestamps without timezone adjustment are assumed to be
+        in UTC already.
+        This works around https://github.com/geoparquet/geoparquet-io/issues/1152
+        and might be obsolete once the it's fix is released in a geoparquet-io
+        version > 1.6.0
+        """
+        ts_fieldnames = self._get_timestamp_fieldnames()
+        for feature in a_geojson_dict['features']:
+            props = feature['properties']
+            for ts_property in ts_fieldnames:
+                if ts_property in props:
+                    dt = datetime.fromisoformat(props[ts_property])
+                    # Assume datetime was given in UTC if no timezone was specified
+                    if not dt.tzinfo:
+                        dt.replace(tzinfo=timezone.utc)
+                    props[ts_property] = dt.astimezone(timezone.utc).isoformat()
+
+    def _cast_fields_and_add_missing(self, table) -> None:
+        """
+        Replaces table's pyarrow table by a new one which
+        has expected columns in expected order and type.
+        """
+        arrays = []
+        patable = table._table
+        for field in self.target_schema:
+            try:
+                if field.name in patable.column_names:
+                    # Cast existing column
+                    arrays.append(patable[field.name].cast(field.type))
+                else:
+                    # Create null column of the correct type
+                    arrays.append(pa.nulls(len(patable), type=field.type))
+            except Exception:
+                logger.exception(f'Exception handling field {field}')
+
+        patable = pa.Table.from_arrays(arrays, schema=self.target_schema)
+        table._table = patable
+
+    def _as_table(self, a_geojson_dict: dict):
+        """
+        Writes a_geojson_dict to a tempory file which is then read
+        via geoparquet-io as pyarrow table.
+        """
+        with NamedTemporaryFile('w', delete_on_close=False) as f:
+            json.dump(a_geojson_dict, f, indent=2)
+            f.close()
+            return gpio.convert(f.name)
+
+    def render(self, filename, a_geojson_dict: dict) -> None:
+        self._set_timestamps_to_UTC(a_geojson_dict)
+        table = self._as_table(a_geojson_dict)
+        self._cast_fields_and_add_missing(table)
+        table.write(filename)

datex2_xml2json/transform/jsonata_transformer.py

@@ -0,0 +1,100 @@
+import jsonata
+
+from .base import AbstractTransformer
+
+# ruff: noqa: E501 (JSONata expressions are long...)
+
+# TODO: we asume arrays applicableForTrafficType, placesAtWhichApplicable, applicableForTrafficDirection have at most 1 element... We should check this
+mostly_flat_geojson_expression = """
+{
+  "type": "FeatureCollection",
+  "features": payload.situation[].situationRecord.{
+    "type": "Feature",
+    "properties": {
+        "publicationTime": %.%.publicationTime,
+        "publicationCreator": %.%.publicationCreator.nationalIdentifier,
+        "publicationIdentifier": %.%.payloadPublicationExtension.publicationIdentifier,
+        "sourceIdentification": source.sourceIdentification,
+        "situationId": %.id,
+        "situationVersionTime": %.situationVersionTime,
+        "confidentiality": %.headerInformation.confidentiality,
+        "informationStatus": %.headerInformation.informationStatus,
+        "overallSeverity": %.overallSeverity,
+        "id": id,
+        "version": version,
+        "situationRecordCreationTime": situationRecordCreationTime,
+        "situationRecordVersionTime": situationRecordVersionTime,
+        "probabilityOfOccurrence": probabilityOfOccurrence,
+        /* description is not declared in BEMaS */
+        "description": generalPublicComment[commentType.value="description"].comment.values[lang="de"].value,
+        "roadworksType": generalPublicComment[commentExtension.commentExtended.commentType2="roadworksType"].comment.values[lang="de"].value,
+        "roadworksName": generalPublicComment[commentExtension.commentExtended.commentType2="roadworksName"].comment.values[lang="de"].value,
+        "heavyDutyTransportRestriction": generalPublicComment[commentExtension.commentExtended.commentType2="heavyDutyTransportRestriction"].comment.values[lang="de"].value,
+        "routeRecommendation": generalPublicComment[commentExtension.commentExtended.commentType2="routeRecommendation"][0].comment.values[lang="de"].value,
+        "type": type,
+        "complianceOption": complianceOption,
+        "applicableForTrafficDirection":applicableForTrafficDirection[0],
+        /* TODO this is not set for BEMaS? */
+        "placesAtWhichApplicable":placesAtWhichApplicable[0],
+        "cause":cause.managedCause.objectReference.id,
+        "numberOfOperationalLanes": impact.numberOfOperationalLanes,
+        "numberOfLanesRestricted": impact.numberOfLanesRestricted,
+        "residualRoadWidth": impact.residualRoadWidth,
+        "trafficConstrictionType": impact.trafficConstrictionType,
+        "laneRestriction": impact.impactExtension.impactExtended.laneRestriction,
+        "laneStatusCoded": impact.impactExtension.impactExtended.laneStatusCoded,
+        "extendedLaneStatusCoded": situationRecordExtension.situationRecordExtended.extendedLaneStatusCoded,
+        "hardShoulderStatus": impact.impactExtension.impactExtended.hardShoulderStatus,
+        /* Note: other publication (i.e. TrafficMessages) use roadClosed and forVehiclesWithCharacteristicsOf */
+        "residualHeight": impact.impactExtension.impactExtended.residualHeight,
+        /* Note: other publication (i.e. TrafficMessages) use roadClosed and forVehiclesWithCharacteristicsOf */
+        "maxVehicleWeight": impact.impactExtension.impactExtended.laneRestriction[lane="allLanesCompleteCarriageway"].maxVehicleWeight,
+        "capacityRemaining": impact.capacityRemaining,
+        "originalNumberOfLanes": impact.originalNumberOfLanes,
+        /* is numberOfObstructions used?*/
+        "numberOfObstructions": impact.numberOfObstructions,
+        /* Note: some publications (i.e. BEMaS use impactExtended to communicate height and weight restrictions ) */
+        "forVehiclesWithCharacteristicsOf": forVehiclesWithCharacteristicsOf,
+        "validityStatus": validity.validityStatus,
+        "overallStartTime": validity.validityTimeSpecification.overallStartTime,
+        "overallEndTime": validity.validityTimeSpecification.overallEndTime,
+        "validPeriods": validity.validityTimeSpecification.validPeriod,
+        "subjectTypeOfWorks": subjects.subjectTypeOfWorks,
+        "severity": severity,
+        "applicableForTrafficType":applicableForTrafficType[0],
+        /* TODO Check which types are defined with maxoccurs=*, check which have value */
+        "situationRecordSubtype": obstructionType[0] ?? reroutingManagementType[0] ?? constructionWorkType ?? generalInstructionToRoadUsersType ?? infrastructureDamageType ?? accidentType[0] ?? abnormalTrafficType ?? speedManagementType ?? roadMaintenanceType[0] ?? animalPresenceType ?? environmentalObstructionType ?? generalNetworkManagementType ?? authorityOperationType ?? roadOrCarriagewayOrLaneManagementType ?? vehicleObstructionType ?? poorEnvironmentType,
+        "actionPlanIdentifier": actionPlanIdentifier,
+        "operatorActionStatus": operatorActionStatus,
+        "roadworksDurationClassification": roadworksDurationClassification,
+        "mobilityType": mobility.mobilityType,
+        "roadworksLayout": roadworksExtension.roadworksExtended.roadworksLayout,
+        "urlLinkAddress": urlLink[0].urlLinkAddress,
+        "roadNumber": locationReference.linearWithinLinearElement.linearElement.locLinearElement.roadNumber,
+        "roadName": locationReference.linearWithinLinearElement.linearElement.locLinearElement.roadName.values[0].value,
+        "fromASBSegmentFromNode": locationReference.linearWithinLinearElement.fromPoint.fromReferent.referentIdentifier,
+        "fromASBSegmentTowardsNode": locationReference.linearWithinLinearElement.fromPoint.towardsReferent.referentIdentifier,
+        "fromASBSegmentStation": locationReference.linearWithinLinearElement.fromPoint.distanceAlong,
+        "toASBSegmentFromNode": locationReference.linearWithinLinearElement.toPoint.fromReferent.referentIdentifier,
+        "toASBSegmentTowardsNode": locationReference.linearWithinLinearElement.toPoint.towardsReferent.referentIdentifier,
+        "toASBSegmentStation": locationReference.linearWithinLinearElement.toPoint.distanceAlong,
+        "lengthAffected": locationReference.supplementaryPositionalDescription.lengthAffected,
+        "temporarySpeedLimit": temporarySpeedLimit ?? operatorActionExtension.operatorActionExtended.mainSpeedLimit
+    },
+    "geometry": locationReference.geoJsonGeometry
+  } ?? []
+}
+"""
+
+
+class JsonataTransformer(AbstractTransformer):
+    def __init__(self, jsonata_expression=mostly_flat_geojson_expression):
+        self.jsonata_expr = jsonata.Jsonata(jsonata_expression)
+
+    def transform(self, a_dict: dict) -> dict:
+        result = self.jsonata_expr.evaluate(a_dict)
+
+        return self.post_transform(result)
+
+    def post_transform(self, a_dict: dict) -> dict:
+        return a_dict

datex2_xml2json/transform/roads_regio_transformer.py

@@ -0,0 +1,88 @@
+import logging
+
+from .base import SituationRecordTransformer
+
+logger = logging.getLogger(__name__)
+
+
+class RoadsRegioTransformer(SituationRecordTransformer):
+    def __init__(self, path: str = 'payload/sitSituationPublication/situation/situationRecord'):
+        super().__init__(path)
+
+    def _filter_empty_comments(self, situation_record: dict):
+        # Remove comments without value
+        if 'generalPublicComment' in situation_record:
+            comments = [
+                c
+                for c in situation_record['generalPublicComment']
+                if len(c['comment']['values']) > 0 and c['comment']['values'][0].get('value') is not None
+            ]
+            situation_record['generalPublicComment'] = comments
+
+    def _handle_originalNumberOfLanes(self, situation_record: dict):
+        # Removes originalNumberOfLanes from impact.
+
+        if 'impact' in situation_record:
+            # TODO originalNumberOfLanes probably should they be added elsewhere
+            situation_record['impact'].pop('originalNumberOfLanes', None)
+
+    def _handle_bemas_locations(self, situation_record: dict):
+        # Removes originalNumberOfLanes from impact.
+
+        # BEMaS
+        # Expectation:
+        # locationGroup/
+        #   linearExtended/gmlLineString/roadInformation
+        # .  linearWithinLinearElement[0]/linearElement
+        # Result:
+        #  linearElement/locLinearElementByLineString/
+        # .   gmlLineString/locGmlLineString
+        # .   roadNumber
+        # .   roadName
+        locationGroup = situation_record.get('locationReference', {}).get('locSingleRoadLinearLocation', {})
+
+        linearExtended = locationGroup.pop('linearExtended', None)
+        gmlLineString = None
+        if isinstance(linearExtended, dict) and 'gmlLineString' in linearExtended:
+            gmlLineString = linearExtended['gmlLineString']
+            # roadInformation is not part of gmlLineString any more, remove it
+            gmlLineString.pop('roadInformation', {})
+
+        linearWithinLinearElements = locationGroup.get('linearWithinLinearElement', [])
+
+        # Copy roadinformation and gmlLineString to locLinearElementByLineString
+        if len(linearWithinLinearElements) == 1:
+            linearElement = linearWithinLinearElements[0].get('linearElement', {})
+            locLinearElementByLineString = {'gmlLineString': {'locGmlLineString': gmlLineString}} if gmlLineString else {}
+            if 'roadNumber' in linearElement:
+                locLinearElementByLineString['roadNumber'] = linearElement.pop('roadNumber', None)
+            if 'roadName' in linearElement:
+                locLinearElementByLineString['roadName'] = linearElement.pop('roadName', None)
+
+            linearElement['locLinearElementByLineString'] = locLinearElementByLineString
+            linearWithinLinearElements[0]['linearElement'] = linearElement
+
+    def _fix_missing_linearElement(self, situation_record: dict):
+        # Removes originalNumberOfLanes from impact.
+
+        # BEMaS
+        # Expectation:
+        # locationGroup/
+        #   linearExtended/gmlLineString/roadInformation
+        # .  linearWithinLinearElement[0]/linearElement
+        # Result:
+        #  linearElement/locLinearElementByLineString/
+        # .   gmlLineString/locGmlLineString
+        # .   roadNumber
+        # .   roadName
+        locationGroup = situation_record.get('locationReference', {}).get('locSingleRoadLinearLocation', {})
+        linearWithinLinearElements = locationGroup.get('linearWithinLinearElement', [])
+        if len(linearWithinLinearElements) == 1:
+            if 'linearElement' not in linearWithinLinearElements[0]:
+                linearWithinLinearElements[0]['linearElement'] = {}
+
+    def process_situation_record(self, situation_record: dict) -> None:
+        # self._handle_bemas_locations(situation_record)
+        self._fix_missing_linearElement(situation_record)
+        self._handle_originalNumberOfLanes(situation_record)
+        self._filter_empty_comments(situation_record)

datex2_xml2json/transform/source_setter.py

@@ -0,0 +1,42 @@
+from datex2_xml2json.transform.base import SituationRecordTransformer
+
+
+def recurse(data, level=0):
+    if level > 2:
+        return
+    if type(data) is dict:
+        for key, value in data.items():
+            print(level * '  ', key)
+            recurse(value, level + 1)
+
+
+class SourceSetter(SituationRecordTransformer):
+    """
+    This Transformer sets situationRecord/source/sourceIdentification and the
+    custom extension payloadPublication/payloadPublicationExtension/publicationIdentifier,
+    if they are specified in the constructor call.
+    """
+
+    sourceIdentification: str | None = None
+    publicationIdentifier: str | None = None
+
+    def __init__(self, publicationIdentifier: str | None, sourceIdentification: str | None):
+        super().__init__('d2LogicalModel/payloadPublication/situation/situationRecord')
+        self.publicationIdentifier = publicationIdentifier
+        self.sourceIdentification = sourceIdentification
+
+    def process_situation_record(self, situation_record: dict) -> None:
+        situation_record['source'] = {'sourceIdentification': self.sourceIdentification}
+
+    def transform(self, publication: dict) -> dict:
+        recurse(publication)
+        if self.sourceIdentification is not None:
+            publication = super().transform(publication)
+
+        recurse(publication)
+        if self.publicationIdentifier is not None:
+            publication['d2LogicalModel']['payloadPublication'].setdefault('payloadPublicationExtension', {})['publicationIdentifier'] = (
+                self.publicationIdentifier
+            )
+
+        return publication