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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-openpublictransport
-Version: 0.1.12
+Version: 0.1.14
 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.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-openpublictransport"
-version = "0.1.12"
+version = "0.1.14"
 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.14}/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.14}/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.14/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.14/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.14/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