parkapi-sources 0.2.0__py3-none-any.whl

parkapi_sources/__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 .parkapi_sources import ParkAPISources

parkapi_sources/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

parkapi_sources/converters/__init__.py

@@ -0,0 +1,19 @@
+"""
+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 .bahn_v2 import BahnV2PullConverter
+from .base_converter import BaseConverter
+from .bfrk_bw import BfrkBwOepnvBikePushConverter, BfrkBwOepnvCarPushConverter, BfrkBwSpnvBikePushConverter, BfrkBwSpnvCarPushConverter
+from .freiburg import FreiburgPullConverter
+from .heidelberg import HeidelbergPullConverter
+from .karlsruhe import KarlsruhePullConverter
+from .mannheim import MannheimPullConverter
+from .neckarsulm import NeckarsulmPushConverter
+from .pbw import PbwPullConverter
+from .pforzheim import PforzheimPushConverter
+from .reutlingen import ReutlingenPushConverter
+from .stuttgart import StuttgartPushConverter
+from .ulm import UlmPullConverter
+from .vrs_p_r import VrsParkAndRidePushConverter

parkapi_sources/converters/bahn_v2/__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 BahnV2PullConverter

parkapi_sources/converters/bahn_v2/converter.py

@@ -0,0 +1,72 @@
+"""
+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
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import RealtimeParkingSiteInput, SourceInfo, StaticParkingSiteInput
+
+from .mapper import BahnMapper
+from .validators import BahnParkingSiteInput
+
+
+class BahnV2PullConverter(PullConverter):
+    _base_url = 'https://apis.deutschebahn.com/db-api-marketplace/apis/parking-information/db-bahnpark/v2'
+    required_config_keys = ['PARK_API_BAHN_API_CLIENT_ID', 'PARK_API_BAHN_API_CLIENT_SECRET']
+
+    mapper = BahnMapper()
+    bahn_parking_site_validator = DataclassValidator(BahnParkingSiteInput)
+
+    source_info = SourceInfo(
+        uid='bahn_v2',
+        name='Deutsche Bahn Parkplätze',
+        public_url='https://www.dbbahnpark.de',
+        has_realtime_data=False,  # ATM it's impossible to get realtime data due rate limit restrictions
+    )
+
+    def get_static_parking_sites(self) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        static_parking_site_inputs: list = []
+        static_parking_site_errors: list[ImportParkingSiteException] = []
+
+        parking_site_dicts = self.get_data()
+
+        for parking_site_dict in parking_site_dicts.get('_embedded', []):
+            try:
+                parking_site_input: BahnParkingSiteInput = self.bahn_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('id'),
+                        message=f'validation error for data {parking_site_dict}: {e.to_dict()}',
+                    ),
+                )
+                continue
+
+            static_parking_site_inputs.append(
+                self.mapper.map_static_parking_site(parking_site_input),
+            )
+        return static_parking_site_inputs, static_parking_site_errors
+
+    def get_realtime_parking_sites(self) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        return [], []  # ATM it's impossible to get realtime data due rate limit restrictions
+
+    def get_data(self) -> dict:
+        headers: dict[str, str] = {
+            'DB-Client-Id': self.config_helper.get('PARK_API_BAHN_API_CLIENT_ID'),
+            'DB-Api-Key': self.config_helper.get('PARK_API_BAHN_API_CLIENT_SECRET'),
+            'Accept': 'application/vnd.parkinginformation.db-bahnpark.v1+json',
+            'accept': 'application/json',
+        }
+
+        response = requests.get(
+            f'{self.config_helper.get("PARK_API_BAHN_URL", self._base_url)}/parking-facilities',
+            headers=headers,
+            timeout=60,
+        )
+        return response.json()

parkapi_sources/converters/bahn_v2/mapper.py

