parkapi-sources 0.2.0__py3-none-any.whl

parkapi_sources/converters/base_converter/push/normalized_xlsx_converter.py

@@ -0,0 +1,105 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC
+from datetime import datetime, timezone
+from typing import Any
+
+from openpyxl.cell import Cell
+from openpyxl.workbook.workbook import Workbook
+from validataclass.exceptions import ValidationError
+
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import StaticParkingSiteInput
+
+from .xlsx_converter import XlsxConverter
+
+
+class NormalizedXlsxConverter(XlsxConverter, ABC):
+    """
+    This converter acts as a base class for normalized XLSX files which always follow the same default layout. If you want to add another
+    source, you will have to subclass this converter and add `source_info` to it. If there are any minor changes, you can overwrite the
+    specific properties or methods in your child class.
+    """
+
+    # If there are more tables with our defined format, it would make sense to move header_row to XlsxConverter
+    header_row: dict[str, str] = {
+        'ID': 'uid',
+        'Name': 'name',
+        'Art der Anlage': 'type',
+        'Betreiber Name': 'operator_name',
+        'Längengrad': 'lat',
+        'Breitengrad': 'lon',
+        'Adresse mit PLZ und Stadt': 'address',
+        'Maximale Parkdauer': 'max_stay',
+        'Anzahl Stellplätze': 'capacity',
+        'Anzahl Carsharing-Parkplätze': 'capacity_carsharing',
+        'Anzahl Ladeplätze': 'capacity_charging',
+        'Anzahl Frauenparkplätze': 'capacity_woman',
+        'Anzahl Behindertenparkplätze': 'capacity_disabled',
+        'Anlage beleuchtet?': 'has_lighting',
+        'gebührenpflichtig?': 'has_fee',
+        'Existieren Live-Daten?': 'has_realtime_data',
+        'Gebühren-Informationen': 'fee_description',
+        'Webseite': 'public_url',
+        'Park&Ride': 'is_park_and_ride',
+        '24/7 geöffnet?': 'opening_hours_is_24_7',
+        'Öffnungszeiten Mo-Fr Beginn': 'opening_hours_weekday_begin',
+        'Öffnungszeiten Mo-Fr Ende': 'opening_hours_weekday_end',
+        'Öffnungszeiten Sa Beginn': 'opening_hours_saturday_begin',
+        'Öffnungszeiten Sa Ende': 'opening_hours_saturday_end',
+        'Öffnungszeiten So Beginn': 'opening_hours_sunday_begin',
+        'Öffnungszeiten So Ende': 'opening_hours_sunday_end',
+        'Weitere öffentliche Informationen': 'description',
+    }
+    # If there are more tables with our defined format, it would make sense to move type_mapping to XlsxConverter
+    type_mapping: dict[str, str] = {
+        'Parkplatz': 'OFF_STREET_PARKING_GROUND',
+        'Parkhaus': 'CAR_PARK',
+        'Tiefgarage': 'UNDERGROUND',
+        'Am Straßenrand': 'ON_STREET',
+    }
+
+    def handle_xlsx(self, workbook: Workbook) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        worksheet = workbook.active
+        mapping: dict[str, int] = self.get_mapping_by_header(next(worksheet.rows))
+
+        static_parking_site_errors: list[ImportParkingSiteException] = []
+        static_parking_site_inputs: list[StaticParkingSiteInput] = []
+
+        for row in worksheet.iter_rows(min_row=2):
+            # ignore empty lines as LibreOffice sometimes adds empty rows at the end of a file
+            if row[0].value is None:
+                continue
+            parking_site_dict = self.map_row_to_parking_site_dict(mapping, row)
+
+            try:
+                static_parking_site_inputs.append(self.static_parking_site_validator.validate(parking_site_dict))
+            except ValidationError as e:
+                static_parking_site_errors.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=parking_site_dict.get('uid'),
+                        message=f'invalid static parking site data {parking_site_dict}: {e.to_dict()}',
+                    )
+                )
+                continue
+
+        return static_parking_site_inputs, static_parking_site_errors
+
+    def map_row_to_parking_site_dict(self, mapping: dict[str, int], row: list[Cell]) -> dict[str, Any]:
+        parking_site_raw_dict: dict[str, str] = {}
+        for field in mapping.keys():
+            parking_site_raw_dict[field] = row[mapping[field]].value
+
+        parking_site_dict = {key: value for key, value in parking_site_raw_dict.items() if not key.startswith('opening_hours_')}
+        opening_hours_input = self.excel_opening_time_validator.validate(
+            {key: value for key, value in parking_site_raw_dict.items() if key.startswith('opening_hours_')}
+        )
+        parking_site_dict['opening_hours'] = opening_hours_input.get_osm_opening_hours()
+        parking_site_dict['type'] = self.type_mapping.get(parking_site_dict.get('type'))
+        parking_site_dict['static_data_updated_at'] = datetime.now(tz=timezone.utc).isoformat()
+
+        return parking_site_dict

