python-openpublictransport 0.1.2__tar.gz → 0.1.3__tar.gz

{python_openpublictransport-0.1.2 → python_openpublictransport-0.1.3}/PKG-INFO

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

{python_openpublictransport-0.1.2 → python_openpublictransport-0.1.3}/pyproject.toml

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

{python_openpublictransport-0.1.2 → python_openpublictransport-0.1.3}/src/openpublictransport/const.py

@@ -29,6 +29,8 @@ PROVIDER_VBN_OTP = "vbn_otp"
 PROVIDER_VBN_TRIAS = "vbn_trias"
 PROVIDER_OPT = "openpublictransport"
 PROVIDER_OTP_CUSTOM = "otp_custom"
+PROVIDER_NATIONAL_RAIL = "national_rail"
+PROVIDER_REJSEPLANEN = "rejseplanen"
 
 # API base URLs
 API_BASE_URL_VRR = "https://openservice-test.vrr.de/static03/XML_DM_REQUEST"

{python_openpublictransport-0.1.2 → python_openpublictransport-0.1.3}/src/openpublictransport/providers/__init__.py

@@ -32,6 +32,8 @@ from ..const import (
     PROVIDER_VRR,
     PROVIDER_VVO,
     PROVIDER_VVS,
+    PROVIDER_NATIONAL_RAIL,
+    PROVIDER_REJSEPLANEN,
 )
 from .avv import AVVProvider
 from .base import BaseProvider
@@ -61,6 +63,8 @@ from .vrn import VRNProvider
 from .vrr import VRRProvider
 from .vvo import VVOProvider
 from .vvs import VVSProvider
+from .national_rail import NationalRailProvider
+from .rejseplanen import RejseplanenProvider
 
 _PROVIDER_REGISTRY: Dict[str, Type[BaseProvider]] = {}
 
@@ -134,3 +138,5 @@ register_provider(PROVIDER_VBN_OTP, VBNOTPProvider)
 register_provider(PROVIDER_VBN_TRIAS, VBNTriasProvider)
 register_provider(PROVIDER_OPT, OPTProvider)
 register_provider(PROVIDER_OTP_CUSTOM, OTPCustomProvider)
+register_provider(PROVIDER_NATIONAL_RAIL, NationalRailProvider)
+register_provider(PROVIDER_REJSEPLANEN, RejseplanenProvider)

python_openpublictransport-0.1.3/src/openpublictransport/providers/national_rail.py