@@ -0,0 +1,38 @@
+"""
+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 parkapi_sources.models import StaticParkingSiteInput
+
+from .validators import BahnParkingSiteCapacityType, BahnParkingSiteInput, NameContext
+
+
+class BahnMapper:
+    @staticmethod
+    def map_static_parking_site(bahn_input: BahnParkingSiteInput) -> StaticParkingSiteInput:
+        static_parking_site_input = StaticParkingSiteInput(
+            uid=str(bahn_input.id),
+            name=next(iter(name_input.name for name_input in bahn_input.name if name_input.context == NameContext.NAME)),
+            lat=bahn_input.address.location.latitude,
+            lon=bahn_input.address.location.longitude,
+            operator_name=bahn_input.operator.name,
+            address=f'{bahn_input.address.streetAndNumber}, {bahn_input.address.zip} {bahn_input.address.city}',
+            capacity=bahn_input.capacity,
+            type=bahn_input.type.name.to_parking_site_type_input(),
+            has_realtime_data=False,  # TODO: change this as soon as Bahn offers proper rate limits
+            static_data_updated_at=datetime.now(tz=timezone.utc),
+            public_url=bahn_input.url,
+        )
+        if bahn_input.access.openingHours.is24h:
+            static_parking_site_input.opening_hours = '24/7'
+
+        for capacity_data in bahn_input.capacity:
+            if capacity_data.type == BahnParkingSiteCapacityType.PARKING:
+                static_parking_site_input.capacity = int(round(capacity_data.total))
+            elif capacity_data.type == BahnParkingSiteCapacityType.HANDICAPPED_PARKING:
+                static_parking_site_input.capacity_disabled = int(round(capacity_data.total))
+
+        return static_parking_site_input

parkapi_sources/converters/bahn_v2/validators.py

@@ -0,0 +1,131 @@
+"""
+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 decimal import Decimal
+from enum import Enum
+from typing import Optional
+
+from validataclass.dataclasses import Default, validataclass
+from validataclass.validators import (
+    BooleanValidator,
+    DataclassValidator,
+    DecimalValidator,
+    EnumValidator,
+    IntegerValidator,
+    ListValidator,
+    Noneable,
+    NumericValidator,
+    StringValidator,
+    UrlValidator,
+)
+
+from parkapi_sources.models.enums import ParkingSiteType
+
+
+class NameContext(Enum):
+    NAME = 'NAME'
+    DISPLAY = 'DISPLAY'
+    LABEL = 'LABEL'
+    SLOGAN = 'SLOGAN'
+
+
+class BahnParkingSiteCapacityType(Enum):
+    PARKING = 'PARKING'
+    HANDICAPPED_PARKING = 'HANDICAPPED_PARKING'
+
+
+class BahnParkingSiteType(Enum):
+    PARKPLATZ = 'Parkplatz'
+    TIEFGARAGE = 'Tiefgarage'
+    PARKHAUS = 'Parkhaus'
+    STRASSE = 'Straße'
+    PARKDECK = 'Parkdeck'
+
+    def to_parking_site_type_input(self) -> ParkingSiteType:
+        # TODO: find out more details about this enumeration for a proper mapping
+        return {
+            self.PARKPLATZ: ParkingSiteType.ON_STREET,
+            self.PARKHAUS: ParkingSiteType.CAR_PARK,
+            self.TIEFGARAGE: ParkingSiteType.UNDERGROUND,
+            self.STRASSE: ParkingSiteType.ON_STREET,
+            self.PARKDECK: ParkingSiteType.CAR_PARK,
+        }.get(self, ParkingSiteType.OTHER)
+
+
+@validataclass
+class BahnNameInput:
+    name: str = StringValidator()
+    context: NameContext = EnumValidator(NameContext)
+
+
+@validataclass
+class BahnTypeInput:
+    name: BahnParkingSiteType = EnumValidator(BahnParkingSiteType)
+    nameEn: str = StringValidator()
+    abbreviation: str = StringValidator()
+
+
+@validataclass
+class BahnOperatorInput:
+    name: str = StringValidator()
+    # url: str = UrlValidator()  # TODO: urls are broken
+
+
+@validataclass
+class BahnLocationInput:
+    longitude: Decimal = NumericValidator()
+    latitude: Decimal = NumericValidator()
+
+
+@validataclass
+class BahnAdressInput:
+    streetAndNumber: str = StringValidator()
+    zip: str = StringValidator()
+    city: str = StringValidator()
+    phone: Optional[str] = Noneable(StringValidator())
+    location: BahnLocationInput = DataclassValidator(BahnLocationInput)
+
+
+@validataclass
+class BahnCapacityInput:
+    type: BahnParkingSiteCapacityType = EnumValidator(BahnParkingSiteCapacityType)
+    total: int = IntegerValidator(allow_strings=True, min_value=0)
+
+
+@validataclass
+class BahnOpeningHoursInput:
+    text: Optional[str] = StringValidator(), Default(None)
+    is24h: bool = BooleanValidator()
+
+
+@validataclass
+class BahnClearanceInput:
+    height: Optional[Decimal] = Noneable(DecimalValidator()), Default(None)
+    width: Optional[Decimal] = Noneable(DecimalValidator()), Default(None)
+
+
+@validataclass
+class BahnRestrictionInput:
+    clearance: BahnClearanceInput = DataclassValidator(BahnClearanceInput)
+
+
+@validataclass
+class BahnAccessInput:
+    openingHours: BahnOpeningHoursInput = DataclassValidator(BahnOpeningHoursInput)
+    restrictions: BahnRestrictionInput = DataclassValidator(BahnRestrictionInput)
+    # TODO: ignored multible attributes which do not matter so far
+
+
+@validataclass
+class BahnParkingSiteInput:
+    id: int = IntegerValidator(allow_strings=True)
+    name: list[BahnNameInput] = ListValidator(DataclassValidator(BahnNameInput))
+    url: Optional[str] = UrlValidator(), Default(None)
+    type: BahnTypeInput = DataclassValidator(BahnTypeInput)
+    operator: BahnOperatorInput = DataclassValidator(BahnOperatorInput)
+    address: BahnAdressInput = DataclassValidator(BahnAdressInput)
+    capacity: list[BahnCapacityInput] = ListValidator(DataclassValidator(BahnCapacityInput))
+    access: BahnAccessInput = DataclassValidator(BahnAccessInput)
+    # TODO: ignored multible attributes which do not matter so far