parkapi_sources/converters/base_converter/push/push_converter.py

@@ -0,0 +1,12 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC
+
+from parkapi_sources.converters import BaseConverter
+
+
+class PushConverter(BaseConverter, ABC):
+    pass

parkapi_sources/converters/base_converter/push/xlsx_converter.py

@@ -0,0 +1,47 @@
+"""
+Copyright 2023 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC, abstractmethod
+
+from openpyxl.cell import Cell
+from openpyxl.workbook import Workbook
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.converters.base_converter.push import PushConverter
+from parkapi_sources.exceptions import ImportParkingSiteException, ImportSourceException
+from parkapi_sources.models import (
+    ExcelOpeningTimeInput,
+    ExcelStaticParkingSiteInput,
+    RealtimeParkingSiteInput,
+    SourceInfo,
+    StaticParkingSiteInput,
+)
+
+
+class XlsxConverter(PushConverter, ABC):
+    static_parking_site_validator = DataclassValidator(ExcelStaticParkingSiteInput)
+    excel_opening_time_validator = DataclassValidator(ExcelOpeningTimeInput)
+
+    header_row: dict[str, str] = {}
+    source_info: SourceInfo
+
+    @abstractmethod
+    def handle_xlsx(
+        self,
+        workbook: Workbook,
+    ) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        pass
+
+    def get_mapping_by_header(self, row: tuple[Cell]) -> dict[str, int]:
+        row_values = [cell.value for cell in row]
+        mapping: dict[str, int] = {}
+        for header_col, target_field in self.header_row.items():
+            if header_col not in row_values:
+                raise ImportSourceException(
+                    source_uid=self.source_info.uid,
+                    message=f'cannot find header key {header_col}',
+                )
+            mapping[target_field] = row_values.index(header_col)
+        return mapping

parkapi_sources/converters/base_converter/push/xml_converter.py

@@ -0,0 +1,21 @@
+"""
+Copyright 2023 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC, abstractmethod
+
+from lxml.etree import Element
+
+from parkapi_sources.converters.base_converter.push import PushConverter
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+from parkapi_sources.util import XMLHelper
+
+
+class XmlConverter(PushConverter, ABC):
+    xml_helper = XMLHelper()
+
+    @abstractmethod
+    def handle_xml(self, root: Element) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        pass

parkapi_sources/converters/bfrk_bw/__init__.py

@@ -0,0 +1,7 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from .bike_converter import BfrkBwOepnvBikePushConverter, BfrkBwSpnvBikePushConverter
+from .car_converter import BfrkBwOepnvCarPushConverter, BfrkBwSpnvCarPushConverter

parkapi_sources/converters/bfrk_bw/base_converter.py

