parkapi-sources 0.2.0__tar.gz → 0.3.0__tar.gz

parkapi_sources-0.2.0/.github/workflows/lint.yml → parkapi_sources-0.3.0/.github/workflows/lint-test.yml

@@ -1,9 +1,6 @@
 name: lint
 
 on:
-  push:
-    branches:
-      - '*'
   pull_request:
     branches:
       - '*'
@@ -13,17 +10,15 @@ on:
 jobs:
   lint:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version:
-          - '3'
+
     steps:
     - name: checkout
       uses: actions/checkout@v4
-    - name: setup Python v${{ matrix.python-version }}
+
+    - name: setup Python v3.10
       uses: actions/setup-python@v5
       with:
-        python-version: ${{ matrix.python-version }}
+        python-version: '3.10'
         cache: 'pip'
 
     - name: pip install
@@ -41,3 +36,28 @@ jobs:
       # uses: uses: psf/black@stable
       run: |
         black -S --check --diff ./src ./tests
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+
+    - name: set timezone
+      uses: szenius/set-timezone@v2.0
+      with:
+        timezoneLinux: "Europe/Berlin"
+
+    - name: checkout
+      uses: actions/checkout@v4
+
+    - name: setup Python v3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.10'
+        cache: 'pip'
+
+    - name: pip install
+      run: pip install -r requirements.txt -r requirements-dev.txt
+
+    - name: run pytest
+      run: python -m pytest tests