parkapi_sources/converters/base_converter/__init__.py

@@ -0,0 +1,6 @@
+"""
+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 .base_converter import BaseConverter

parkapi_sources/converters/base_converter/base_converter.py

@@ -0,0 +1,26 @@
+"""
+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 validataclass.validators import DataclassValidator
+
+from parkapi_sources.models import RealtimeParkingSiteInput, SourceInfo, StaticParkingSiteInput
+from parkapi_sources.util import ConfigHelper
+
+
+class BaseConverter(ABC):
+    config_helper: ConfigHelper
+    static_parking_site_validator = DataclassValidator(StaticParkingSiteInput)
+    realtime_parking_site_validator = DataclassValidator(RealtimeParkingSiteInput)
+    required_config_keys: list[str] = []
+
+    def __init__(self, config_helper: ConfigHelper):
+        self.config_helper = config_helper
+
+    @property
+    @abstractmethod
+    def source_info(self) -> SourceInfo:
+        pass

parkapi_sources/converters/base_converter/pull/__init__.py

@@ -0,0 +1,8 @@
+"""
+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 .pull_converter import PullConverter
+from .pull_scraper_mixin import PullScraperMixin
+from .static_geojson_data_mixin import GeojsonFeatureGeometryInput, GeojsonInput, StaticGeojsonDataMixin

parkapi_sources/converters/base_converter/pull/pull_converter.py

@@ -0,0 +1,20 @@
+"""
+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 abstractmethod
+
+from parkapi_sources.converters.base_converter import BaseConverter
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+
+
+class PullConverter(BaseConverter):
+    @abstractmethod
+    def get_static_parking_sites(self) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        pass
+
+    @abstractmethod
+    def get_realtime_parking_sites(self) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        pass

parkapi_sources/converters/base_converter/pull/pull_scraper_mixin.py