@@ -0,0 +1,56 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC, abstractmethod
+
+from validataclass.exceptions import ValidationError
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.converters.base_converter.push import CsvConverter
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import StaticParkingSiteInput
+
+from .base_models import BfrkBaseRowInput
+
+
+class BfrkBasePushConverter(CsvConverter, ABC):
+
+    @property
+    @abstractmethod
+    def header_mapping(self) -> dict[str, str]:
+        pass
+
+    @property
+    @abstractmethod
+    def bfrk_row_validator(self) -> DataclassValidator:
+        pass
+
+    def handle_csv(self, data: list[list]) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        static_parking_site_inputs: list[StaticParkingSiteInput] = []
+        static_parking_site_errors: list[ImportParkingSiteException] = []
+
+        mapping: dict[str, int] = self.get_mapping_by_header(self.header_mapping, data[0])
+
+        # We start at row 2, as the first one is our header
+        for row in data[1:]:
+            input_dict: dict[str, str] = {}
+            for field in self.header_mapping.values():
+                input_dict[field] = row[mapping[field]]
+
+            try:
+                input_data: BfrkBaseRowInput = self.bfrk_row_validator.validate(input_dict)
+            except ValidationError as e:
+                static_parking_site_errors.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=input_dict.get('ID'),
+                        message=f'validation error for {input_dict}: {e.to_dict()}',
+                    ),
+                )
+                continue
+
+            static_parking_site_inputs.append(input_data.to_static_parking_site_input())
+
+        return static_parking_site_inputs, static_parking_site_errors

parkapi_sources/converters/bfrk_bw/base_models.py

@@ -0,0 +1,57 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import Optional
+
+from validataclass.dataclasses import validataclass
+from validataclass.validators import IntegerValidator, StringValidator
+
+from parkapi_sources.models import StaticParkingSiteInput
+from parkapi_sources.models.enums import ExternalIdentifierType
+from parkapi_sources.models.parking_site_inputs import ExternalIdentifierInput
+from parkapi_sources.validators import ExcelNoneable, GermanDecimalValidator
+
+
+@validataclass
+class BfrkBaseRowInput:
+    uid: str = StringValidator()
+    name: str = StringValidator()
+    lat: Decimal = GermanDecimalValidator()
+    lon: Decimal = GermanDecimalValidator()
+    capacity: int = IntegerValidator(allow_strings=True)
+    identifier_dhid: str = StringValidator()
+    identifier_osm: str = StringValidator()
+    photo_url: Optional[str] = ExcelNoneable(StringValidator())
+
+    def to_static_parking_site_input(self) -> StaticParkingSiteInput:
+        external_identifiers = []
+        if self.identifier_osm:
+            external_identifiers.append(
+                ExternalIdentifierInput(
+                    type=ExternalIdentifierType.OSM,
+                    value=self.identifier_osm,
+                ),
+            )
+        if self.identifier_dhid:
+            external_identifiers.append(
+                ExternalIdentifierInput(
+                    type=ExternalIdentifierType.DHID,
+                    value=self.identifier_dhid,
+                ),
+            )
+
+        return StaticParkingSiteInput(
+            uid=self.uid,
+            name=self.name,
+            lat=self.lat,
+            lon=self.lon,
+            address='',
+            capacity=self.capacity,
+            photo_url=self.photo_url,
+            static_data_updated_at=datetime.now(tz=timezone.utc),
+            external_identifiers=external_identifiers,
+        )

parkapi_sources/converters/bfrk_bw/bike_converter.py