@@ -0,0 +1,310 @@
+"""National Rail (UK) provider using OpenLDBWS SOAP API.
+
+Stop search uses the Overpass API (OSM) to find UK railway stations with
+ref:crs tags, returning the 3-letter CRS code used by OpenLDBWS.
+"""
+
+import logging
+import re
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree as ET
+from zoneinfo import ZoneInfo
+
+import aiohttp
+
+from ..const import PROVIDER_NATIONAL_RAIL
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+_ENDPOINT = "https://lite.realtime.nationalrail.co.uk/OpenLDBWS/ldb11.asmx"
+_SOAP_ACTION = "http://thalesgroup.com/RTTI/2017-10-01/ldb/GetDepartureBoard"
+_OVERPASS_URL = "https://overpass-api.de/api/interpreter"
+
+# UK bounding box (lat_min, lon_min, lat_max, lon_max)
+_UK_BBOX = "49,-11,62,2"
+
+_SOAP_TEMPLATE = """<?xml version="1.0" encoding="UTF-8"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+               xmlns:ldb="http://thalesgroup.com/RTTI/2017-10-01/ldb/"
+               xmlns:tok="http://thalesgroup.com/RTTI/2013-11-28/Token/types">
+  <soap:Header>
+    <tok:AccessToken>
+      <tok:TokenValue>{api_key}</tok:TokenValue>
+    </tok:AccessToken>
+  </soap:Header>
+  <soap:Body>
+    <ldb:GetDepartureBoardRequest>
+      <ldb:numRows>{num_rows}</ldb:numRows>
+      <ldb:crs>{crs}</ldb:crs>
+    </ldb:GetDepartureBoardRequest>
+  </soap:Body>
+</soap:Envelope>"""
+
+
+def _strip_namespaces(xml_string: str) -> str:
+    """Remove XML namespace prefixes and declarations for simpler parsing."""
+    xml_string = re.sub(r' xmlns[^=]*="[^"]*"', "", xml_string)
+    xml_string = re.sub(r"<([a-zA-Z]+):", "<", xml_string)
+    xml_string = re.sub(r"</([a-zA-Z]+):", "</", xml_string)
+    return xml_string
+
+
+def _text(el: Optional[ET.Element], tag: str, default: str = "") -> str:
+    """Get text of a direct child element."""
+    if el is None:
+        return default
+    child = el.find(tag)
+    return child.text if child is not None and child.text else default
+
+
+class NationalRailProvider(BaseProvider):
+    """National Rail (UK) provider via OpenLDBWS."""
+
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        api_key: Optional[str] = None,
+        api_key_secondary: Optional[str] = None,
+        custom_url: Optional[str] = None,
+    ):
+        super().__init__(session, api_key=api_key, api_key_secondary=api_key_secondary, custom_url=custom_url)
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_NATIONAL_RAIL
+
+    @property
+    def provider_name(self) -> str:
+        return "National Rail (UK)"
+
+    @property
+    def requires_api_key(self) -> bool:
+        return True
+
+    def get_timezone(self) -> str:
+        return "Europe/London"
+
+    def get_transport_type_mapping(self) -> Dict:
+        return {}
+
+    async def fetch_departures(
+        self,
+        station_id: Optional[str],
+        place_dm: Optional[str],
+        name_dm: Optional[str],
+        departures_limit: int,
+    ) -> Optional[Dict]:
+        """Fetch departures via OpenLDBWS SOAP for a given CRS code."""
+        if not self.api_key or not station_id:
+            return None
+
+        crs = station_id.strip().upper()
+        body = _SOAP_TEMPLATE.format(
+            api_key=self.api_key,
+            num_rows=min(departures_limit, 150),
+            crs=crs,
+        )
+
+        try:
+            async with self.session.post(
+                _ENDPOINT,
+                data=body.encode("utf-8"),
+                headers={
+                    "Content-Type": "text/xml; charset=utf-8",
+                    "SOAPAction": _SOAP_ACTION,
+                },
+                timeout=aiohttp.ClientTimeout(total=15),
+            ) as resp:
+                if resp.status != 200:
+                    _LOGGER.warning("%s: HTTP %s for CRS %s", self.provider_name, resp.status, crs)
+                    return None
+                text = await resp.text()
+        except Exception as exc:
+            _LOGGER.warning("%s: request failed: %s", self.provider_name, exc)
+            return None
+
+        try:
+            root = ET.fromstring(_strip_namespaces(text))
+        except ET.ParseError as exc:
+            _LOGGER.warning("%s: XML parse error: %s", self.provider_name, exc)
+            return None
+
+        services = root.findall(".//service")
+        if not services:
+            return {"stopEvents": []}
+
+        tz = ZoneInfo(self.get_timezone())
+        now = datetime.now(tz)
+        board_date = now.date()
+
+        stop_events = []
+        for svc in services:
+            event = self._service_to_dict(svc, board_date, tz, now)
+            if event:
+                stop_events.append(event)
+
+        return {"stopEvents": stop_events}
+
+    def _service_to_dict(
+        self,
+        svc: ET.Element,
+        board_date: Any,
+        tz: ZoneInfo,
+        now: datetime,
+    ) -> Optional[Dict[str, Any]]:
+        """Convert an XML service element to a plain dict."""
+        std = _text(svc, "std")
+        if not std:
+            return None
+
+        etd = _text(svc, "etd")
+        platform = _text(svc, "platform") or None
+        operator_name = _text(svc, "operator")
+        operator_code = _text(svc, "operatorCode")
+        is_cancelled = _text(svc, "isCancelled") == "true"
+        delay_reason = _text(svc, "delayReason")
+        cancel_reason = _text(svc, "cancelReason")
+
+        destination = ""
+        dest_el = svc.find(".//destination")
+        if dest_el is not None:
+            loc = dest_el.find("location")
+            if loc is not None:
+                destination = _text(loc, "locationName")
+        if not destination:
+            destination = "Unknown"
+
+        return {
+            "std": std,
+            "etd": etd,
+            "platform": platform,
+            "operator": operator_name,
+            "operatorCode": operator_code,
+            "isCancelled": is_cancelled,
+            "delayReason": delay_reason,
+            "cancelReason": cancel_reason,
+            "destination": destination,
+            "boardDate": board_date.isoformat(),
+        }
+
+    def parse_departure(
+        self,
+        stop: Dict[str, Any],
+        tz: Any,
+        now: datetime,
+    ) -> Optional[UnifiedDeparture]:
+        """Map a service dict to UnifiedDeparture."""
+        std = stop.get("std", "")
+        etd = stop.get("etd", "")
+        if not std:
+            return None
+
+        try:
+            board_date_str = stop.get("boardDate", "")
+            from datetime import date as date_cls
+
+            board_date = date_cls.fromisoformat(board_date_str) if board_date_str else datetime.now(tz).date()
+        except ValueError:
+            board_date = datetime.now(tz).date()
+
+        def _parse_hhmm(hhmm: str) -> Optional[datetime]:
+            try:
+                h, m = map(int, hhmm.strip().split(":"))
+                dt = datetime(board_date.year, board_date.month, board_date.day, h, m, tzinfo=tz)
+                if (now - dt).total_seconds() > 3600:
+                    dt += timedelta(days=1)
+                return dt
+            except (ValueError, TypeError):
+                return None
+
+        planned_dt = _parse_hhmm(std)
+        if planned_dt is None:
+            return None
+
+        is_cancelled = stop.get("isCancelled", False)
+        notices: List[str] = []
+        if stop.get("delayReason"):
+            notices.append(stop["delayReason"])
+        if stop.get("cancelReason"):
+            notices.append(stop["cancelReason"])
+
+        delay = 0
+        is_realtime = False
+        actual_dt = planned_dt
+
+        if is_cancelled:
+            notices.insert(0, "Cancelled")
+            is_realtime = True
+        elif etd == "On time":
+            is_realtime = True
+        elif etd == "Delayed":
+            is_realtime = True
+            notices.insert(0, "Delayed")
+        elif etd and ":" in etd:
+            actual_dt_parsed = _parse_hhmm(etd)
+            if actual_dt_parsed:
+                actual_dt = actual_dt_parsed
+                delay = max(0, int((actual_dt - planned_dt).total_seconds() / 60))
+                is_realtime = True
+
+        minutes_until = max(0, int((actual_dt - now).total_seconds() / 60))
+        line = stop.get("operatorCode", "") or stop.get("operator", "")
+
+        return UnifiedDeparture(
+            line=line,
+            destination=stop.get("destination", ""),
+            departure_time=actual_dt.strftime("%H:%M"),
+            planned_time=std,
+            delay=delay,
+            platform=stop.get("platform"),
+            transportation_type="train",
+            is_realtime=is_realtime,
+            minutes_until_departure=minutes_until,
+            departure_time_obj=actual_dt,
+            agency=stop.get("operator") or None,
+            notices=notices if notices else None,
+        )
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        """Find UK railway stations with CRS codes via Overpass API (OSM)."""
+        escaped = re.sub(r"[.*+?^${}()|[\]\\]", r"\\\g<0>", search_term)
+
+        query = f"""[out:json][timeout:15];
+(
+  node["railway"="station"]["ref:crs"]["name"~"{escaped}",i]({_UK_BBOX});
+  node["railway"="station"]["ref:crs"]["official_name"~"{escaped}",i]({_UK_BBOX});
+  node["railway"="station"]["ref:crs"]["alt_name"~"{escaped}",i]({_UK_BBOX});
+);
+out 10;"""
+
+        try:
+            async with self.session.post(
+                _OVERPASS_URL,
+                data={"data": query},
+                headers={
+                    "User-Agent": "openpublictransport-homeassistant/1.0 (github.com/NerdySoftPaw/openpublictransport)"
+                },
+                timeout=aiohttp.ClientTimeout(total=15),
+            ) as resp:
+                if resp.status != 200:
+                    _LOGGER.warning("%s: Overpass HTTP %s", self.provider_name, resp.status)
+                    return []
+                data = await resp.json(content_type=None)
+        except Exception as exc:
+            _LOGGER.warning("%s: stop search failed: %s", self.provider_name, exc)
+            return []
+
+        results = []
+        for element in data.get("elements", []):
+            tags = element.get("tags", {})
+            crs = tags.get("ref:crs", "").strip().upper()
+            name = tags.get("name") or tags.get("official_name", "")
+            if not crs or len(crs) != 3 or not name:
+                continue
+            operator = tags.get("operator") or tags.get("network", "")
+            results.append({"id": crs, "name": name, "place": operator, "area_type": "stop"})
+
+        return results[:10]

