python-openpublictransport 0.1.0__py3-none-any.whl

openpublictransport/providers/rmv.py

@@ -0,0 +1,272 @@
+"""RMV (Rhein-Main-Verkehrsverbund) 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_RMV
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+API_BASE = "https://www.rmv.de/hapi"
+
+PRODUCT_MAPPING = {
+    "ICE": "train",
+    "IC": "train",
+    "EC": "train",
+    "RE": "train",
+    "RB": "train",
+    "S": "train",
+    "U": "subway",
+    "Tram": "tram",
+    "Bus": "bus",
+    "AST": "bus",
+    "Fäh": "ferry",
+}
+
+
+def _parse_dt(s: str) -> Optional[datetime]:
+    try:
+        return datetime.fromisoformat(s)
+    except (ValueError, TypeError):
+        return None
+
+
+def _determine_transport_type(product: Dict[str, Any]) -> str:
+    cat_out = product.get("catOut", "").strip()
+    cat_code = product.get("catCode")
+
+    for key, transport_type in PRODUCT_MAPPING.items():
+        if cat_out.startswith(key):
+            return transport_type
+
+    if cat_code is not None:
+        try:
+            code = int(cat_code)
+            if code in (1, 2):
+                return "train"
+            elif code in (4, 8):
+                return "train"
+            elif code == 16:
+                return "train"
+            elif code == 32:
+                return "bus"
+            elif code == 64:
+                return "ferry"
+            elif code == 128:
+                return "subway"
+            elif code == 256:
+                return "tram"
+        except (ValueError, TypeError):
+            pass
+
+    return "unknown"
+
+
+class RMVProvider(BaseProvider):
+    """RMV (Frankfurt/Rhine-Main) provider using HAFAS REST API."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_RMV
+
+    @property
+    def provider_name(self) -> str:
+        return "RMV (Frankfurt)"
+
+    @property
+    def requires_api_key(self) -> bool:
+        return True
+
+    def get_timezone(self) -> str:
+        return "Europe/Berlin"
+
+    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("RMV provider requires a station_id")
+            return None
+
+        if not self.api_key:
+            _LOGGER.error("RMV provider requires an API key")
+            return None
+
+        url = (
+            f"{API_BASE}/departureBoard"
+            f"?accessId={self.api_key}"
+            f"&id={station_id}"
+            f"&format=json"
+            f"&duration=120"
+            f"&maxJourneys={departures_limit}"
+        )
+
+        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):
+                        return None
+
+                    if "errorCode" in data:
+                        _LOGGER.warning("RMV API error: %s", data.get("errorText", "unknown"))
+                        return None
+
+                    departures = data.get("Departure", [])
+                    if isinstance(departures, dict):
+                        departures = [departures]
+                    return {"stopEvents": departures}
+                elif response.status == 401:
+                    _LOGGER.error("RMV API: invalid API key")
+                else:
+                    _LOGGER.warning("RMV API returned status %s", response.status)
+        except aiohttp.ClientError as e:
+            _LOGGER.warning("RMV API request failed: %s", e)
+        except Exception as e:
+            _LOGGER.warning("RMV API error: %s", e)
+
+        return None
+
+    def parse_departure(
+        self, stop: Dict[str, Any], tz: Union[ZoneInfo, Any], now: datetime
+    ) -> Optional[UnifiedDeparture]:
+        try:
+            date_str = stop.get("date")
+            time_str = stop.get("time")
+            rt_date_str = stop.get("rtDate")
+            rt_time_str = stop.get("rtTime")
+
+            if not date_str or not time_str:
+                return None
+
+            planned_dt_str = f"{date_str}T{time_str}"
+            planned = _parse_dt(planned_dt_str)
+            if not planned:
+                return None
+            planned_local = planned.replace(tzinfo=tz) if planned.tzinfo is None else planned.astimezone(tz)
+
+            if rt_date_str and rt_time_str:
+                rt_dt_str = f"{rt_date_str}T{rt_time_str}"
+                rt = _parse_dt(rt_dt_str)
+                if rt:
+                    when_local = rt.replace(tzinfo=tz) if rt.tzinfo is None else rt.astimezone(tz)
+                    is_realtime = True
+                else:
+                    when_local = planned_local
+                    is_realtime = False
+            else:
+                when_local = planned_local
+                is_realtime = False
+
+            delay_minutes = int((when_local - planned_local).total_seconds() / 60)
+
+            product = stop.get("ProductAtStop", stop.get("Product", {}))
+            if isinstance(product, list):
+                product = product[0] if product else {}
+            line_name = product.get("line", product.get("name", ""))
+            transport_type = _determine_transport_type(product)
+
+            direction = stop.get("direction", "Unknown")
+            platform = stop.get("track", "")
+
+            rt_track = stop.get("rtTrack", "")
+            planned_track = platform
+            platform_changed = bool(rt_track and planned_track and rt_track != planned_track)
+            if rt_track:
+                platform = rt_track
+
+            time_diff = when_local - now
+            minutes_until = max(0, int(time_diff.total_seconds() / 60))
+
+            notices = []
+            for msg in stop.get("Messages", {}).get("Message", []):
+                if isinstance(msg, dict):
+                    text = msg.get("head", "") or msg.get("text", "")
+                    if text:
+                        notices.append(text)
+
+            operator = product.get("operator", product.get("operatorName", ""))
+
+            return UnifiedDeparture(
+                line=line_name,
+                destination=direction,
+                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=product.get("catOutL"),
+                agency=operator if operator else None,
+                notices=notices if notices else None,
+                planned_platform=planned_track if platform_changed else None,
+                platform_changed=platform_changed,
+            )
+        except Exception as e:
+            _LOGGER.debug("Error parsing RMV departure: %s", e)
+            return None
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        if not self.api_key:
+            _LOGGER.error("RMV provider requires an API key for stop search")
+            return []
+
+        url = (
+            f"{API_BASE}/location.name"
+            f"?accessId={self.api_key}"
+            f"&input={quote(search_term, safe='')}"
+            f"&format=json"
+            f"&maxNo=15"
+            f"&type=S"
+        )
+
+        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, dict):
+                        return []
+
+                    stop_locations = data.get("stopLocationOrCoordLocation", [])
+                    results = []
+
+                    for item in stop_locations:
+                        if not isinstance(item, dict):
+                            continue
+                        loc = item.get("StopLocation", {})
+                        if not loc:
+                            continue
+
+                        name = loc.get("name", "")
+                        place = ""
+                        if "," in name:
+                            parts = name.split(",", 1)
+                            place = parts[0].strip()
+
+                        results.append(
+                            {
+                                "id": loc.get("extId", loc.get("id", "")),
+                                "name": name,
+                                "place": place,
+                                "area_type": "stop",
+                            }
+                        )
+                    return results
+                else:
+                    _LOGGER.error("RMV API returned status %s", response.status)
+        except Exception as e:
+            _LOGGER.error("Error searching RMV stops: %s", e)
+
+        return []