@@ -0,0 +1,50 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC
+
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.models import SourceInfo
+
+from .base_converter import BfrkBasePushConverter
+from .bike_models import BfrkBikeRowInput
+
+
+class BfrkBwBikePushConverter(BfrkBasePushConverter, ABC):
+    bfrk_row_validator = DataclassValidator(BfrkBikeRowInput)
+
+    header_mapping: dict[str, str] = {
+        'ID': 'uid',
+        'HST_Name': 'name',
+        'Anlagentyp': 'type',
+        'Latitude': 'lat',
+        'Longitude': 'lon',
+        'Stellplatzanzahl': 'capacity',
+        'beleuchtet': 'has_lighting',
+        'kostenpflichtig': 'has_fee',
+        'ueberdacht': 'has_roof',
+        'HST_DHID': 'identifier_dhid',
+        'OSM_ID': 'identifier_osm',
+        'Anlage_Foto': 'photo_url',
+    }
+
+
+class BfrkBwOepnvBikePushConverter(BfrkBwBikePushConverter):
+    source_info = SourceInfo(
+        uid='bfrk_bw_oepnv_bike',
+        name='Barrierefreie Reisekette Baden-Württemberg: Fahrrad-Parkplätze an Bushaltestellen',
+        public_url='https://www.mobidata-bw.de/dataset/bfrk-barrierefreiheit-an-bw-haltestellen',
+        has_realtime_data=False,
+    )
+
+
+class BfrkBwSpnvBikePushConverter(BfrkBwBikePushConverter):
+    source_info = SourceInfo(
+        uid='bfrk_bw_spnv_bike',
+        name='Barrierefreie Reisekette Baden-Württemberg: Fahrrad-Parkplätze an Bahnhöfen',
+        public_url='https://www.mobidata-bw.de/dataset/bfrk-barrierefreiheit-an-bw-bahnhoefen',
+        has_realtime_data=False,
+    )

parkapi_sources/converters/bfrk_bw/bike_models.py

@@ -0,0 +1,56 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from enum import Enum
+from typing import Optional
+
+from validataclass.dataclasses import validataclass
+from validataclass.validators import EnumValidator
+
+from parkapi_sources.models.enums import ParkingSiteType, PurposeType
+from parkapi_sources.models.parking_site_inputs import StaticParkingSiteInput
+from parkapi_sources.validators import ExcelNoneable, MappedBooleanValidator
+
+from .base_models import BfrkBaseRowInput
+
+
+class GermanMappedBooleanValidator(MappedBooleanValidator):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, mapping={'ja': True, 'nein': False}, **kwargs)
+
+
+class BfrkBikeType(Enum):
+    WALL_LOOPS = 'Vorderradhalter'
+    STANDS = 'Anlehnbuegel'
+    LOCKERS = 'Fahrradboxen'
+    TWO_TIER = 'doppelstoeckig'
+    SHED = 'Fahrradsammelanlage'
+    BUILDING = 'Fahrradparkhaus'
+    AUTOMATIC_BUILDING = 'automatischesParksystem'
+    OTHER = 'Sonstiges'
+
+    def to_parking_site_type(self) -> ParkingSiteType:
+        if self == BfrkBikeType.AUTOMATIC_BUILDING:
+            return ParkingSiteType.BUILDING
+        return ParkingSiteType[self.name]
+
+
+@validataclass
+class BfrkBikeRowInput(BfrkBaseRowInput):
+    type: BfrkBikeType = EnumValidator(BfrkBikeType)
+    has_roof: Optional[bool] = ExcelNoneable(GermanMappedBooleanValidator())
+    has_fee: bool = GermanMappedBooleanValidator()
+    has_lighting: bool = GermanMappedBooleanValidator()
+
+    def to_static_parking_site_input(self) -> StaticParkingSiteInput:
+        static_parking_site_input = super().to_static_parking_site_input()
+
+        static_parking_site_input.type = self.type.to_parking_site_type()
+        static_parking_site_input.has_roof = self.has_roof
+        static_parking_site_input.has_fee = self.has_fee
+        static_parking_site_input.has_lighting = self.has_lighting
+        static_parking_site_input.purpose = PurposeType.BIKE
+
+        return static_parking_site_input

parkapi_sources/converters/bfrk_bw/car_converter.py

