python-openpublictransport 0.1.14__tar.gz → 0.1.16__tar.gz

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-openpublictransport
-Version: 0.1.14
+Version: 0.1.16
 Summary: Python library for public transport APIs (EFA, OTP2, TRIAS, FPTF, HAFAS, GTFS-RT)
 License: MIT
 Requires-Python: >=3.11

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-openpublictransport"
-version = "0.1.14"
+version = "0.1.16"
 description = "Python library for public transport APIs (EFA, OTP2, TRIAS, FPTF, HAFAS, GTFS-RT)"
 readme = "README.md"
 license = { text = "MIT" }

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/const.py

@@ -4,6 +4,7 @@
 PROVIDER_VRR = "vrr"
 PROVIDER_KVV = "kvv"
 PROVIDER_HVV = "hvv"
+PROVIDER_HVV_GTI = "hvv_gti"  # HVV via the official Geofox GTI API (credentials required)
 PROVIDER_BVG = "bvg"
 PROVIDER_MVV = "mvv"
 PROVIDER_VVS = "vvs"

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/models.py

@@ -38,6 +38,9 @@ class UnifiedDeparture:
     notices: Optional[list[str]] = None
     planned_platform: Optional[str] = None
     platform_changed: bool = False
+    # Human-readable form of `platform` when the provider offers one
+    # ("Gleis 3" next to the technical "3")
+    platform_name: Optional[str] = None
     line_color: Optional[str] = None
     line_text_color: Optional[str] = None
 
@@ -60,6 +63,8 @@ class UnifiedDeparture:
             result["agency"] = self.agency
         if self.notices:
             result["notices"] = self.notices
+        if self.platform_name and self.platform_name != self.platform:
+            result["platform_name"] = self.platform_name
         if self.platform_changed:
             result["planned_platform"] = self.planned_platform
             result["platform_changed"] = True

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/parsers.py

@@ -1,6 +1,7 @@
 """Common parsing utilities for all providers."""
 
 import logging
+import re
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Optional, Union
 from zoneinfo import ZoneInfo
@@ -9,6 +10,29 @@ from .models import UnifiedDeparture
 
 _LOGGER = logging.getLogger(__name__)
 
+# Human-readable platform labels APIs prefix onto the bare track identifier:
+# "Gleis 3", "Bstg. 12", "Steig B", "Platform 4", "Pl. 2", "Track 1".
+_PLATFORM_LABEL_RE = re.compile(
+    r"^(?:gleis|bstg\.?|bahnsteig|steig|platform|plattform|pl\.|track|quai|voie|spor|perron)\s*",
+    re.IGNORECASE,
+)
+
+
+def normalize_platform(value: Any) -> str:
+    """Reduce a platform value to its bare identifier, lowercased.
+
+    ``"Gleis 3"``, ``"gleis 3"`` and ``"3"`` all normalize to ``"3"``. Used to
+    compare a technical platform value against a human-readable one without
+    reporting a spurious platform change, and re-used by consumers that want to
+    match user input like ``platform: 3`` against whatever the provider returns.
+    """
+    if value is None:
+        return ""
+    text = str(value).strip()
+    if not text:
+        return ""
+    return _PLATFORM_LABEL_RE.sub("", text).strip().casefold()
+
 
 def _parse_dt(s: str) -> Optional[datetime]:
     """Parse an ISO datetime string, returning None on failure."""
@@ -18,6 +42,13 @@ def _parse_dt(s: str) -> Optional[datetime]:
         return None
 
 