@@ -0,0 +1,74 @@
+"""
+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 typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+from validataclass.exceptions import ValidationError
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import RealtimeParkingSiteInput, SourceInfo
+
+
+class PullScraperMixin(ABC):
+    source_info: SourceInfo
+    realtime_parking_site_validator: DataclassValidator
+
+    @abstractmethod
+    def get_realtime_tags_and_params(self) -> tuple[list[Tag], dict]:
+        pass
+
+    @abstractmethod
+    def realtime_tag_to_dict(self, tag: Tag, **kwargs) -> Optional[dict]:
+        pass
+
+    def load_url_in_soup(self, url: Optional[str] = None):
+        if url is None:
+            url = self.source_info.public_url
+
+        response = requests.get(url, timeout=30)
+
+        return BeautifulSoup(response.text, features='html.parser')
+
+    def _get_scraped_realtime_parking_site_inputs_and_exceptions(
+        self,
+    ) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        realtime_parking_site_inputs: list[RealtimeParkingSiteInput] = []
+        import_parking_site_exceptions: list[ImportParkingSiteException] = []
+
+        tags, params = self.get_realtime_tags_and_params()
+        for tag in tags:
+            try:
+                realtime_parking_site_dict = self.realtime_tag_to_dict(tag, **params)
+            except Exception as e:
+                import_parking_site_exceptions.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        message=f'Invalid data: {e}',
+                    ),
+                )
+                continue
+
+            # If realtime_parking_site_dict is None, we don't have a dataset to handle
+            if realtime_parking_site_dict is None:
+                continue
+
+            try:
+                realtime_parking_site_inputs.append(self.realtime_parking_site_validator.validate(realtime_parking_site_dict))
+            except ValidationError as e:
+                import_parking_site_exceptions.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=realtime_parking_site_dict.get('uid'),
+                        message=f'Invallid data at uid {realtime_parking_site_dict.get("uid")}: {e.to_dict()}, '
+                        f'data: {realtime_parking_site_dict}',
+                    ),
+                )
+
+        return realtime_parking_site_inputs, import_parking_site_exceptions

parkapi_sources/converters/base_converter/pull/static_geojson_data_mixin/__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 .mixin import StaticGeojsonDataMixin
+from .models import GeojsonFeatureGeometryInput, GeojsonInput

parkapi_sources/converters/base_converter/pull/static_geojson_data_mixin/mixin.py

@@ -0,0 +1,69 @@
+"""
+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 json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import requests
+from validataclass.exceptions import ValidationError
+from validataclass.validators import DataclassValidator
+
+from parkapi_sources.converters.base_converter.pull.static_geojson_data_mixin.models import GeojsonFeatureInput, GeojsonInput
+from parkapi_sources.exceptions import ImportParkingSiteException, ImportSourceException
+from parkapi_sources.models import SourceInfo, StaticParkingSiteInput
+from parkapi_sources.util import ConfigHelper
+
+
+class StaticGeojsonDataMixin:
+    config_helper: ConfigHelper
+    source_info: SourceInfo
+    geojson_validator = DataclassValidator(GeojsonInput)
+    geojson_feature_validator = DataclassValidator(GeojsonFeatureInput)
+    _base_url = 'https://raw.githubusercontent.com/ParkenDD/parkapi-sources-v3/main/data'
+
+    def _get_static_geojson(self, source_uid: str) -> GeojsonInput:
+        if self.config_helper.get('STATIC_GEOJSON_BASE_PATH'):
+            with Path(self.config_helper.get('STATIC_GEOJSON_BASE_PATH'), f'{source_uid}.geojson').open() as geojson_file:
+                return json.loads(geojson_file.read())
+        else:
+            response = requests.get(f'{self.config_helper.get("STATIC_GEOJSON_BASE_URL")}/{source_uid}.geojson', timeout=30)
+            return response.json()
+
+    def _get_static_parking_site_inputs_and_exceptions(
+        self,
+        source_uid: str,
+    ) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        geojson_dict = self._get_static_geojson(source_uid)
+        try:
+            geojson_input = self.geojson_validator.validate(geojson_dict)
+        except ValidationError as e:
+            raise ImportSourceException(
+                source_uid=source_uid,
+                message=f'Invalid GeoJSON for source {source_uid}: {e.to_dict()}. Data: {geojson_dict}',
+            ) from e
+
+        static_parking_site_inputs: list[StaticParkingSiteInput] = []
+        import_parking_site_exceptions: list[ImportParkingSiteException] = []
+
+        for feature_dict in geojson_input.features:
+            try:
+                feature_input: GeojsonFeatureInput = self.geojson_feature_validator.validate(feature_dict)
+                static_parking_site_inputs.append(
+                    feature_input.to_static_parking_site_input(
+                        # TODO: Use the Last-Updated HTTP header instead, but as Github does not set such an header, we need to move
+                        #  all GeoJSON data in order to use this.
+                        static_data_updated_at=datetime.now(tz=timezone.utc),
+                    ),
+                )
+            except ValidationError as e:
+                import_parking_site_exceptions.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=feature_dict.get('properties', {}).get('uid'),
+                        message=f'Invalid GeoJSON feature for source {source_uid}: {e.to_dict()}',
+                    ),
+                )
+        return static_parking_site_inputs, import_parking_site_exceptions

