python-openpublictransport 0.1.0__py3-none-any.whl

openpublictransport/providers/nta.py

@@ -0,0 +1,288 @@
+"""NTA (National Transport Authority, Ireland) provider implementation."""
+
+import asyncio
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional, Union
+from zoneinfo import ZoneInfo
+
+import aiohttp
+from aiohttp import ClientConnectorError
+
+from ..const import API_BASE_URL_NTA_GTFSR, NTA_TRANSPORTATION_TYPES, PROVIDER_NTA_IE
+from ..models import UnifiedDeparture
+from ..parsers import parse_departure_generic
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class NTAProvider(BaseProvider):
+    """NTA (National Transport Authority, Ireland) provider."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_NTA_IE
+
+    @property
+    def provider_name(self) -> str:
+        return "NTA (Ireland)"
+
+    @property
+    def requires_api_key(self) -> bool:
+        return True
+
+    def get_timezone(self) -> str:
+        return "Europe/Dublin"
+
+    async def cleanup(self) -> None:
+        pass
+
+    async def fetch_departures(
+        self,
+        station_id: Optional[str],
+        place_dm: str,
+        name_dm: str,
+        departures_limit: int,
+    ) -> Optional[Dict[str, Any]]:
+        if not self.api_key:
+            _LOGGER.error("NTA API key is required")
+            return None
+
+        if not station_id:
+            _LOGGER.error("NTA requires a station ID (stop_id)")
+            return None
+
+        url = f"{API_BASE_URL_NTA_GTFSR}/v2/TripUpdates"
+        params = {"format": "json"}
+
+        headers = {
+            "User-Agent": "Mozilla/5.0 (compatible; OpenPublicTransport NTA)",
+            "x-api-key": self.api_key,
+        }
+
+        max_retries = 3
+        current_api_key = self.api_key
+        for attempt in range(1, max_retries + 1):
+            try:
+                headers["x-api-key"] = current_api_key
+
+                async with self.session.get(
+                    url, params=params, headers=headers, timeout=aiohttp.ClientTimeout(total=15)
+                ) as response:
+                    if response.status == 200:
+                        try:
+                            json_data = await response.json()
+
+                            if not isinstance(json_data, dict):
+                                _LOGGER.warning("NTA API returned non-dict response: %s", type(json_data))
+                                return None
+
+                            entities = json_data.get("entity", [])
+                            if not isinstance(entities, list):
+                                _LOGGER.debug("NTA API response missing or invalid 'entity' field")
+                                return {"stopEvents": []}
+
+                            entity_count = len(entities)
+                            if entity_count == 0:
+                                _LOGGER.debug("NTA API returned empty entities list")
+                                return {"stopEvents": []}
+
+                            _LOGGER.info(
+                                "NTA API returned %d entities (processing for stop %s)", entity_count, station_id
+                            )
+
+                            stop_events = []
+                            target_stop_id = station_id
+                            max_departures = departures_limit * 3
+                            processed_entities = 0
+
+                            now = datetime.now(timezone.utc)
+
+                            for entity in entities:
+                                if not isinstance(entity, dict):
+                                    continue
+
+                                trip_update = entity.get("trip_update")
+                                if not isinstance(trip_update, dict):
+                                    continue
+
+                                stop_time_updates = trip_update.get("stop_time_update", [])
+                                if not isinstance(stop_time_updates, list) or len(stop_time_updates) == 0:
+                                    continue
+
+                                matching_stop_time = None
+                                for stop_time_update in stop_time_updates:
+                                    if not isinstance(stop_time_update, dict):
+                                        continue
+                                    stop_id = stop_time_update.get("stop_id")
+                                    if stop_id == target_stop_id:
+                                        matching_stop_time = stop_time_update
+                                        break
+
+                                if matching_stop_time is None:
+                                    continue
+
+                                trip = trip_update.get("trip", {})
+                                if not isinstance(trip, dict):
+                                    continue
+
+                                stop_time_update = matching_stop_time
+
+                                route_id = trip.get("route_id", "")
+                                trip_id = trip.get("trip_id", "")
+                                stop_id = stop_time_update.get("stop_id", target_stop_id)
+
+                                route_short_name = route_id.split("_")[0] if route_id else ""
+
+                                route_type = 3
+                                if route_short_name and route_short_name.lower() in ["red", "green", "luas"]:
+                                    route_type = 0
+
+                                departure = stop_time_update.get("departure", {})
+                                arrival = stop_time_update.get("arrival", {})
+                                delay_seconds = departure.get("delay") or arrival.get("delay") or 0
+
+                                schedule_relationship = stop_time_update.get("schedule_relationship", "SCHEDULED")
+                                if schedule_relationship in ["CANCELED", "SKIPPED"]:
+                                    continue
+
+                                destination = route_short_name or "Unknown"
+
+                                departure_time = departure.get("time")
+                                arrival_time = arrival.get("time")
+
+                                if departure_time:
+                                    try:
+                                        planned_time = datetime.fromtimestamp(departure_time, tz=now.tzinfo)
+                                        estimated_time = planned_time + timedelta(seconds=delay_seconds)
+                                    except (ValueError, OSError):
+                                        planned_time = now
+                                        estimated_time = now + timedelta(seconds=delay_seconds)
+                                elif arrival_time:
+                                    try:
+                                        planned_time = datetime.fromtimestamp(arrival_time, tz=now.tzinfo)
+                                        estimated_time = planned_time + timedelta(seconds=delay_seconds)
+                                    except (ValueError, OSError):
+                                        planned_time = now
+                                        estimated_time = now + timedelta(seconds=delay_seconds)
+                                else:
+                                    planned_time = now
+                                    estimated_time = now + timedelta(seconds=delay_seconds)
+
+                                planned_time_str = planned_time.strftime("%Y-%m-%dT%H:%M:%S%z")
+                                estimated_time_str = estimated_time.strftime("%Y-%m-%dT%H:%M:%S%z")
+
+                                platform = (
+                                    stop_time_update.get("platform_code") or stop_time_update.get("platform") or ""
+                                )
+
+                                stop_event = {
+                                    "departureTimePlanned": planned_time_str,
+                                    "departureTimeEstimated": estimated_time_str,
+                                    "transportation": {
+                                        "number": route_short_name,
+                                        "description": "",
+                                        "destination": {"name": destination},
+                                        "product": {"class": route_type},
+                                    },
+                                    "platform": {"name": platform},
+                                    "realtimeStatus": ["MONITORED"] if delay_seconds != 0 else [],
+                                    "route_id": route_id,
+                                    "trip_id": trip_id,
+                                    "stop_id": stop_id,
+                                    "delay_seconds": delay_seconds,
+                                }
+                                stop_events.append(stop_event)
+                                processed_entities += 1
+
+                                if len(stop_events) >= max_departures:
+                                    break
+
+                            _LOGGER.info(
+                                "NTA: Processed %d/%d entities, found %d departures for stop %s",
+                                processed_entities,
+                                entity_count,
+                                len(stop_events),
+                                target_stop_id,
+                            )
+                            return {"stopEvents": stop_events}
+
+                        except (ValueError, aiohttp.ContentTypeError) as e:
+                            _LOGGER.warning("NTA API returned invalid JSON: %s", e)
+                            return None
+                        except Exception as e:
+                            _LOGGER.warning("NTA API JSON parsing failed: %s", e, exc_info=True)
+                            return None
+                    elif response.status == 404:
+                        _LOGGER.warning("NTA API endpoint not found (404)")
+                        return None
+                    elif response.status == 401:
+                        if self.api_key_secondary and current_api_key == self.api_key:
+                            _LOGGER.info("NTA Primary API key failed (401), trying Secondary key...")
+                            current_api_key = self.api_key_secondary
+                            continue
+                        _LOGGER.warning("NTA API authentication failed (401) - check API key(s)")
+                        return None
+                    elif response.status >= 500:
+                        _LOGGER.warning(
+                            "NTA API server error (status %s) on attempt %d/%d",
+                            response.status,
+                            attempt,
+                            max_retries,
+                        )
+                        if attempt < max_retries:
+                            await asyncio.sleep(2**attempt)
+                            continue
+                        return None
+                    else:
+                        _LOGGER.warning(
+                            "NTA API returned status %s on attempt %d/%d", response.status, attempt, max_retries
+                        )
+                        if attempt < max_retries:
+                            await asyncio.sleep(2**attempt)
+                            continue
+
+            except asyncio.TimeoutError:
+                _LOGGER.warning("NTA API timeout on attempt %d/%d", attempt, max_retries)
+                if attempt < max_retries:
+                    await asyncio.sleep(2**attempt)
+                    continue
+            except ClientConnectorError as e:
+                _LOGGER.warning("NTA API connection error on attempt %d/%d: %s", attempt, max_retries, e)
+                if attempt < max_retries:
+                    await asyncio.sleep(2**attempt)
+                    continue
+            except Exception as e:
+                _LOGGER.warning("NTA API attempt %d/%d failed: %s", attempt, max_retries, e)
+                if attempt < max_retries:
+                    await asyncio.sleep(2**attempt)
+                    continue
+
+        return None
+
+    def parse_departure(
+        self, stop: Dict[str, Any], tz: Union[ZoneInfo, Any], now: datetime
+    ) -> Optional[UnifiedDeparture]:
+        transportation = stop.get("transportation", {})
+        product = transportation.get("product", {})
+        route_type = product.get("class", 3)
+        transport_type = NTA_TRANSPORTATION_TYPES.get(route_type, "bus")
+
+        return parse_departure_generic(
+            stop,
+            tz,
+            now,
+            get_transport_type_fn=lambda t: transport_type,
+            get_platform_fn=lambda s: (
+                s.get("platform", {}).get("name", "")
+                if isinstance(s.get("platform"), dict)
+                else str(s.get("platform", ""))
+            ),
+            get_realtime_fn=lambda s, est, plan: "MONITORED" in s.get("realtimeStatus", []),
+        )
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        """NTA stop search is not available without GTFS Static data."""
+        _LOGGER.warning("NTA stop search is not available without GTFS Static data. Please enter the stop_id directly.")
+        return []

openpublictransport/providers/nvbw.py

@@ -0,0 +1,44 @@
+"""NVBW (Nahverkehrsgesellschaft Baden-Württemberg) provider implementation."""
+
+from typing import Any, Callable, Dict, Optional
+
+from ..const import PROVIDER_NVBW
+from .efa_base import EFABaseProvider
+
+
+class NVBWProvider(EFABaseProvider):
+    """NVBW (Baden-Württemberg) provider."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_NVBW
+
+    @property
+    def provider_name(self) -> str:
+        return "NVBW (Baden-Württemberg)"
+
+    @property
+    def dm_base_url(self) -> str:
+        return "https://www.efa-bw.de/nvbw/XML_DM_REQUEST"
+
+    @property
+    def sf_base_url(self) -> str:
+        return "https://www.efa-bw.de/nvbw/XML_STOPFINDER_REQUEST"
+
+    def get_timezone(self) -> str:
+        return "Europe/Berlin"
+
+    def get_transport_type_mapping(self) -> Dict[Any, str]:
+        return {
+            0: "train",  # High-speed trains (ICE, IC, EC)
+            1: "train",  # Regional trains (RE, RB)
+            4: "tram",  # Tram/Streetcar
+            5: "bus",  # City bus
+            6: "bus",  # Regional bus
+            7: "bus",  # Express bus
+            8: "bus",  # Night bus
+            13: "train",  # Regionalzug (RE)
+        }
+
+    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