+def _default_planned_platform_fn(stop: Dict[str, Any]) -> str:
+    """Legacy planned-platform lookup used when a provider supplies none."""
+    platform = stop.get("platform")
+    planned_name = platform.get("plannedName") if isinstance(platform, dict) else None
+    return stop.get("plannedPlatformName") or planned_name or ""
+
+
 def parse_departure_generic(
     stop: Dict[str, Any],
     tz: Union[ZoneInfo, Any],
@@ -25,6 +56,8 @@ def parse_departure_generic(
     get_transport_type_fn: Callable[[Dict[str, Any]], str],
     get_platform_fn: Callable[[Dict[str, Any]], str],
     get_realtime_fn: Callable[[Dict[str, Any], Optional[str], Optional[str]], bool],
+    get_planned_platform_fn: Optional[Callable[[Dict[str, Any]], str]] = None,
+    get_platform_name_fn: Optional[Callable[[Dict[str, Any]], str]] = None,
 ) -> Optional[UnifiedDeparture]:
     """Generic parser for departure data — shared logic across all providers."""
     try:
@@ -75,6 +108,7 @@ def parse_departure_generic(
 
         transport_type = get_transport_type_fn(transportation)
         platform = get_platform_fn(stop)
+        platform_name = get_platform_name_fn(stop) if get_platform_name_fn else ""
 
         time_diff = estimated_local - now
         minutes_until = max(0, int(time_diff.total_seconds() / 60))
@@ -93,10 +127,13 @@ def parse_departure_generic(
                 if text and isinstance(text, str):
                     notices.append(text.strip())
 
-        planned_platform = stop.get("plannedPlatformName") or stop.get("platform", {}).get("plannedName")
-        actual_platform = platform
+        planned_fn = get_planned_platform_fn or _default_planned_platform_fn
+        planned_platform = planned_fn(stop)
+        # Compare normalized values: providers mix the technical identifier
+        # ("3") with the human-readable label ("Gleis 3") across the actual and
+        # planned fields, and those are the same platform, not a change.
         platform_changed = bool(
-            planned_platform and actual_platform and str(planned_platform).strip() != str(actual_platform).strip()
+            planned_platform and platform and normalize_platform(planned_platform) != normalize_platform(platform)
         )
 
         return UnifiedDeparture(
@@ -115,6 +152,7 @@ def parse_departure_generic(
             notices=notices if notices else None,
             planned_platform=str(planned_platform).strip() if planned_platform and platform_changed else None,
             platform_changed=platform_changed,
+            platform_name=str(platform_name).strip() or None,
         )
 
     except Exception as e:

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/providers/__init__.py

@@ -11,6 +11,7 @@ from ..const import (
     PROVIDER_DB,
     PROVIDER_DING,
     PROVIDER_HVV,
+    PROVIDER_HVV_GTI,
     PROVIDER_KVV,
     PROVIDER_MVV,
     PROVIDER_NTA_IE,
@@ -51,6 +52,7 @@ from .db import DBProvider
 from .ding import DINGProvider
 from .gtfsde import OPTProvider
 from .hvv import HVVProvider
+from .hvv_gti import HVVGTIProvider
 from .kvv import KVVProvider
 from .mvv import MVVProvider
 from .nta import NTAProvider
@@ -161,3 +163,4 @@ register_provider(PROVIDER_BART_US, BARTProvider)
 register_provider(PROVIDER_DART_US, DARTProvider)
 register_provider(PROVIDER_IRISHRAIL_IE, IrishRailProvider)
 register_provider(PROVIDER_TPG_CH, TPGProvider)
+register_provider(PROVIDER_HVV_GTI, HVVGTIProvider)

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/providers/efa_base.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from abc import abstractmethod
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 from urllib.parse import quote
 from zoneinfo import ZoneInfo
 
@@ -39,6 +39,52 @@ def _transport_type_from_name(name: str) -> str:
     return "unknown"
 
 
+def _location_and_properties(stop: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """Return (location, location.properties) from an EFA stop event."""
+    location = stop.get("location")
+    if not isinstance(location, dict):
+        return {}, {}
+    properties = location.get("properties")
+    return location, properties if isinstance(properties, dict) else {}
+
+
+def _efa_platform(stop: Dict[str, Any]) -> str:
+    """Technical platform/track of an EFA stop event.
+
+    EFA's RapidJSON carries the track under ``location.properties.platform``.
+    Prefer that technical value ("3") over the human-readable ``platformName``
+    / ``disassembledName`` ("Gleis 3"): the readable form is only populated for
+    rail platforms, while bus and tram stops still have the technical
+    identifier (issue #56).
+
+    The last two fallbacks are the pre-RapidJSON shape, kept so older or
+    non-standard EFA deployments keep working.
+    """
+    location, properties = _location_and_properties(stop)
+    legacy = stop.get("platform")
+    legacy_name = legacy.get("name") if isinstance(legacy, dict) else None
+    return (
+        properties.get("platform")
+        or properties.get("platformName")
+        or location.get("disassembledName")
+        or legacy_name
+        or stop.get("platformName")
+        or ""
+    )
+
+
+def _efa_platform_name(stop: Dict[str, Any]) -> str:
+    """Human-readable platform label ("Gleis 3"), when EFA supplies one."""
+    location, properties = _location_and_properties(stop)
+    return properties.get("platformName") or location.get("disassembledName") or ""
+
+
+def _efa_planned_platform(stop: Dict[str, Any]) -> str:
+    """Scheduled platform, for detecting a real-time platform change."""
+    _, properties = _location_and_properties(stop)
+    return properties.get("plannedPlatform") or properties.get("plannedPlatformName") or ""
+
+
 class EFABaseProvider(BaseProvider):
     """Base class for all EFA-based providers (VRR, KVV, HVV, MVV, etc.)."""
 
@@ -53,8 +99,16 @@ class EFABaseProvider(BaseProvider):
         """Return the base URL for stop finder requests."""
 
     def get_platform_fn(self) -> Callable[[Dict[str, Any]], str]:
-        """Return function to extract platform from stop event."""
-        return lambda s: s.get("platform", {}).get("name") or s.get("platformName", "")
+        """Return function to extract the technical platform from a stop event."""
+        return _efa_platform
+
+    def get_platform_name_fn(self) -> Callable[[Dict[str, Any]], str]:
+        """Return function to extract the human-readable platform label."""
+        return _efa_platform_name
+
+    def get_planned_platform_fn(self) -> Callable[[Dict[str, Any]], str]:
+        """Return function to extract the scheduled platform."""
+        return _efa_planned_platform
 
     def get_realtime_fn(self) -> Callable[[Dict[str, Any], Optional[str], Optional[str]], bool]:
         """Return function to detect realtime data."""
@@ -163,6 +217,8 @@ class EFABaseProvider(BaseProvider):
             get_transport_type_fn=determine_transport_type,
             get_platform_fn=self.get_platform_fn(),
             get_realtime_fn=self.get_realtime_fn(),
+            get_planned_platform_fn=self.get_planned_platform_fn(),
+            get_platform_name_fn=self.get_platform_name_fn(),
         )
 
     async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/providers/hvv.py

@@ -31,10 +31,8 @@ class HVVProvider(EFABaseProvider):
     def get_transport_type_mapping(self) -> Dict[Any, str]:
         return HVV_TRANSPORTATION_TYPES
 
-    def get_platform_fn(self) -> Callable[[Dict[str, Any]], str]:
-        return lambda s: (
-            s.get("location", {}).get("properties", {}).get("platform") or s.get("location", {}).get("platformName", "")
-        )
+    # location.properties.platform is now the EFABaseProvider default, so this
+    # provider no longer needs its own override.
 
     def get_realtime_fn(self) -> Callable[[Dict[str, Any], Optional[str], Optional[str]], bool]:
         return lambda s, est, plan: est != plan if est and plan else False

python_openpublictransport-0.1.16/src/openpublictransport/providers/hvv_gti.py

@@ -0,0 +1,358 @@
+"""HVV via the official Geofox Thin Interface (GTI).
+
+The `hvv` provider talks to the public EFA endpoint. This one uses HOCHBAHN's
+official API on behalf of the HVV, which carries real-time delays, cancellations
+and platform changes that EFA does not expose.
+
+Credentials are free but must be requested by email from api@hochbahn.de; the
+API is documented at https://gti.geofox.de/html/GTIHandbuch_p.html.
+
+Requested for https://github.com/NerdySoftPaw/openpublictransport/issues/61.
+"""
+
+import base64
+import hashlib
+import hmac
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Union
+from zoneinfo import ZoneInfo
+
+import aiohttp
+
+from ..const import PROVIDER_HVV_GTI
+from ..exceptions import AuthenticationError
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+GTI_BASE_URL = "https://gti.geofox.de/gti/public"
+
+# The API version the request bodies below are written against. The server
+# tailors its response to this number, so it is pinned rather than left to the
+# server default (which is the long-obsolete version 1).
+GTI_API_VERSION = 63
+
+# A line's type carries a granular value (`shortInfo`, and sometimes a granular
+# `simpleType`) plus a coarse `simpleType`. The granular one is authoritative;
+# the coarse one flattens U-Bahn, S-Bahn and AKN all into TRAIN, so it is only
+# consulted after the line name has had a chance to disambiguate.
+_GRANULAR_TYPE_MAP = {
+    "UBAHN": "subway",
+    "U": "subway",
+    "U-BAHN": "subway",
+    "SBAHN": "train",
+    "S": "train",
+    "S-BAHN": "train",
+    "AKN": "train",
+    "A": "train",
+    "RBAHN": "train",
+    "R": "train",
+    "FERNBAHN": "train",
+    "ZUG": "train",
+    "STADTBUS": "bus",
+    "METROBUS": "bus",
+    "SCHNELLBUS": "bus",
+    "NACHTBUS": "bus",
+    "XPRESSBUS": "bus",
+    "EILBUS": "bus",
+    "FAEHRE": "ferry",
+    "FÄHRE": "ferry",
+    "AST": "taxi",
+}
+
+_COARSE_TYPE_MAP = {
+    "BUS": "bus",
+    "TRAIN": "train",
+    "SHIP": "ferry",
+}
+
+
+def sign_request(password: str, body: bytes) -> str:
+    """Return the geofox-auth-signature for a request body.
+
+    HMAC-SHA1 over the UTF-8 request body, keyed with the password, Base64
+    encoded — GTI handbook §3 "Authentifikation".
+    """
+    digest = hmac.new(password.encode("utf-8"), body, hashlib.sha1).digest()
+    return base64.b64encode(digest).decode("ascii")
+
+
+def _transport_type(line: Dict[str, Any]) -> str:
+    """Map a GTI line to a unified transportation type."""
+    line_type = line.get("type") if isinstance(line.get("type"), dict) else {}
+    short_info = str(line_type.get("shortInfo") or "").strip().upper()
+    simple_type = str(line_type.get("simpleType") or "").strip().upper()
+
+    for value in (short_info, simple_type):
+        if value in _GRANULAR_TYPE_MAP:
+            return _GRANULAR_TYPE_MAP[value]
+
+    # Only the coarse type is left, which lumps U-Bahn, S-Bahn and AKN together
+    # under TRAIN. Hamburg's line names are unambiguous, so use them first.
+    name = str(line.get("name") or "").strip().upper()
+    if len(name) > 1 and name[1].isdigit():
+        if name[0] == "U":
+            return "subway"
+        if name[0] in ("S", "A", "R"):
+            return "train"
+
+    if simple_type in _COARSE_TYPE_MAP:
+        return _COARSE_TYPE_MAP[simple_type]
+
+    _LOGGER.debug("HVV GTI: unmapped line type %s for line %r", line_type, line.get("name"))
+    return "unknown"
+
+
+class HVVGTIProvider(BaseProvider):
+    """HVV via the official Geofox GTI API (real-time)."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_HVV_GTI
+
+    @property
+    def provider_name(self) -> str:
+        return "HVV Geofox GTI (Hamburg)"
+
+    @property
+    def requires_api_key(self) -> bool:
+        return True
+
+    def get_timezone(self) -> str:
+        return "Europe/Berlin"
+
+    # ── transport ────────────────────────────────────────────────────────────
+
+    async def _post(self, method: str, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Call one GTI method, signing the exact bytes that are sent.
+
+        The signature covers the serialized body, so the body is serialized
+        once and handed to aiohttp as raw bytes — letting aiohttp re-serialize
+        it via ``json=`` could change the bytes and invalidate the signature.
+        """
+        if not self.api_key or not self.api_key_secondary:
+            _LOGGER.error("%s: username and password are required", self.provider_name)
+            raise AuthenticationError(f"{self.provider_name}: username and password are required")
+
+        body = json.dumps(
+            {"version": GTI_API_VERSION, "language": "de", **payload},
+            ensure_ascii=False,
+            separators=(",", ":"),
+        ).encode("utf-8")
+
+        headers = {
+            "geofox-auth-type": "HmacSHA1",
+            "geofox-auth-user": self.api_key,
+            "geofox-auth-signature": sign_request(self.api_key_secondary, body),
+            "Content-Type": "application/json;charset=UTF-8",
+            "Accept": "application/json",
+            "X-Platform": "web",
+        }
+
+        url = f"{GTI_BASE_URL}/{method}"
+        try:
+            async with self.session.post(
+                url, data=body, headers=headers, timeout=aiohttp.ClientTimeout(total=15)
+            ) as response:
+                if response.status in (401, 403):
+                    raise AuthenticationError(
+                        f"{self.provider_name}: authentication failed (HTTP {response.status}) — "
+                        "check the GTI username and password"
+                    )
+                if response.status != 200:
+                    _LOGGER.warning("%s: %s → HTTP %s", self.provider_name, method, response.status)
+                    return None
+
+                data = await response.json(content_type=None)
+        except AuthenticationError:
+            raise
+        except aiohttp.ClientError as exc:
+            _LOGGER.warning("%s: %s request failed: %s", self.provider_name, method, exc)
+            return None
+        except Exception as exc:
+            _LOGGER.warning("%s: %s error: %s", self.provider_name, method, exc)
+            return None
+
+        if not isinstance(data, dict):
+            _LOGGER.warning("%s: %s returned %s, expected an object", self.provider_name, method, type(data))
+            return None
+
+        return_code = data.get("returnCode")
+        if return_code != "OK":
+            # GTI signals a bad key with a return code rather than an HTTP status.
+            if return_code in ("ERROR_COMM", "ERROR_TEXT") and "auth" in str(data.get("errorDevInfo", "")).lower():
+                raise AuthenticationError(f"{self.provider_name}: {data.get('errorText') or return_code}")
+            _LOGGER.warning(
+                "%s: %s returned %s — %s (%s)",
+                self.provider_name,
+                method,
+                return_code,
+                data.get("errorText") or "no message",
+                data.get("errorDevInfo") or "",
+            )
+            return None
+
+        return data
+
+    # ── stop search ──────────────────────────────────────────────────────────
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        """Search stations via the checkName method."""
+        data = await self._post(
+            "checkName",
+            {
+                "theName": {"name": search_term, "type": "STATION"},
+                "maxList": 25,
+                "coordinateType": "EPSG_4326",
+            },
+        )
+        if not data:
+            return []
+
+        stops = []
+        for result in data.get("results") or []:
+            if not isinstance(result, dict) or result.get("type") != "STATION" or not result.get("id"):
+                continue
+            stops.append(
+                {
+                    "id": result["id"],
+                    "name": result.get("name", ""),
+                    "place": result.get("city", ""),
+                    "area_type": "stop",
+                }
+            )
+        return stops
+
+    # ── departures ───────────────────────────────────────────────────────────
+
+    async def fetch_departures(
+        self,
+        station_id: Optional[str],
+        place_dm: str,
+        name_dm: str,
+        departures_limit: int,
+    ) -> Optional[Dict[str, Any]]:
+        """Fetch a departure board via the departureList method."""
+        if not station_id:
+            _LOGGER.warning("%s: a station ID is required", self.provider_name)
+            return None
+
+        now = datetime.now(ZoneInfo(self.get_timezone()))
+        data = await self._post(
+            "departureList",
+            {
+                "station": {"id": station_id, "type": "STATION"},
+                "time": {"date": now.strftime("%d.%m.%Y"), "time": now.strftime("%H:%M")},
+                "maxList": max(departures_limit, 5),
+                "maxTimeOffset": 200,
+                "useRealtime": True,
+                "returnFilters": False,
+                "coordinateType": "EPSG_4326",
+            },
+        )
+        if not data:
+            return None
+
+        # Departures are offsets from the board's own reference time, not
+        # absolute timestamps, so it has to be resolved here while we still
+        # have the response that produced them.
+        reference = self._reference_time(data.get("time"), now)
+
+        stop_events = []
+        for departure in data.get("departures") or []:
+            event = self._to_stop_event(departure, reference)
+            if event:
+                stop_events.append(event)
+
+        stop_events.sort(key=lambda event: event["estimated"])
+        return {"stopEvents": stop_events[:departures_limit]}
+
+    def _reference_time(self, gti_time: Any, fallback: datetime) -> datetime:
+        """Parse the response's GTITime, falling back to the request time."""
+        if isinstance(gti_time, dict) and gti_time.get("date") and gti_time.get("time"):
+            try:
+                return datetime.strptime(
+                    f"{gti_time['date']} {gti_time['time']}", "%d.%m.%Y %H:%M"
+                ).replace(tzinfo=ZoneInfo(self.get_timezone()))
+            except ValueError:
+                _LOGGER.debug("%s: unparseable reference time %s", self.provider_name, gti_time)
+        return fallback
+
+    def _to_stop_event(self, departure: Any, reference: datetime) -> Optional[Dict[str, Any]]:
+        """Normalise one GTI departure into this provider's stop-event shape."""
+        if not isinstance(departure, dict):
+            return None
+
+        line = departure.get("line") if isinstance(departure.get("line"), dict) else {}
+        time_offset = departure.get("timeOffset")
+        if not isinstance(time_offset, int):
+            _LOGGER.debug("%s: departure without a timeOffset: %s", self.provider_name, departure)
+            return None
+
+        # planned = board reference + timeOffset; the real-time deviation is a
+        # separate value in seconds on top (GTI handbook §2.4.2).
+        delay_seconds = departure.get("delay") if isinstance(departure.get("delay"), int) else 0
+        planned = reference + timedelta(minutes=time_offset)
+        estimated = planned + timedelta(seconds=delay_seconds)
+
+        platform = departure.get("realtimePlatform") or departure.get("platform") or ""
+        planned_platform = departure.get("platform") or ""
+
+        notices = []
+        for attribute in departure.get("attributes") or []:
+            if isinstance(attribute, dict):
+                text = attribute.get("value") or attribute.get("title") or ""
+                if text:
+                    notices.append(str(text).strip())
+        if departure.get("cancelled"):
+            notices.append("Fahrt fällt aus")
+        if departure.get("extra"):
+            notices.append("Verstärkerfahrt")
+
+        return {
+            "line": str(line.get("name") or ""),
+            "destination": str(line.get("direction") or "Unknown"),
+            "transportType": _transport_type(line),
+            "planned": planned,
+            "estimated": estimated,
+            "delaySeconds": delay_seconds,
+            "isRealtime": departure.get("delay") is not None,
+            "platform": str(platform),
+            "plannedPlatform": str(planned_platform),
+            "cancelled": bool(departure.get("cancelled")),
+            "notices": notices or None,
+        }
+
+    def parse_departure(
+        self, stop: Dict[str, Any], tz: Union[ZoneInfo, Any], now: datetime
+    ) -> Optional[UnifiedDeparture]:
+        """Build a UnifiedDeparture from a stop event produced above."""
+        try:
+            planned = stop["planned"].astimezone(tz)
+            estimated = stop["estimated"].astimezone(tz)
+
+            platform = stop.get("platform") or ""
+            planned_platform = stop.get("plannedPlatform") or ""
+            platform_changed = bool(platform and planned_platform and platform != planned_platform)
+
+            return UnifiedDeparture(
+                line=stop.get("line", ""),
+                destination=stop.get("destination", "Unknown"),
+                departure_time=estimated.strftime("%H:%M"),
+                planned_time=planned.strftime("%H:%M"),
+                delay=int(stop.get("delaySeconds", 0) / 60),
+                platform=platform,
+                transportation_type=stop.get("transportType", "unknown"),
+                is_realtime=bool(stop.get("isRealtime")),
+                minutes_until_departure=max(0, int((estimated - now).total_seconds() / 60)),
+                departure_time_obj=estimated,
+                notices=stop.get("notices"),
+                planned_platform=planned_platform if platform_changed else None,
+                platform_changed=platform_changed,
+            )
+        except Exception as exc:
+            _LOGGER.debug("%s parse_departure error: %s", self.provider_name, exc)
+            return None

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/openpublictransport/providers/kvv.py

@@ -31,8 +31,9 @@ class KVVProvider(EFABaseProvider):
     def get_transport_type_mapping(self) -> Dict[Any, str]:
         return KVV_TRANSPORTATION_TYPES
 
-    def get_platform_fn(self) -> Callable[[Dict[str, Any]], str]:
-        return lambda s: s.get("location", {}).get("disassembledName") or s.get("platformName", "")
+    # Platform comes from EFABaseProvider: location.properties.platform, with
+    # location.disassembledName ("Gleis 3") still a fallback and now exposed
+    # separately as platform_name.
 
     def get_realtime_fn(self) -> Callable[[Dict[str, Any], Optional[str], Optional[str]], bool]:
         return lambda s, est, plan: s.get("isRealtimeControlled", False)

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/python_openpublictransport.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-openpublictransport
-Version: 0.1.14
+Version: 0.1.16
 Summary: Python library for public transport APIs (EFA, OTP2, TRIAS, FPTF, HAFAS, GTFS-RT)
 License: MIT
 Requires-Python: >=3.11

{python_openpublictransport-0.1.14 → python_openpublictransport-0.1.16}/src/python_openpublictransport.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ src/openpublictransport/providers/gtfsde.py
 src/openpublictransport/providers/hafas_base.py
 src/openpublictransport/providers/hafas_mgate_base.py
 src/openpublictransport/providers/hvv.py
+src/openpublictransport/providers/hvv_gti.py
 src/openpublictransport/providers/irishrail.py
 src/openpublictransport/providers/kvv.py
 src/openpublictransport/providers/mobiliteit_lu.py
@@ -56,9 +57,11 @@ src/python_openpublictransport.egg-info/SOURCES.txt
 src/python_openpublictransport.egg-info/dependency_links.txt
 src/python_openpublictransport.egg-info/requires.txt
 src/python_openpublictransport.egg-info/top_level.txt
+tests/test_efa_platform.py
 tests/test_entur.py
 tests/test_hafas_base.py
 tests/test_hafas_mgate.py
+tests/test_hvv_gti.py
 tests/test_national_rail.py
 tests/test_national_rail_parse.py
 tests/test_national_rail_static.py