python-openpublictransport 0.1.12__tar.gz → 0.1.15__tar.gz

{python_openpublictransport-0.1.12 → python_openpublictransport-0.1.15}/PKG-INFO

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

{python_openpublictransport-0.1.12 → python_openpublictransport-0.1.15}/pyproject.toml

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

{python_openpublictransport-0.1.12 → python_openpublictransport-0.1.15}/src/openpublictransport/const.py

@@ -31,6 +31,13 @@ PROVIDER_OPT = "openpublictransport"
 PROVIDER_OTP_CUSTOM = "otp_custom"
 PROVIDER_NATIONAL_RAIL = "national_rail"
 PROVIDER_REJSEPLANEN = "rejseplanen"
+PROVIDER_NS_NL = "ns_nl"
+PROVIDER_MOBILITEIT_LU = "mobiliteit_lu"
+PROVIDER_ENTUR_NO = "entur_no"
+PROVIDER_BART_US = "bart_us"
+PROVIDER_DART_US = "dart_us"
+PROVIDER_IRISHRAIL_IE = "irishrail_ie"
+PROVIDER_TPG_CH = "tpg_ch"
 
 # API base URLs
 API_BASE_URL_VRR = "https://openservice-test.vrr.de/static03/XML_DM_REQUEST"

{python_openpublictransport-0.1.12 → python_openpublictransport-0.1.15}/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.12 → python_openpublictransport-0.1.15}/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.12 → python_openpublictransport-0.1.15}/src/openpublictransport/providers/__init__.py

@@ -34,6 +34,13 @@ from ..const import (
     PROVIDER_VVS,
     PROVIDER_NATIONAL_RAIL,
     PROVIDER_REJSEPLANEN,
+    PROVIDER_NS_NL,
+    PROVIDER_MOBILITEIT_LU,
+    PROVIDER_ENTUR_NO,
+    PROVIDER_BART_US,
+    PROVIDER_DART_US,
+    PROVIDER_IRISHRAIL_IE,
+    PROVIDER_TPG_CH,
 )
 from .avv import AVVProvider
 from .base import BaseProvider
@@ -65,6 +72,13 @@ from .vvo import VVOProvider
 from .vvs import VVSProvider
 from .national_rail import NationalRailProvider
 from .rejseplanen import RejseplanenProvider
+from .ns import NSProvider
+from .mobiliteit_lu import MobiliteitLuProvider
+from .entur import EnturProvider
+from .bart import BARTProvider
+from .dart import DARTProvider
+from .irishrail import IrishRailProvider
+from .tpg import TPGProvider
 
 _PROVIDER_REGISTRY: Dict[str, Type[BaseProvider]] = {}
 
@@ -140,3 +154,10 @@ register_provider(PROVIDER_OPT, OPTProvider)
 register_provider(PROVIDER_OTP_CUSTOM, OTPCustomProvider)
 register_provider(PROVIDER_NATIONAL_RAIL, NationalRailProvider)
 register_provider(PROVIDER_REJSEPLANEN, RejseplanenProvider)
+register_provider(PROVIDER_NS_NL, NSProvider)
+register_provider(PROVIDER_MOBILITEIT_LU, MobiliteitLuProvider)
+register_provider(PROVIDER_ENTUR_NO, EnturProvider)
+register_provider(PROVIDER_BART_US, BARTProvider)
+register_provider(PROVIDER_DART_US, DARTProvider)
+register_provider(PROVIDER_IRISHRAIL_IE, IrishRailProvider)
+register_provider(PROVIDER_TPG_CH, TPGProvider)

python_openpublictransport-0.1.15/src/openpublictransport/providers/bart.py

@@ -0,0 +1,26 @@
+"""BART — Bay Area Rapid Transit (USA) provider.
+
+Modern HAFAS ``mgate.exe`` gateway; unsigned. Config from
+public-transport/transport-apis (``us/bart-hafas-mgate``).
+"""
+
+from ..const import PROVIDER_BART_US
+from .hafas_mgate_base import HafasMgateBaseProvider
+
+
+class BARTProvider(HafasMgateBaseProvider):
+    """BART (San Francisco Bay Area) via HAFAS mgate."""
+
+    mgate_endpoint = "https://planner.bart.gov/bin/mgate.exe"
+    mgate_auth = {"type": "AID", "aid": "kEwHkFUCIL500dym"}
+    mgate_client = {"id": "BART", "type": "WEB", "name": "webapp", "l": "vs_webapp"}
+    mgate_ver = "1.40"
+    timezone = "America/Los_Angeles"
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_BART_US
+
+    @property
+    def provider_name(self) -> str:
+        return "BART (San Francisco Bay Area)"