parkapi_sources/converters/base_converter/pull/static_geojson_data_mixin/models.py

@@ -0,0 +1,63 @@
+"""
+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
+from decimal import Decimal
+from typing import Optional
+
+from validataclass.dataclasses import Default, ValidataclassMixin, validataclass
+from validataclass.validators import (
+    AnyOfValidator,
+    AnythingValidator,
+    BooleanValidator,
+    DataclassValidator,
+    EnumValidator,
+    IntegerValidator,
+    ListValidator,
+    NumericValidator,
+    StringValidator,
+    UrlValidator,
+)
+
+from parkapi_sources.models import StaticParkingSiteInput
+from parkapi_sources.models.enums import ParkingSiteType
+
+
+@validataclass
+class GeojsonFeaturePropertiesInput(ValidataclassMixin):
+    uid: str = StringValidator(min_length=1, max_length=256)
+    name: str = StringValidator(min_length=1, max_length=256)
+    type: Optional[ParkingSiteType] = EnumValidator(ParkingSiteType), Default(None)
+    public_url: Optional[str] = UrlValidator(max_length=4096), Default(None)
+    address: str = StringValidator(max_length=512)
+    capacity: int = IntegerValidator()
+    has_realtime_data: bool = BooleanValidator()
+
+
+@validataclass
+class GeojsonFeatureGeometryInput:
+    type: str = AnyOfValidator(allowed_values=['Point'])
+    coordinates: list[Decimal] = ListValidator(NumericValidator(), min_length=2, max_length=2)
+
+
+@validataclass
+class GeojsonFeatureInput:
+    type: str = AnyOfValidator(allowed_values=['Feature'])
+    properties: GeojsonFeaturePropertiesInput = DataclassValidator(GeojsonFeaturePropertiesInput)
+    geometry: GeojsonFeatureGeometryInput = DataclassValidator(GeojsonFeatureGeometryInput)
+
+    def to_static_parking_site_input(self, static_data_updated_at: datetime) -> StaticParkingSiteInput:
+        return StaticParkingSiteInput(
+            lat=self.geometry.coordinates[1],
+            lon=self.geometry.coordinates[0],
+            static_data_updated_at=static_data_updated_at,
+            **self.properties.to_dict(),
+        )
+
+
+@validataclass
+class GeojsonInput:
+    type: str = AnyOfValidator(allowed_values=['FeatureCollection'])
+    features: list[dict] = ListValidator(AnythingValidator(allowed_types=[dict]))

parkapi_sources/converters/base_converter/push/__init__.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 .push_converter import PushConverter  # noqa: I001
+
+from .csv_converter import CsvConverter
+from .json_converter import JsonConverter
+from .normalized_xlsx_converter import NormalizedXlsxConverter
+from .xlsx_converter import XlsxConverter
+from .xml_converter import XmlConverter

parkapi_sources/converters/base_converter/push/csv_converter.py

@@ -0,0 +1,39 @@
+"""
+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.
+"""
+
+import csv
+from abc import ABC, abstractmethod
+from io import StringIO
+from typing import Any
+
+from parkapi_sources.converters.base_converter.push import PushConverter
+from parkapi_sources.exceptions import ImportParkingSiteException, ImportSourceException
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+
+
+class CsvConverter(PushConverter, ABC):
+    def handle_csv_string(
+        self,
+        data: StringIO,
+    ) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        return self.handle_csv(list(csv.reader(data, delimiter=';')))
+
+    def get_mapping_by_header(self, header_row: dict[str, str], row: list[Any]) -> dict[str, int]:
+        mapping: dict[str, int] = {}
+        for header_field, target_field in header_row.items():
+            if header_field not in row:
+                raise ImportSourceException(
+                    source_uid=self.source_info.uid,
+                    message=f'cannot find header key {header_field}',
+                )
+            mapping[target_field] = row.index(header_field)
+        return mapping
+
+    @abstractmethod
+    def handle_csv(
+        self,
+        data: list[list],
+    ) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        pass

parkapi_sources/converters/base_converter/push/json_converter.py

@@ -0,0 +1,19 @@
+"""
+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 parkapi_sources.converters.base_converter.push import PushConverter
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+
+
+class JsonConverter(PushConverter, ABC):
+    @abstractmethod
+    def handle_json(
+        self,
+        data: dict | list,
+    ) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        pass