openpublictransport/providers/nwl.py

@@ -0,0 +1,46 @@
+"""NWL (Nahverkehr Westfalen-Lippe) provider implementation."""
+
+from typing import Any, Callable, Dict, Optional
+
+from ..const import PROVIDER_NWL
+from .efa_base import EFABaseProvider
+
+
+class NWLProvider(EFABaseProvider):
+    """NWL (Westfalen-Lippe) provider."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_NWL
+
+    @property
+    def provider_name(self) -> str:
+        return "NWL (Westfalen-Lippe)"
+
+    @property
+    def dm_base_url(self) -> str:
+        return "https://westfalenfahrplan.de/nwl-efa/XML_DM_REQUEST"
+
+    @property
+    def sf_base_url(self) -> str:
+        return "https://westfalenfahrplan.de/nwl-efa/XML_STOPFINDER_REQUEST"
+
+    def get_timezone(self) -> str:
+        return "Europe/Berlin"
+
+    def get_transport_type_mapping(self) -> Dict[Any, str]:
+        return {
+            0: "train",  # High-speed trains (ICE, IC, EC)
+            1: "train",  # Regional trains (RE, RB)
+            2: "subway",  # U-Bahn
+            3: "subway",  # U-Bahn variant
+            4: "tram",  # Tram/Streetcar
+            5: "bus",  # City bus
+            6: "bus",  # Regional bus
+            7: "bus",  # Express bus
+            8: "bus",  # Night bus
+            13: "train",  # Regionalzug (RE)
+        }
+
+    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

openpublictransport/providers/oebb.py

@@ -0,0 +1,182 @@
+"""ÖBB (Österreichische Bundesbahnen) provider implementation."""
+
+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_OEBB
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+API_BASE = "https://oebb.macistry.com/api"
+
+PRODUCT_MAPPING = {
+    "nationalExpress": "train",
+    "national": "train",
+    "interregional": "train",
+    "regional": "train",
+    "suburban": "train",
+    "subway": "subway",
+    "tram": "tram",
+    "bus": "bus",
+    "ferry": "ferry",
+    "onCall": "bus",
+}
+
+
+def _parse_dt(s: str) -> Optional[datetime]:
+    try:
+        return datetime.fromisoformat(s)
+    except (ValueError, TypeError):
+        return None
+
+
+class OeBBProvider(BaseProvider):
+    """ÖBB (Austria) provider using FPTF REST API."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_OEBB
+
+    @property
+    def provider_name(self) -> str:
+        return "ÖBB (Österreich)"
+
+    def get_timezone(self) -> str:
+        return "Europe/Vienna"
+
+    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("ÖBB provider requires a station_id")
+            return None
+
+        url = f"{API_BASE}/stops/{station_id}/departures?results={departures_limit}&duration=120"
+
+        try:
+            async with self.session.get(url, timeout=aiohttp.ClientTimeout(total=15)) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    if not isinstance(data, dict) or "departures" not in data:
+                        return {"stopEvents": []}
+                    return {"stopEvents": data["departures"]}
+                else:
+                    _LOGGER.warning("ÖBB API returned status %s", response.status)
+        except aiohttp.ClientError as e:
+            _LOGGER.warning("ÖBB API request failed: %s", e)
+        except Exception as e:
+            _LOGGER.warning("ÖBB API error: %s", e)
+
+        return None
+
+    def parse_departure(
+        self, stop: Dict[str, Any], tz: Union[ZoneInfo, Any], now: datetime
+    ) -> Optional[UnifiedDeparture]:
+        try:
+            when_str = stop.get("when") or stop.get("plannedWhen")
+            planned_str = stop.get("plannedWhen")
+            if not when_str or not planned_str:
+                return None
+
+            when = _parse_dt(when_str)
+            planned = _parse_dt(planned_str)
+            if not when or not planned:
+                return None
+
+            when_local = when.astimezone(tz)
+            planned_local = planned.astimezone(tz)
+
+            delay_seconds = stop.get("delay") or 0
+            delay_minutes = int(delay_seconds / 60)
+
+            line_info = stop.get("line", {})
+            line_name = line_info.get("name", "")
+            product = line_info.get("product", "")
+            transport_type = PRODUCT_MAPPING.get(product, "unknown")
+
+            destination_info = stop.get("destination", {})
+            destination = destination_info.get("name", stop.get("direction", "Unknown"))
+
+            platform = stop.get("platform") or ""
+            planned_platform = stop.get("plannedPlatform") or ""
+            platform_changed = bool(platform and planned_platform and platform != planned_platform)
+
+            time_diff = when_local - now
+            minutes_until = max(0, int(time_diff.total_seconds() / 60))
+
+            is_realtime = stop.get("prognosisType") is not None
+
+            notices = []
+            for remark in stop.get("remarks", []):
+                if isinstance(remark, dict) and remark.get("type") == "warning":
+                    text = remark.get("text") or remark.get("summary", "")
+                    if text:
+                        notices.append(text)
+
+            operator = line_info.get("operator", {})
+            agency = operator.get("name") if isinstance(operator, dict) else None
+
+            return UnifiedDeparture(
+                line=line_name,
+                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=is_realtime,
+                minutes_until_departure=minutes_until,
+                departure_time_obj=when_local,
+                description=stop.get("direction"),
+                agency=agency,
+                notices=notices if notices else None,
+                planned_platform=planned_platform if platform_changed else None,
+                platform_changed=platform_changed,
+            )
+        except Exception as e:
+            _LOGGER.debug("Error parsing ÖBB departure: %s", e)
+            return None
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        url = f"{API_BASE}/locations?query={quote(search_term, safe='')}&results=15"
+
+        try:
+            async with self.session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    if not isinstance(data, list):
+                        return []
+
+                    results = []
+                    for location in data:
+                        if not isinstance(location, dict):
+                            continue
+                        if location.get("type") != "stop":
+                            continue
+                        name = location.get("name", "")
+                        results.append(
+                            {
+                                "id": str(location.get("id", "")),
+                                "name": name,
+                                "place": "",
+                                "area_type": "stop",
+                            }
+                        )
+                    return results
+                else:
+                    _LOGGER.error("ÖBB API returned status %s", response.status)
+        except Exception as e:
+            _LOGGER.error("Error searching ÖBB stops: %s", e)
+
+        return []