python_openpublictransport-0.1.3/src/openpublictransport/providers/rejseplanen.py

@@ -0,0 +1,236 @@
+"""Rejseplanen (Denmark) provider using the HAFAS REST API.
+
+Requires a free API key from labs.rejseplanen.dk (50k calls/month, non-commercial).
+"""
+
+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_REJSEPLANEN
+from ..models import UnifiedDeparture
+from .base import BaseProvider
+
+_LOGGER = logging.getLogger(__name__)
+
+_API_BASE = "https://www.rejseplanen.dk/api"
+
+_PRODUCT_MAPPING: Dict[str, str] = {
+    "IC": "train",
+    "LYN": "train",
+    "RE": "train",
+    "REG": "train",
+    "S": "train",
+    "TOG": "train",
+    "M": "subway",
+    "BUS": "bus",
+    "EXB": "bus",
+    "NB": "bus",
+    "TB": "bus",
+    "F": "ferry",
+    "T": "tram",
+}
+
+
+def _parse_hafas_time(date_str: str, time_str: str, tz: Any) -> Optional[datetime]:
+    """Parse Rejseplanen date (DD.MM.YY) and time (HH:MM) into a timezone-aware datetime."""
+    if not date_str or not time_str:
+        return None
+    try:
+        time_fmt = "%H:%M:%S" if time_str.count(":") == 2 else "%H:%M"
+        dt = datetime.strptime(f"{date_str} {time_str}", f"%d.%m.%y {time_fmt}")
+        return dt.replace(tzinfo=tz)
+    except ValueError:
+        return None
+
+
+class RejseplanenProvider(BaseProvider):
+    """Rejseplanen (Denmark) provider via HAFAS REST API."""
+
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        api_key: Optional[str] = None,
+        api_key_secondary: Optional[str] = None,
+        custom_url: Optional[str] = None,
+    ):
+        super().__init__(session, api_key=api_key, api_key_secondary=api_key_secondary, custom_url=custom_url)
+
+    @property
+    def provider_id(self) -> str:
+        return PROVIDER_REJSEPLANEN
+
+    @property
+    def provider_name(self) -> str:
+        return "Rejseplanen (Denmark)"
+
+    @property
+    def requires_api_key(self) -> bool:
+        return True
+
+    def get_timezone(self) -> str:
+        return "Europe/Copenhagen"
+
+    def get_transport_type_mapping(self) -> Dict:
+        return _PRODUCT_MAPPING
+
+    async def fetch_departures(
+        self,
+        station_id: Optional[str],
+        place_dm: str,
+        name_dm: str,
+        departures_limit: int,
+    ) -> Optional[Dict[str, Any]]:
+        """Fetch departures from the Rejseplanen departureBoard endpoint."""
+        if not station_id:
+            _LOGGER.warning("%s: station_id required", self.provider_name)
+            return None
+        if not self.api_key:
+            _LOGGER.error("%s: API key required", self.provider_name)
+            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 resp:
+                if resp.status != 200:
+                    _LOGGER.warning("%s: HTTP %s for station %s", self.provider_name, resp.status, station_id)
+                    return None
+                data = await resp.json(content_type=None)
+        except Exception as exc:
+            _LOGGER.warning("%s: request failed: %s", self.provider_name, exc)
+            return None
+
+        if not isinstance(data, dict):
+            return None
+        if "errorCode" in data:
+            _LOGGER.warning("%s: API error %s: %s", self.provider_name, data.get("errorCode"), data.get("errorText"))
+            return None
+
+        board = data.get("DepartureBoard", {})
+        departures = board.get("Departure", [])
+        if isinstance(departures, dict):
+            departures = [departures]
+
+        return {"stopEvents": departures}
+
+    def parse_departure(
+        self,
+        stop: Dict[str, Any],
+        tz: Union[ZoneInfo, Any],
+        now: datetime,
+    ) -> Optional[UnifiedDeparture]:
+        """Parse a single Rejseplanen departure dict into UnifiedDeparture."""
+        try:
+            date_str = stop.get("date", "")
+            time_str = stop.get("time", "")
+            rt_date_str = stop.get("rtDate", "")
+            rt_time_str = stop.get("rtTime", "")
+
+            planned_dt = _parse_hafas_time(date_str, time_str, tz)
+            if planned_dt is None:
+                return None
+
+            if rt_date_str and rt_time_str:
+                actual_dt = _parse_hafas_time(rt_date_str, rt_time_str, tz) or planned_dt
+                is_realtime = True
+            else:
+                actual_dt = planned_dt
+                is_realtime = False
+
+            delay = max(0, int((actual_dt - planned_dt).total_seconds() / 60))
+            minutes_until = max(0, int((actual_dt - now).total_seconds() / 60))
+
+            type_str = stop.get("type", "").upper()
+            transport_type = _PRODUCT_MAPPING.get(type_str, "train")
+
+            line = stop.get("name", "")
+            destination = stop.get("direction", stop.get("finalStop", ""))
+
+            track = stop.get("track", "") or ""
+            rt_track = stop.get("rtTrack", "") or ""
+            platform = rt_track if rt_track else track
+            platform_changed = bool(rt_track and track and rt_track != track)
+
+            notices: List[str] = []
+            if stop.get("cancelled") == "true" or stop.get("cancelled") is True:
+                notices.append("Cancelled / Aflyst")
+
+            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)
+
+            return UnifiedDeparture(
+                line=line,
+                destination=destination,
+                departure_time=actual_dt.strftime("%H:%M"),
+                planned_time=planned_dt.strftime("%H:%M"),
+                delay=delay,
+                platform=platform or None,
+                transportation_type=transport_type,
+                is_realtime=is_realtime,
+                minutes_until_departure=minutes_until,
+                departure_time_obj=actual_dt,
+                notices=notices if notices else None,
+                planned_platform=track if platform_changed else None,
+                platform_changed=platform_changed,
+            )
+        except Exception as exc:
+            _LOGGER.debug("%s: parse error: %s", self.provider_name, exc)
+            return None
+
+    async def search_stops(self, search_term: str) -> List[Dict[str, Any]]:
+        """Search for Danish stops using the Rejseplanen location.name endpoint."""
+        if not self.api_key:
+            _LOGGER.error("%s: API key required for stop search", self.provider_name)
+            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 resp:
+                if resp.status != 200:
+                    _LOGGER.warning("%s: stop search HTTP %s", self.provider_name, resp.status)
+                    return []
+                data = await resp.json(content_type=None)
+        except Exception as exc:
+            _LOGGER.warning("%s: stop search failed: %s", self.provider_name, exc)
+            return []
+
+        if not isinstance(data, dict):
+            return []
+
+        location_list = data.get("LocationList", {})
+        stops = location_list.get("StopLocation", [])
+        if isinstance(stops, dict):
+            stops = [stops]
+
+        results = []
+        for loc in stops:
+            if not isinstance(loc, dict):
+                continue
+            station_id = loc.get("extId") or loc.get("id", "")
+            name = loc.get("name", "")
+            if not station_id or not name:
+                continue
+            results.append({"id": str(station_id), "name": name, "place": "", "area_type": "stop"})
+
+        return results[:10]

{python_openpublictransport-0.1.2 → python_openpublictransport-0.1.3}/src/python_openpublictransport.egg-info/PKG-INFO

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

{python_openpublictransport-0.1.2 → python_openpublictransport-0.1.3}/src/python_openpublictransport.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/openpublictransport/providers/gtfsde.py
 src/openpublictransport/providers/hvv.py
 src/openpublictransport/providers/kvv.py
 src/openpublictransport/providers/mvv.py
+src/openpublictransport/providers/national_rail.py
 src/openpublictransport/providers/nta.py
 src/openpublictransport/providers/nvbw.py
 src/openpublictransport/providers/nwl.py
@@ -24,6 +25,7 @@ src/openpublictransport/providers/oebb.py
 src/openpublictransport/providers/otp.py
 src/openpublictransport/providers/otp_base.py
 src/openpublictransport/providers/otp_custom.py
+src/openpublictransport/providers/rejseplanen.py
 src/openpublictransport/providers/rmv.py
 src/openpublictransport/providers/rvv.py
 src/openpublictransport/providers/sbb.py