parkapi_sources-0.3.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.3.0
+
+Released 2024-05-02
+
+Features:
+
+* Automated tests via CI pipeline
+* Converter: [Neckarsulm bike](https://github.com/ParkenDD/parkapi-sources-v3/pull/27)
+* Converter: [Kienzler](https://github.com/ParkenDD/parkapi-sources-v3/pull/22)
+* Converter: [Mannheim and Buchen](https://github.com/ParkenDD/parkapi-sources-v3/pull/21)
+* Converter: [Reutlingen bike](https://github.com/ParkenDD/parkapi-sources-v3/pull/28)
+* Converter: [Baden-Württemberg: Park und Mitfahren](https://github.com/ParkenDD/parkapi-sources-v3/pull/18)
+
+Fixes:
+* [Fix required key at Heidelberg converter](https://github.com/ParkenDD/parkapi-sources-v3/pull/20)
+
+
+## 0.2.0
+
+Released 2024-04-18
+
+First release including [public PyPI package](https://pypi.org/project/parkapi-sources/).

{parkapi_sources-0.2.0 → parkapi_sources-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: parkapi_sources
-Version: 0.2.0
+Version: 0.3.0
 Summary: ParkAPI Sources is a collection of converters from several different data sources to normalized ParkAPI data.
 Author-email: "Ernesto Ruge, binary butterfly GmbH" <ernesto.ruge@binary-butterfly.de>
 Maintainer-email: "Ernesto Ruge, binary butterfly GmbH" <ernesto.ruge@binary-butterfly.de>
@@ -47,14 +47,20 @@ We support following data sources:
 | Barrierefreie Reisekette Baden-Württemberg: PKW-Parkplätze an Bushaltestellen     | car     | push (csv)  | `bfrk_bw_spnv_car`   | no       |
 | Barrierefreie Reisekette Baden-Württemberg: Fahrrad-Parkplätze an Bahnhöfen       | bike    | push (csv)  | `bfrk_bw_oepnv_bike` | no       |
 | Barrierefreie Reisekette Baden-Württemberg: Fahrrad-Parkplätze an Bushaltestellen | bike    | push (csv)  | `bfrk_bw_spnv_bike`  | no       |
+| Stadt Buchen                                                                      | car     | push (json) | `buchen`             | yes      |
 | Stadt Freiburg                                                                    | car     | pull        | `freiburg`           | yes      |
 | Stadt Heidelberg                                                                  | car     | pull        | `heidelberg`         | yes      |
 | Stadt Karlsruhe                                                                   | car     | pull        | `karlsruhe`          | yes      |
-| Stadt Mannheim                                                                    | car     | pull        | `mannheim`           | yes      |
+| Kienzler                                                                          | bike    | pull        | `kienzler`           | yes      |
+| Stadt Mannheim                                                                    | car     | push (json) | `mannheim`           | yes      |
+| Stadt Neckarsulm: PKW-Parkplätze                                                  | car     | pull        | `neckarsulm`         | no       |
+| Stadt Neckarsulm: Fahrrad-Abstellanlagen                                          | bike    | pull        | `neckarsulm_bike`    | no       |
 | Stadt Karlsruhe                                                                   | car     | push (csv)  | `neckarsulm`         | no       |
+| Baden-Württemberg: Parken und Mitfahren                                           | car     | push (xlsx) | `pum_bw`             | no       |
 | Parkraumgesellschaft Baden-Württemberg                                            | car     | pull        | `pbw`                | yes      |
 | Stadt Pforzheim                                                                   | car     | push (csv)  | `pforzheim`          | no       |
-| Stadt Reutlingen                                                                  | car     | push (csv)  | `reutlingen`         | no       |
+| Stadt Reutlingen: PKW-Parkplätze                                                  | car     | push (csv)  | `reutlingen`         | no       |
+| Stadt Reutlingen: Fahrrad-Abstellanlagen                                          | bike    | push (csv)  | `reutlingen_bike`    | no       |
 | Stadt Stuttgart                                                                   | car     | push (json) | `stuttgart`          | yes      |
 | Stadt Ulm                                                                         | car     | pull        | `ulm`                | yes      |
 | Verband Region Stuttgart: Park and Ride                                           | car     | pull        | `vrs_p_r`            | yes      |
@@ -216,6 +222,48 @@ If you test a `PullConverter`, you will need no mock requests. This can be done
 If you created new validators, these should be tested with different inputs. Usually, `pytest.parametrize` is a nice approach to do this.
 
 
+### Migrate a converter
+
+If you want to migrate a v1 or v2 converter, you can re-use some of the code. There is a paradigm change, though: `parkapi-source-v3` 
+enforces a strict validation after transforming the data, while v1 and v2 converters don't. ParkAPI v1 / v2 converters are always pull
+converters, so the base class is always `PullConverter`.
+
+Instead of defining `POOL`, you will set `source_info` at the same place. Attributes are almost the same, except for `id` was renamed to 
+`uid`, and there is the new attribute `has_realtime_data`, which has to be set.
+
+ParkAPI v1 and v2 used two methods for static and realtime data, just as `parkapi-sources-v3`:
+
+- the old static data handling `def get_lot_infos(self) -> List[LotInfo]:` is
+  `get_static_parking_sites(self) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:` in `parkapi-sources-v3`.
+- the old realtime data handling`def get_lot_data(self) -> List[LotData]:` is
+  `def get_realtime_parking_sites(self) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:` in 
+  `parkapi-sources-v3`.
+
+The result objects have quite the same idea, too:
+
+- `LotInfo` gets `StaticParkingSiteInput`
+- `LotData` gets `RealtimeParkingSiteInput`
+
+There's also a helper for scraped content: before, there was `self.request_soup(self.POOL.public_url)` in order to get a `BeautifulSoup`
+element. Now, there is a helper mixin called `PullScraperMixin`. You can use it this way: 
+
+```
+class MyPullConverter(PullConverter, PullScraperMixin):
+```
+
+Additionally, there is another mixin for the GeoJSON files you already know from v1 and v2 converters: `StaticGeojsonDataMixin`. Using this,
+you can just define the static data method this way:
+
+```
+    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)
+```
+
+Afterwards, you can put the GeoJSON file to `/data`.
+
+Please keep in mind that you will have to add tests for the migrated scraper.
+
+
 ### Linting
 
 As we try to keep a consistent code style, please lint your code before creating the merge request. We use `black` and `ruff` for linting.

{parkapi_sources-0.2.0 → parkapi_sources-0.3.0}/README.md

@@ -13,14 +13,20 @@ We support following data sources:
 | Barrierefreie Reisekette Baden-Württemberg: PKW-Parkplätze an Bushaltestellen     | car     | push (csv)  | `bfrk_bw_spnv_car`   | no       |
 | Barrierefreie Reisekette Baden-Württemberg: Fahrrad-Parkplätze an Bahnhöfen       | bike    | push (csv)  | `bfrk_bw_oepnv_bike` | no       |
 | Barrierefreie Reisekette Baden-Württemberg: Fahrrad-Parkplätze an Bushaltestellen | bike    | push (csv)  | `bfrk_bw_spnv_bike`  | no       |
+| Stadt Buchen                                                                      | car     | push (json) | `buchen`             | yes      |
 | Stadt Freiburg                                                                    | car     | pull        | `freiburg`           | yes      |
 | Stadt Heidelberg                                                                  | car     | pull        | `heidelberg`         | yes      |
 | Stadt Karlsruhe                                                                   | car     | pull        | `karlsruhe`          | yes      |
-| Stadt Mannheim                                                                    | car     | pull        | `mannheim`           | yes      |
+| Kienzler                                                                          | bike    | pull        | `kienzler`           | yes      |
+| Stadt Mannheim                                                                    | car     | push (json) | `mannheim`           | yes      |
+| Stadt Neckarsulm: PKW-Parkplätze                                                  | car     | pull        | `neckarsulm`         | no       |
+| Stadt Neckarsulm: Fahrrad-Abstellanlagen                                          | bike    | pull        | `neckarsulm_bike`    | no       |
 | Stadt Karlsruhe                                                                   | car     | push (csv)  | `neckarsulm`         | no       |
+| Baden-Württemberg: Parken und Mitfahren                                           | car     | push (xlsx) | `pum_bw`             | no       |
 | Parkraumgesellschaft Baden-Württemberg                                            | car     | pull        | `pbw`                | yes      |
 | Stadt Pforzheim                                                                   | car     | push (csv)  | `pforzheim`          | no       |
-| Stadt Reutlingen                                                                  | car     | push (csv)  | `reutlingen`         | no       |
+| Stadt Reutlingen: PKW-Parkplätze                                                  | car     | push (csv)  | `reutlingen`         | no       |
+| Stadt Reutlingen: Fahrrad-Abstellanlagen                                          | bike    | push (csv)  | `reutlingen_bike`    | no       |
 | Stadt Stuttgart                                                                   | car     | push (json) | `stuttgart`          | yes      |
 | Stadt Ulm                                                                         | car     | pull        | `ulm`                | yes      |
 | Verband Region Stuttgart: Park and Ride                                           | car     | pull        | `vrs_p_r`            | yes      |
@@ -182,6 +188,48 @@ If you test a `PullConverter`, you will need no mock requests. This can be done
 If you created new validators, these should be tested with different inputs. Usually, `pytest.parametrize` is a nice approach to do this.
 
 
+### Migrate a converter
+
+If you want to migrate a v1 or v2 converter, you can re-use some of the code. There is a paradigm change, though: `parkapi-source-v3` 
+enforces a strict validation after transforming the data, while v1 and v2 converters don't. ParkAPI v1 / v2 converters are always pull
+converters, so the base class is always `PullConverter`.
+
+Instead of defining `POOL`, you will set `source_info` at the same place. Attributes are almost the same, except for `id` was renamed to 
+`uid`, and there is the new attribute `has_realtime_data`, which has to be set.
+
+ParkAPI v1 and v2 used two methods for static and realtime data, just as `parkapi-sources-v3`:
+
+- the old static data handling `def get_lot_infos(self) -> List[LotInfo]:` is
+  `get_static_parking_sites(self) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:` in `parkapi-sources-v3`.
+- the old realtime data handling`def get_lot_data(self) -> List[LotData]:` is
+  `def get_realtime_parking_sites(self) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:` in 
+  `parkapi-sources-v3`.
+
+The result objects have quite the same idea, too:
+
+- `LotInfo` gets `StaticParkingSiteInput`
+- `LotData` gets `RealtimeParkingSiteInput`
+
+There's also a helper for scraped content: before, there was `self.request_soup(self.POOL.public_url)` in order to get a `BeautifulSoup`
+element. Now, there is a helper mixin called `PullScraperMixin`. You can use it this way: 
+
+```
+class MyPullConverter(PullConverter, PullScraperMixin):
+```
+
+Additionally, there is another mixin for the GeoJSON files you already know from v1 and v2 converters: `StaticGeojsonDataMixin`. Using this,
+you can just define the static data method this way:
+
+```
+    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)
+```
+
+Afterwards, you can put the GeoJSON file to `/data`.
+
+Please keep in mind that you will have to add tests for the migrated scraper.
+
+
 ### Linting
 
 As we try to keep a consistent code style, please lint your code before creating the merge request. We use `black` and `ruff` for linting.

{parkapi_sources-0.2.0 → parkapi_sources-0.3.0}/src/parkapi_sources/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)

{parkapi_sources-0.2.0 → parkapi_sources-0.3.0}/src/parkapi_sources/converters/__init__.py

@@ -9,11 +9,15 @@ from .bfrk_bw import BfrkBwOepnvBikePushConverter, BfrkBwOepnvCarPushConverter,
 from .freiburg import FreiburgPullConverter
 from .heidelberg import HeidelbergPullConverter
 from .karlsruhe import KarlsruhePullConverter
-from .mannheim import MannheimPullConverter
+from .kienzler import KienzlerPullConverter
+from .mannheim_buchen import BuchenPushConverter, MannheimPushConverter
 from .neckarsulm import NeckarsulmPushConverter
+from .neckarsulm_bike import NeckarsulmBikePushConverter
 from .pbw import PbwPullConverter
 from .pforzheim import PforzheimPushConverter
+from .pum_bw import PumBwPushConverter
 from .reutlingen import ReutlingenPushConverter
+from .reutlingen_bike import ReutlingenBikePushConverter
 from .stuttgart import StuttgartPushConverter
 from .ulm import UlmPullConverter
 from .vrs_p_r import VrsParkAndRidePushConverter

{parkapi_sources-0.2.0 → parkapi_sources-0.3.0}/src/parkapi_sources/converters/base_converter/push/__init__.py

@@ -8,5 +8,6 @@ from .push_converter import PushConverter  # noqa: I001
 from .csv_converter import CsvConverter
 from .json_converter import JsonConverter
 from .normalized_xlsx_converter import NormalizedXlsxConverter
+from .parkapi_json_converter import ParkApiConverter
 from .xlsx_converter import XlsxConverter
 from .xml_converter import XmlConverter

parkapi_sources-0.3.0/src/parkapi_sources/converters/base_converter/push/parkapi_json_converter.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.
+"""
+
+from abc import ABC
+
+from validataclass.dataclasses import validataclass
+from validataclass.exceptions import ValidationError
+from validataclass.validators import AnythingValidator, DataclassValidator, ListValidator
+
+from parkapi_sources.converters.base_converter.push import JsonConverter
+from parkapi_sources.exceptions import ImportParkingSiteException, ImportSourceException
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+
+
+@validataclass
+class ParkingSiteItemsInput:
+    items: list[dict] = ListValidator(AnythingValidator(allowed_types=[dict]))
+
+
+class ParkApiConverter(JsonConverter, ABC):
+    parking_site_items_validator = DataclassValidator(ParkingSiteItemsInput)
+    static_parking_site_validator = DataclassValidator(StaticParkingSiteInput)
+    realtime_parking_site_validator = DataclassValidator(RealtimeParkingSiteInput)
+
+    def handle_json(
+        self,
+        data: dict | list,
+    ) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        parking_site_inputs: list[StaticParkingSiteInput | RealtimeParkingSiteInput] = []
+        parking_site_errors: list[ImportParkingSiteException] = []
+
+        try:
+            parking_site_item_inputs = self.parking_site_items_validator.validate(data)
+        except ValidationError as e:
+            raise ImportSourceException(source_uid=self.source_info.uid, message=f'Invalid data {e.to_dict()}') from e
+
+        for parking_site_dict in parking_site_item_inputs.items:
+            try:
+                static_parking_site_input = self.static_parking_site_validator.validate(parking_site_dict)
+                parking_site_inputs.append(static_parking_site_input)
+            except ValidationError as e:
+                parking_site_errors.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=parking_site_dict.get('uid'),
+                        message=f'validation error for {parking_site_dict}: {e.to_dict()}',
+                    ),
+                )
+                # If there was an error, we don't proceed with realtime data
+                continue
+
+            # No realtime data means no realtime data handling
+            if not static_parking_site_input.has_realtime_data:
+                continue
+
+            try:
+                parking_site_inputs.append(self.realtime_parking_site_validator.validate(parking_site_dict))
+            except ValidationError as e:
+                parking_site_errors.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=parking_site_dict.get('uid'),
+                        message=f'validation error for {parking_site_dict}: {e.to_dict()}',
+                    ),
+                )
+
+        return parking_site_inputs, parking_site_errors

{parkapi_sources-0.2.0 → parkapi_sources-0.3.0}/src/parkapi_sources/converters/heidelberg/converter.py

@@ -15,6 +15,7 @@ from .validators import HeidelbergRealtimeInput, HeidelbergRealtimeUpdateInput
 
 
 class HeidelbergPullConverter(PullConverter, StaticGeojsonDataMixin):
+    required_config_keys = ['PARK_API_HEIDELBERG_API_KEY']
     heidelberg_realtime_validator = DataclassValidator(HeidelbergRealtimeInput)
     heidelberg_realtime_update_validator = DataclassValidator(HeidelbergRealtimeUpdateInput)
     source_info = SourceInfo(

{parkapi_sources-0.2.0/src/parkapi_sources/converters/mannheim → parkapi_sources-0.3.0/src/parkapi_sources/converters/kienzler}/__init__.py

@@ -3,4 +3,4 @@ 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 MannheimPullConverter
+from .converter import KienzlerPullConverter

parkapi_sources-0.3.0/src/parkapi_sources/converters/kienzler/converter.py

@@ -0,0 +1,78 @@
+"""
+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 AnythingValidator, DataclassValidator, ListValidator
+
+from parkapi_sources.converters.base_converter.pull import PullConverter
+from parkapi_sources.exceptions import ImportParkingSiteException
+from parkapi_sources.models import RealtimeParkingSiteInput, SourceInfo, StaticParkingSiteInput
+
+from .models import KienzlerInput
+
+
+class KienzlerPullConverter(PullConverter):
+    kienzler_list_validator = ListValidator(AnythingValidator(allowed_types=[dict]))
+    kienzler_item_validator = DataclassValidator(KienzlerInput)
+
+    required_config_keys = ['PARK_API_KIENZLER_USER', 'PARK_API_KIENZLER_PASSWORD', 'PARK_API_KIENZLER_IDS']
+    source_info = SourceInfo(
+        uid='kienzler',
+        name='Kienzler',
+        has_realtime_data=True,
+        public_url='https://www.bikeandridebox.de',
+    )
+
+    def get_static_parking_sites(self) -> tuple[list[StaticParkingSiteInput], list[ImportParkingSiteException]]:
+        static_parking_site_inputs: list[StaticParkingSiteInput] = []
+
+        kienzler_parking_sites, static_parking_site_errors = self._get_kienzler_parking_sites()
+        for kienzler_parking_site in kienzler_parking_sites:
+            static_parking_site_inputs.append(kienzler_parking_site.to_static_parking_site())
+
+        return static_parking_site_inputs, static_parking_site_errors
+
+    def get_realtime_parking_sites(self) -> tuple[list[RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        realtime_parking_site_inputs: list[RealtimeParkingSiteInput] = []
+
+        kienzler_parking_sites, static_parking_site_errors = self._get_kienzler_parking_sites()
+        for kienzler_parking_site in kienzler_parking_sites:
+            realtime_parking_site_inputs.append(kienzler_parking_site.to_realtime_parking_site())
+
+        return realtime_parking_site_inputs, static_parking_site_errors
+
+    def _get_kienzler_parking_sites(self) -> tuple[list[KienzlerInput], list[ImportParkingSiteException]]:
+        kienzler_item_inputs: list[KienzlerInput] = []
+        errors: list[ImportParkingSiteException] = []
+
+        parking_site_dicts = self.kienzler_list_validator.validate(self._request())
+        for parking_site_dict in parking_site_dicts:
+            try:
+                kienzler_item_inputs.append(self.kienzler_item_validator.validate(parking_site_dict))
+            except ValidationError as e:
+                errors.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=parking_site_dict.get('uid'),
+                        message=f'validation error for {parking_site_dict}: {e.to_dict()}',
+                    ),
+                )
+        return kienzler_item_inputs, errors
+
+    def _request(self) -> list[dict]:
+        response = requests.post(
+            url='https://www.bikeandridebox.de/index.php?eID=JSONAPI',
+            json={
+                'user': self.config_helper.get('PARK_API_KIENZLER_USER'),
+                'password': self.config_helper.get('PARK_API_KIENZLER_PASSWORD'),
+                'action': 'capacity',
+                'context': 'unit',
+                'ids': self.config_helper.get('PARK_API_KIENZLER_IDS').split(','),
+            },
+            timeout=30,
+        )
+
+        return response.json()

parkapi_sources-0.3.0/src/parkapi_sources/converters/kienzler/models.py

@@ -0,0 +1,44 @@
+"""
+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 validataclass.dataclasses import validataclass
+from validataclass.validators import IntegerValidator, NumericValidator, StringValidator
+
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+from parkapi_sources.models.enums import ParkingSiteType, PurposeType
+
+
+@validataclass
+class KienzlerInput:
+    id: str = StringValidator(min_length=1)
+    name: str = StringValidator()
+    lat: Decimal = NumericValidator()
+    long: Decimal = NumericValidator()
+    bookable: int = IntegerValidator(min_value=0)
+    sum_boxes: int = IntegerValidator(min_value=0)
+
+    def to_static_parking_site(self) -> StaticParkingSiteInput:
+        return StaticParkingSiteInput(
+            uid=self.id,
+            name=self.name,
+            purpose=PurposeType.ITEM if 'Schließfächer' in self.name else PurposeType.BIKE,
+            lat=self.lat,
+            lon=self.long,
+            has_realtime_data=True,
+            capacity=self.sum_boxes,
+            type=ParkingSiteType.LOCKERS,
+            static_data_updated_at=datetime.now(tz=timezone.utc),
+        )
+
+    def to_realtime_parking_site(self) -> RealtimeParkingSiteInput:
+        return RealtimeParkingSiteInput(
+            uid=self.id,
+            realtime_data_updated_at=datetime.now(tz=timezone.utc),
+            realtime_capacity=self.sum_boxes,
+            realtime_free_capacity=self.bookable,
+        )

parkapi_sources-0.3.0/src/parkapi_sources/converters/mannheim_buchen/__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 BuchenPushConverter, MannheimPushConverter

parkapi_sources-0.3.0/src/parkapi_sources/converters/mannheim_buchen/converter.py

@@ -0,0 +1,68 @@
+"""
+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.exceptions import ValidationError
+from validataclass.validators import AnythingValidator, DataclassValidator, ListValidator
+
+from parkapi_sources.converters.base_converter.push import JsonConverter
+from parkapi_sources.converters.mannheim_buchen.models import MannheimBuchenInput
+from parkapi_sources.exceptions import ImportParkingSiteException, ImportSourceException
+from parkapi_sources.models import RealtimeParkingSiteInput, SourceInfo, StaticParkingSiteInput
+
+
+class MannheimBuchenBaseConverter(JsonConverter, ABC):
+    mannheim_buchen_list_validator = ListValidator(AnythingValidator(allowed_types=[dict]))
+    mannheim_buchen_validator = DataclassValidator(MannheimBuchenInput)
+
+    def handle_json(
+        self,
+        data: dict | list,
+    ) -> tuple[list[StaticParkingSiteInput | RealtimeParkingSiteInput], list[ImportParkingSiteException]]:
+        parking_site_inputs: list[StaticParkingSiteInput | RealtimeParkingSiteInput] = []
+        parking_site_errors: list[ImportParkingSiteException] = []
+
+        try:
+            parking_site_dicts = self.mannheim_buchen_list_validator.validate(data)
+        except ValidationError as e:
+            raise ImportSourceException(source_uid=self.source_info.uid, message=f'Invalid data {e.to_dict()}') from e
+
+        for parking_site_dict in parking_site_dicts:
+            try:
+                parking_site_input: MannheimBuchenInput = self.mannheim_buchen_validator.validate(parking_site_dict)
+
+                parking_site_inputs.append(parking_site_input.to_static_parking_site(city=self.source_info.name))
+                parking_site_inputs.append(parking_site_input.to_realtime_parking_site())
+
+            except ValidationError as e:
+                parking_site_errors.append(
+                    ImportParkingSiteException(
+                        source_uid=self.source_info.uid,
+                        parking_site_uid=parking_site_dict.get('uid'),
+                        message=f'validation error for {parking_site_dict}: {e.to_dict()}',
+                    ),
+                )
+        return parking_site_inputs, parking_site_errors
+
+
+class MannheimPushConverter(MannheimBuchenBaseConverter):
+    source_info = SourceInfo(
+        uid='mannheim',
+        name='Stadt Mannheim',
+        public_url='https://www.parken-mannheim.de',
+        timezone='Europe/Berlin',
+        has_realtime_data=True,
+    )
+
+
+class BuchenPushConverter(MannheimBuchenBaseConverter):
+    source_info = SourceInfo(
+        uid='buchen',
+        name='Stadt Buchen',
+        public_url='https://www.buchen.de/ueber-buchen/kostenlos-parken.html',
+        timezone='Europe/Berlin',
+        has_realtime_data=True,
+    )

parkapi_sources-0.3.0/src/parkapi_sources/converters/mannheim_buchen/models.py

@@ -0,0 +1,99 @@
+"""
+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 enum import Enum
+from zoneinfo import ZoneInfo
+
+from validataclass.dataclasses import DefaultUnset, validataclass
+from validataclass.helpers import OptionalUnset
+from validataclass.validators import (
+    AnyOfValidator,
+    DataclassValidator,
+    DateTimeValidator,
+    EnumValidator,
+    IntegerValidator,
+    ListValidator,
+    NumericValidator,
+    StringValidator,
+)
+
+from parkapi_sources.models import RealtimeParkingSiteInput, StaticParkingSiteInput
+from parkapi_sources.models.enums import ParkingSiteType
+
+
+class MannheimParkingSiteType(Enum):
+    CAR_PARK = 'carPark'
+
+    def to_parking_site_type(self) -> ParkingSiteType:
+        return {
+            self.CAR_PARK: ParkingSiteType.CAR_PARK,
+        }.get(self)
+
+
+@validataclass
+class MannheimBuchenLocationInput:
+    coordinates: list[Decimal] = ListValidator(NumericValidator())
+    type: str = AnyOfValidator(allowed_values=['Point'])
+
+
+@validataclass
+class MannheimBuchenAddressInput:
+    street: OptionalUnset[str] = StringValidator(), DefaultUnset
+    houseNo: OptionalUnset[str] = StringValidator(), DefaultUnset
+    postalCode: OptionalUnset[str] = StringValidator(), DefaultUnset
+    city: OptionalUnset[str] = StringValidator(), DefaultUnset
+
+
+@validataclass
+class MannheimBuchenInput:
+    id: str = StringValidator()
+    name: str = StringValidator()
+    operatorId: str = StringValidator()
+    dataType: str = AnyOfValidator(allowed_values=['parkingCar'])
+    location: MannheimBuchenLocationInput = DataclassValidator(MannheimBuchenLocationInput)
+    address: MannheimBuchenAddressInput = DataclassValidator(MannheimBuchenAddressInput)
+    description: str = StringValidator()
+    trafficType: str = AnyOfValidator(allowed_values=['car'])
+    type: MannheimParkingSiteType = EnumValidator(MannheimParkingSiteType)
+    capacity: int = IntegerValidator(min_value=0)
+    free: int = IntegerValidator(min_value=0)
+    timestamp: datetime = DateTimeValidator(local_timezone=ZoneInfo('Europe/Berlin'), target_timezone=timezone.utc)
+
+    def to_static_parking_site(self, city: str) -> StaticParkingSiteInput:
+        address = ''
+        if self.address.street:
+            address = self.address.street
+            if self.address.houseNo:
+                address += f' {self.address.houseNo}'
+            address += ', '
+        if self.address.postalCode:
+            address += f' {self.address.postalCode}'
+        if self.address.city:
+            address += f' {self.address.city}'
+        else:
+            address += f' {city}'
+
+        return StaticParkingSiteInput(
+            uid=self.id,
+            name=self.name,
+            address=address,
+            description=self.description,
+            lat=self.location.coordinates[1],
+            lon=self.location.coordinates[0],
+            has_realtime_data=True,
+            capacity=self.capacity,
+            type=self.type.to_parking_site_type(),
+            static_data_updated_at=self.timestamp,
+        )
+
+    def to_realtime_parking_site(self) -> RealtimeParkingSiteInput:
+        return RealtimeParkingSiteInput(
+            uid=self.id,
+            realtime_data_updated_at=self.timestamp,
+            realtime_capacity=self.capacity,
+            realtime_free_capacity=self.free,
+        )