python_openpublictransport-0.1.15/src/openpublictransport/providers/dart.py

@@ -0,0 +1,29 @@
+"""DART — Des Moines Area Rapid Transit (Iowa, USA) provider.
+
+Modern HAFAS ``mgate.exe`` gateway; unsigned. Config from
+public-transport/transport-apis (``us/dart-hafas-mgate``). Note: that catalogue
+entry is titled "Dallas Area Rapid Transit", but the endpoint actually serves
+**Des Moines, Iowa** (DART Central Station, DSM/WDM/Ankeny/Johnston stops) —
+verified live. Iowa is Central time, so the timezone is unchanged.
+"""
+
+from ..const import PROVIDER_DART_US
+from .hafas_mgate_base import HafasMgateBaseProvider
+
+
+class DARTProvider(HafasMgateBaseProvider):
+    """DART (Des Moines, Iowa) via HAFAS mgate."""
+
+    mgate_endpoint = "https://dart.hafas.de/bin/mgate.exe"
+    mgate_auth = {"type": "AID", "aid": "XNFGL2aSkxfDeK8N4waOZnsdJ"}
+    mgate_client = {"id": "DART", "type": "WEB", "name": "webapp", "l": "vs_webapp"}
+    mgate_ver = "1.35"
+    timezone = "America/Chicago"
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_DART_US
+
+    @property
+    def provider_name(self) -> str:
+        return "DART (Des Moines)"

{python_openpublictransport-0.1.12 → python_openpublictransport-0.1.15}/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.15/src/openpublictransport/providers/entur.py