@@ -0,0 +1,49 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from abc import ABC
+
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.models import SourceInfo
+
+from .base_converter import BfrkBasePushConverter
+from .car_models import BfrkCarRowInput
+
+
+class BfrkBwCarPushConverter(BfrkBasePushConverter, ABC):
+    bfrk_row_validator = DataclassValidator(BfrkCarRowInput)
+
+    header_mapping: dict[str, str] = {
+        'ID': 'uid',
+        'HST_Name': 'name',
+        'Art': 'type',
+        'Latitude': 'lat',
+        'Longitude': 'lon',
+        'Stellplatzanzahl_insgesamt': 'capacity',
+        'Stellplatzanzahl_Behinderte': 'capacity_disabled',
+        'Nutzungsbedingungen': 'description',
+        'HST_DHID': 'identifier_dhid',
+        'OSM_ID': 'identifier_osm',
+        'Parkplatz_Foto': 'photo_url',
+    }
+
+
+class BfrkBwOepnvCarPushConverter(BfrkBwCarPushConverter):
+    source_info = SourceInfo(
+        uid='bfrk_bw_oepnv_car',
+        name='Barrierefreie Reisekette Baden-Württemberg: PKW-Parkplätze an Bushaltestellen',
+        public_url='https://www.mobidata-bw.de/dataset/bfrk-barrierefreiheit-an-bw-haltestellen',
+        has_realtime_data=False,
+    )
+
+
+class BfrkBwSpnvCarPushConverter(BfrkBwCarPushConverter):
+    source_info = SourceInfo(
+        uid='bfrk_bw_spnv_car',
+        name='Barrierefreie Reisekette Baden-Württemberg: PKW-Parkplätze an Bahnhöfen',
+        public_url='https://www.mobidata-bw.de/dataset/bfrk-barrierefreiheit-an-bw-bahnhoefen',
+        has_realtime_data=False,
+    )

parkapi_sources/converters/bfrk_bw/car_models.py

@@ -0,0 +1,46 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from enum import Enum
+
+from validataclass.dataclasses import validataclass
+from validataclass.validators import EnumValidator, IntegerValidator
+
+from parkapi_sources.models import StaticParkingSiteInput
+from parkapi_sources.models.enums import ParkingSiteType
+from parkapi_sources.validators import ReplacingStringValidator
+
+from .base_models import BfrkBaseRowInput
+
+
+class BfrkCarType(Enum):
+    PARK_AND_RIDE_PARKING_SITE = 'Park-and-Ride Parkplatz'
+    SHORT_TERM_PARKING_SITE = 'Kurzzeitparkplätze'
+    CAR_PARK = 'Parkhaus'
+    DISABLED_PARKING_SPACE = 'Behindertenparkplatz'
+
+    def to_parking_site_type(self) -> ParkingSiteType:
+        return {
+            self.PARK_AND_RIDE_PARKING_SITE: ParkingSiteType.OFF_STREET_PARKING_GROUND,
+            self.SHORT_TERM_PARKING_SITE: ParkingSiteType.OFF_STREET_PARKING_GROUND,
+            self.CAR_PARK: ParkingSiteType.CAR_PARK,
+            self.DISABLED_PARKING_SPACE: ParkingSiteType.OTHER,
+        }.get(self)
+
+
+@validataclass
+class BfrkCarRowInput(BfrkBaseRowInput):
+    type: BfrkCarType = EnumValidator(BfrkCarType)
+    capacity_disabled: int = IntegerValidator(allow_strings=True)
+    description: str = ReplacingStringValidator(mapping={'\x80': '€'})
+
+    def to_static_parking_site_input(self) -> StaticParkingSiteInput:
+        static_parking_site_input = super().to_static_parking_site_input()
+
+        static_parking_site_input.type = self.type.to_parking_site_type()
+        static_parking_site_input.capacity_disabled = self.capacity_disabled
+        static_parking_site_input.description = self.description
+
+        return static_parking_site_input

parkapi_sources/converters/freiburg/__init__.py

@@ -0,0 +1,6 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from .converter import FreiburgPullConverter

parkapi_sources/converters/freiburg/converter.py