openpublictransport/providers/rvv.py

@@ -0,0 +1,43 @@
+"""RVV (Regensburger Verkehrsverbund) provider implementation."""
+
+from typing import Any, Callable, Dict, Optional
+
+from ..const import PROVIDER_RVV
+from .efa_base import EFABaseProvider
+
+
+class RVVProvider(EFABaseProvider):
+    """RVV (Regensburg) provider."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_RVV
+
+    @property
+    def provider_name(self) -> str:
+        return "RVV (Regensburg)"
+
+    @property
+    def dm_base_url(self) -> str:
+        return "https://efa.rvv.de/efa/XML_DM_REQUEST"
+
+    @property
+    def sf_base_url(self) -> str:
+        return "https://efa.rvv.de/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)
+            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/sbb.py

@@ -0,0 +1,174 @@
+"""SBB (Swiss Federal Railways) provider implementation."""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import quote
+from zoneinfo import ZoneInfo
+
+import aiohttp
+
+from ..const import PROVIDER_SBB
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+API_BASE = "https://transport.opendata.ch/v1"
+
+CATEGORY_MAPPING = {
+    "ICE": "train",
+    "IC": "train",
+    "IR": "train",
+    "EC": "train",
+    "RE": "train",
+    "S": "train",
+    "TGV": "train",
+    "RJ": "train",
+    "T": "tram",
+    "B": "bus",
+    "NFB": "bus",
+    "BUS": "bus",
+    "BAT": "ferry",
+    "FAE": "ferry",
+    "M": "subway",
+    "FUN": "train",
+}
+
+
+def _parse_dt(s: str) -> Optional[datetime]:
+    try:
+        return datetime.fromisoformat(s)
+    except (ValueError, TypeError):
+        return None
+
+
+class SBBProvider(BaseProvider):
+    """SBB (Swiss Federal Railways) provider."""
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_SBB
+
+    @property
+    def provider_name(self) -> str:
+        return "SBB (Schweiz)"
+
+    def get_timezone(self) -> str:
+        return "Europe/Zurich"
+
+    async def fetch_departures(
+        self,
+        station_id: Optional[str],
+        place_dm: str,
+        name_dm: str,
+        departures_limit: int,
+    ) -> Optional[Dict[str, Any]]:
+        if station_id:
+            url = f"{API_BASE}/stationboard?id={station_id}&limit={departures_limit}"
+        else:
+            station_name = f"{name_dm}, {place_dm}" if place_dm else name_dm
+            url = f"{API_BASE}/stationboard?station={quote(station_name, safe='')}&limit={departures_limit}"
+
+        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):
+                        return None
+                    stationboard = data.get("stationboard", [])
+                    return {"stopEvents": stationboard}
+                else:
+                    _LOGGER.warning("SBB API returned status %s", response.status)
+        except aiohttp.ClientError as e:
+            _LOGGER.warning("SBB API request failed: %s", e)
+        except Exception as e:
+            _LOGGER.warning("SBB API error: %s", e)
+
+        return None
+
+    def parse_departure(
+        self, stop: Dict[str, Any], tz: Union[ZoneInfo, Any], now: datetime
+    ) -> Optional[UnifiedDeparture]:
+        try:
+            stop_info = stop.get("stop", {})
+            dep_str = stop_info.get("departure")
+            if not dep_str:
+                return None
+
+            dep_dt = _parse_dt(dep_str)
+            if not dep_dt:
+                return None
+
+            dep_local = dep_dt.astimezone(tz)
+            delay_min = stop_info.get("delay") or 0
+
+            planned_local = dep_local - timedelta(minutes=delay_min)
+
+            category = stop.get("category", "")
+            number = stop.get("number", "")
+            line = f"{category}{number}"
+
+            transport_type = CATEGORY_MAPPING.get(category, "unknown")
+            destination = stop.get("to", "Unknown")
+            platform = stop_info.get("platform", "")
+
+            time_diff = dep_local - now
+            minutes_until = max(0, int(time_diff.total_seconds() / 60))
+
+            is_realtime = stop_info.get("prognosis", {}).get("departure") is not None
+
+            prognosis_platform = stop_info.get("prognosis", {}).get("platform")
+            platform_changed = bool(prognosis_platform and platform and prognosis_platform != platform)
+            planned_platform = platform if platform_changed else None
+            if prognosis_platform:
+                platform = prognosis_platform
+
+            return UnifiedDeparture(
+                line=line,
+                destination=destination,
+                departure_time=dep_local.strftime("%H:%M"),
+                planned_time=planned_local.strftime("%H:%M"),
+                delay=delay_min,
+                platform=platform,
+                transportation_type=transport_type,
+                is_realtime=is_realtime,
+                minutes_until_departure=minutes_until,
+                departure_time_obj=dep_local,
+                description=stop.get("operator", ""),
+                notices=None,
+                planned_platform=planned_platform,
+                platform_changed=platform_changed,
+            )
+        except Exception as e:
+            _LOGGER.debug("Error parsing SBB 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='')}&type=station"
+
+        try:
+            async with self.session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    stations = data.get("stations", [])
+                    results = []
+                    for station in stations:
+                        if not isinstance(station, dict) or not station.get("id"):
+                            continue
+                        name = station.get("name", "")
+                        results.append(
+                            {
+                                "id": str(station.get("id", "")),
+                                "name": name,
+                                "place": "",
+                                "area_type": "stop",
+                            }
+                        )
+                    return results
+                else:
+                    _LOGGER.error("SBB API returned status %s", response.status)
+        except Exception as e:
+            _LOGGER.error("Error searching SBB stops: %s", e)
+
+        return []