@@ -0,0 +1,207 @@
+"""Entur (Norway) provider implementation.
+
+Norway's national journey planner. Departures come from Entur's OTP
+**transmodel** GraphQL API and stop search from Entur's geocoder. Both are
+keyless; Entur only requires an identifying ``ET-Client-Name`` header.
+
+  * geocoder    https://api.entur.io/geocoder/v1/autocomplete
+  * journeys    https://api.entur.io/journey-planner/v3/graphql
+
+Catalogued by public-transport/transport-apis as ``no/entur-otp``.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import quote
+from zoneinfo import ZoneInfo
+
+import aiohttp
+
+from ..const import PROVIDER_ENTUR_NO
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+GEOCODER_URL = "https://api.entur.io/geocoder/v1/autocomplete"
+JOURNEY_PLANNER_URL = "https://api.entur.io/journey-planner/v3/graphql"
+CLIENT_NAME = "nerdysoftpaw-openpublictransport"
+
+# Transmodel transportMode (lower-case) -> unified transport type.
+MODE_MAPPING = {
+    "rail": "train",
+    "coach": "bus",
+    "bus": "bus",
+    "trolleybus": "bus",
+    "tram": "tram",
+    "metro": "subway",
+    "water": "ferry",
+    "ferry": "ferry",
+    "funicular": "train",
+    "cableway": "tram",
+    "monorail": "subway",
+    "taxi": "taxi",
+}
+
+_DEPARTURES_QUERY = (
+    "query($id:String!,$n:Int!){"
+    "stopPlace(id:$id){"
+    "estimatedCalls(numberOfDepartures:$n,timeRange:7200){"
+    "aimedDepartureTime expectedDepartureTime realtime cancellation "
+    "destinationDisplay{frontText} quay{publicCode} "
+    "serviceJourney{line{publicCode transportMode}}"
+    "}}}"
+)
+
+
+def _parse_dt(s: Optional[str]) -> Optional[datetime]:
+    try:
+        return datetime.fromisoformat(s) if s else None
+    except (ValueError, TypeError):
+        return None
+
+
+class EnturProvider(BaseProvider):
+    """Entur (Norway) via transmodel GraphQL + Entur geocoder."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_ENTUR_NO
+
+    @property
+    def provider_name(self) -> str:
+        return "Entur (Norge)"
+
+    def get_timezone(self) -> str:
+        return "Europe/Oslo"
+
+    def _headers(self) -> Dict[str, str]:
+        return {"ET-Client-Name": CLIENT_NAME, "Accept": "application/json"}
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        url = (
+            f"{GEOCODER_URL}?text={quote(search_term, safe='')}"
+            "&size=12&lang=en&layers=venue"
+        )
+        try:
+            async with self.session.get(
+                url, headers=self._headers(), timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                if response.status != 200:
+                    _LOGGER.error("Entur geocoder returned status %s", response.status)
+                    return []
+                data = await response.json()
+        except Exception as e:  # noqa: BLE001
+            _LOGGER.error("Error searching Entur stops: %s", e)
+            return []
+
+        return self._stops_from_geocoder(data)
+
+    @staticmethod
+    def _stops_from_geocoder(data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        results: List[Dict[str, Any]] = []
+        for feature in data.get("features", []):
+            props = feature.get("properties", {}) if isinstance(feature, dict) else {}
+            stop_id = str(props.get("id") or "")
+            # Only stop places have a departure board.
+            if not stop_id.startswith("NSR:StopPlace:"):
+                continue
+            name = props.get("label") or props.get("name") or ""
+            if not name:
+                continue
+            results.append(
+                {
+                    "id": stop_id,
+                    "name": name,
+                    "place": props.get("locality") or "",
+                    "area_type": "stop",
+                }
+            )
+        return results
+
+    async def fetch_departures(
+        self,
+        station_id: Optional[str],
+        place_dm: str,
+        name_dm: str,
+        departures_limit: int,
+    ) -> Optional[Dict[str, Any]]:
+        if not station_id:
+            _LOGGER.warning("Entur provider requires a station_id")
+            return None
+
+        payload = {
+            "query": _DEPARTURES_QUERY,
+            "variables": {"id": station_id, "n": departures_limit},
+        }
+        try:
+            async with self.session.post(
+                JOURNEY_PLANNER_URL,
+                json=payload,
+                headers=self._headers(),
+                timeout=aiohttp.ClientTimeout(total=15),
+            ) as response:
+                if response.status != 200:
+                    _LOGGER.warning("Entur journey planner returned status %s", response.status)
+                    return None
+                data = await response.json()
+        except aiohttp.ClientError as e:
+            _LOGGER.warning("Entur journey planner request failed: %s", e)
+            return None
+        except Exception as e:  # noqa: BLE001
+            _LOGGER.warning("Entur journey planner error: %s", e)
+            return None
+
+        stop_place = (data.get("data") or {}).get("stopPlace")
+        if not stop_place:
+            return {"stopEvents": []}
+        return {"stopEvents": stop_place.get("estimatedCalls") or []}
+
+    def parse_departure(
+        self, stop: Dict[str, Any], tz: Union[ZoneInfo, Any], now: datetime
+    ) -> Optional[UnifiedDeparture]:
+        try:
+            aimed = _parse_dt(stop.get("aimedDepartureTime"))
+            if not aimed:
+                return None
+            expected = _parse_dt(stop.get("expectedDepartureTime")) or aimed
+
+            planned_local = aimed.astimezone(tz)
+            when_local = expected.astimezone(tz)
+            delay_minutes = int((when_local - planned_local).total_seconds() / 60)
+
+            line_info = (stop.get("serviceJourney") or {}).get("line") or {}
+            line = line_info.get("publicCode") or ""
+            mode = (line_info.get("transportMode") or "").lower()
+            transport_type = MODE_MAPPING.get(mode, "unknown")
+
+            destination = (stop.get("destinationDisplay") or {}).get("frontText") or "Unknown"
+            platform = (stop.get("quay") or {}).get("publicCode") or ""
+
+            minutes_until = max(0, int((when_local - now).total_seconds() / 60))
+
+            notices = None
+            if stop.get("cancellation"):
+                notices = ["Cancelled"]
+
+            return UnifiedDeparture(
+                line=line,
+                destination=destination,
+                departure_time=when_local.strftime("%H:%M"),
+                planned_time=planned_local.strftime("%H:%M"),
+                delay=delay_minutes,
+                platform=platform,
+                transportation_type=transport_type,
+                is_realtime=bool(stop.get("realtime")),
+                minutes_until_departure=minutes_until,
+                departure_time_obj=when_local,
+                description=None,
+                agency=None,
+                notices=notices,
+                planned_platform=None,
+                platform_changed=False,
+            )
+        except Exception as e:  # noqa: BLE001
+            _LOGGER.debug("Error parsing Entur departure: %s", e)
+            return None