@@ -0,0 +1,65 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+import requests
+from validataclass.exceptions import ValidationError
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.converters.base_converter.pull import PullConverter, StaticGeojsonDataMixin
+from parkapi_sources.exceptions import ImportParkingSiteException, ImportSourceException
+from parkapi_sources.models import RealtimeParkingSiteInput, SourceInfo, StaticParkingSiteInput
+
+from .models import FreiburgFeatureInput
+
+
+class FreiburgPullConverter(PullConverter, StaticGeojsonDataMixin):
+    freiburg_realtime_feature_validator = DataclassValidator(FreiburgFeatureInput)
+    source_info = SourceInfo(
+        uid='freiburg',
+        name='Stadt Freiburg',
+        public_url='https://www.freiburg.de/pb/,Lde/231355.html',
+        source_url='https://geoportal.freiburg.de/wfs/gdm_pls/gdm_plslive?request=getfeature&service=wfs&version=1.1.0&typename=pls'
+        '&outputformat=geojson&srsname=epsg:4326',
+        timezone='Europe/Berlin',
+        attribution_contributor='Stadt Freiburg',
+        attribution_license='dl-de/by-2-0',
+        has_realtime_data=True,
+    )
+
+    def get_static_parking_sites(self) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        return self._get_static_parking_site_inputs_and_exceptions(source_uid=self.source_info.uid)
+
+    def get_realtime_parking_sites(self) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        realtime_parking_site_inputs: list[RealtimeParkingSiteInput] = []
+        import_parking_site_exceptions: list[ImportParkingSiteException] = []
+
+        response = requests.get(self.source_info.source_url, timeout=30)
+        response_data = response.json()
+
+        try:
+            realtime_input = self.geojson_validator.validate(response_data)
+        except ValidationError as e:
+            raise ImportSourceException(
+                source_uid=self.source_info.uid,
+                message=f'Invalid Input at source {self.source_info.uid}: {e.to_dict()}, data: {response_data}',
+            ) from e
+
+        for update_dict in realtime_input.features:
+            try:
+                update_input = self.freiburg_realtime_feature_validator.validate(update_dict)
+            except ValidationError as e:
+                import_parking_site_exceptions.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=update_dict.get('properties').get('obs_parkid'),
+                        message=f'Invalid data at uid {update_dict.get("properties").get("obs_parkid")}: '
+                        f'{e.to_dict()}, data: {update_dict}',
+                    ),
+                )
+                continue
+
+            realtime_parking_site_inputs.append(update_input.to_realtime_parking_site_input())
+
+        return realtime_parking_site_inputs, import_parking_site_exceptions

parkapi_sources/converters/freiburg/models.py

@@ -0,0 +1,43 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from datetime import datetime, timezone
+from zoneinfo import ZoneInfo
+
+from validataclass.dataclasses import validataclass
+from validataclass.validators import DataclassValidator, IntegerValidator, StringValidator
+
+from parkapi_sources.models import RealtimeParkingSiteInput
+from parkapi_sources.models.enums import OpeningStatus
+from parkapi_sources.validators import SpacedDateTimeValidator
+
+
+@validataclass
+class FreiburgPropertiesInput:
+    obs_id: int = IntegerValidator(allow_strings=True)
+    obs_parkid: int = IntegerValidator(allow_strings=True)
+    obs_state: int = IntegerValidator(allow_strings=True)
+    obs_max: int = IntegerValidator(allow_strings=True)
+    obs_free: int = IntegerValidator(allow_strings=True)
+    obs_ts: datetime = SpacedDateTimeValidator(
+        local_timezone=ZoneInfo('America/Los_Angeles'),
+        target_timezone=timezone.utc,
+    )
+    park_name: str = StringValidator()
+    park_id: str = StringValidator()
+
+
+@validataclass
+class FreiburgFeatureInput:
+    properties: FreiburgPropertiesInput = DataclassValidator(FreiburgPropertiesInput)
+
+    def to_realtime_parking_site_input(self) -> RealtimeParkingSiteInput:
+        return RealtimeParkingSiteInput(
+            uid=str(self.properties.obs_parkid),
+            realtime_capacity=self.properties.obs_max,
+            realtime_free_capacity=self.properties.obs_free,
+            realtime_data_updated_at=self.properties.obs_ts,
+            realtime_opening_status=OpeningStatus.OPEN if self.properties.obs_state else OpeningStatus.CLOSED,
+        )

parkapi_sources/converters/heidelberg/__init__.py

@@ -0,0 +1,6 @@
+"""
+Copyright 2024 binary butterfly GmbH
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE.txt.
+"""
+
+from .converter import HeidelbergPullConverter