gtfs-cli 0.1.0__py3-none-any.whl

gtfs_cli/__main__.py

@@ -0,0 +1,3 @@
+from gtfs_cli.main import app
+
+app()

gtfs_cli/commands/fetch.py

@@ -0,0 +1,171 @@
+import json
+import logging
+import signal
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+from google.protobuf.json_format import MessageToDict, MessageToJson
+from google.transit import gtfs_realtime_pb2
+
+logging.basicConfig(
+    level=logging.ERROR,
+    format="%(asctime)s %(levelname)s %(message)s",
+    datefmt="%Y-%m-%dT%H:%M:%S",
+    stream=sys.stderr,
+)
+logger = logging.getLogger(__name__)
+
+
+def _is_url(source: str) -> bool:
+    return source.startswith("http://") or source.startswith("https://")
+
+
+def _fetch_from_url(url: str, timeout: float, client=None) -> bytes:
+    import httpx
+
+    if client is not None:
+        response = client.get(url)
+    else:
+        response = httpx.get(url, timeout=timeout, follow_redirects=True)
+    response.raise_for_status()
+    return response.content
+
+
+def _read_from_file(path: str) -> bytes:
+    file_path = Path(path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+    return file_path.read_bytes()
+
+
+def _parse_feed(data: bytes) -> gtfs_realtime_pb2.FeedMessage:
+    feed = gtfs_realtime_pb2.FeedMessage()
+    feed.ParseFromString(data)
+    return feed
+
+
+def _remaining_sleep(next_wake: float) -> float:
+    """Seconds until next_wake on the monotonic clock. Never negative."""
+    return max(0.0, next_wake - time.monotonic())
+
+
+def _backoff_delay(consecutive_failures: int, cap: float = 60.0) -> float:
+    """Exponential backoff: 1s, 2s, 4s, …, capped at `cap` seconds."""
+    return min(2.0 ** (consecutive_failures - 1), cap)
+
+
+def _feed_to_ndjson_line(feed: gtfs_realtime_pb2.FeedMessage) -> str:
+    """Convert a FeedMessage to a single-line JSON string (for NDJSON output)."""
+    d = MessageToDict(feed, preserving_proto_field_name=True)
+    return json.dumps(d, separators=(",", ":"))
+
+
+def fetch(
+    source: str = typer.Argument(
+        help="URL or local file path to a GTFS-RT protobuf feed.",
+    ),
+    timeout: float = typer.Option(
+        30.0,
+        help="HTTP request timeout in seconds (only applies to URL sources).",
+    ),
+    watch: Optional[float] = typer.Option(
+        None,
+        help="Continuously fetch at this interval (seconds). Outputs NDJSON. URL sources only.",
+    ),
+) -> None:
+    """Fetch GTFS-RT data and output as JSON.
+
+    SOURCE is either an HTTP(S) URL or a local file path. Auto-detected.
+
+    Examples:
+
+        gtfs-cli fetch "https://gtfsrt.ttc.ca/trips/update?format=binary"
+
+        gtfs-cli fetch trips.pb
+
+        gtfs-cli fetch feed.pb | jq '.entity[] | .alert'
+
+        gtfs-cli fetch --watch 30 "https://gtfsrt.ttc.ca/trips/update?format=binary"
+
+        gtfs-cli fetch --watch 30 "https://gtfsrt.ttc.ca/trips/update?format=binary" | jq --unbuffered '.entity | length'
+    """
+    if watch is not None:
+        if not _is_url(source):
+            print(
+                "Error: --watch requires a URL source (watching a local file is not supported).",
+                file=sys.stderr,
+            )
+            raise typer.Exit(code=1)
+        _watch_loop(source, timeout, watch)
+        return
+
+    try:
+        if _is_url(source):
+            data = _fetch_from_url(source, timeout)
+        else:
+            data = _read_from_file(source)
+    except FileNotFoundError as e:
+        print(str(e), file=sys.stderr)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        print(f"Error fetching source: {e}", file=sys.stderr)
+        raise typer.Exit(code=1)
+
+    try:
+        feed = _parse_feed(data)
+    except Exception as e:
+        print(f"Error parsing protobuf: {e}", file=sys.stderr)
+        raise typer.Exit(code=1)
+
+    json_output = MessageToJson(feed, preserving_proto_field_name=True)
+    print(json_output)
+
+
+def _watch_loop(
+    url: str,
+    timeout: float,
+    interval: float,
+    _stop_event: threading.Event | None = None,
+) -> None:
+    """Continuously fetch a GTFS-RT feed and output NDJSON lines."""
+    import httpx
+
+    stop_event = _stop_event if _stop_event is not None else threading.Event()
+
+    def _sigterm_handler(signum, frame):
+        stop_event.set()
+
+    old_handler = signal.signal(signal.SIGTERM, _sigterm_handler)
+    consecutive_failures = 0
+    try:
+        with httpx.Client(timeout=timeout, follow_redirects=True) as client:
+            while not stop_event.is_set():
+                next_wake = time.monotonic() + interval
+                try:
+                    data = _fetch_from_url(url, timeout, client=client)
+                except (httpx.HTTPStatusError, httpx.RequestError) as e:
+                    logger.error("HTTP error: %s", e)
+                    consecutive_failures += 1
+                    stop_event.wait(_backoff_delay(consecutive_failures))
+                    continue
+
+                consecutive_failures = 0
+                try:
+                    feed = _parse_feed(data)
+                    print(_feed_to_ndjson_line(feed))
+                    sys.stdout.flush()
+                except BrokenPipeError:
+                    stop_event.set()
+                    break
+                except Exception as e:
+                    logger.error("Parse error: %s", e)
+
+                stop_event.wait(_remaining_sleep(next_wake))
+    except KeyboardInterrupt:
+        pass
+    finally:
+        signal.signal(signal.SIGTERM, old_handler)

gtfs_cli/main.py

@@ -0,0 +1,17 @@
+import typer
+
+from gtfs_cli.commands.fetch import fetch
+
+app = typer.Typer(
+    name="gtfs-cli",
+    help="CLI tool to fetch, archive, process and explore GTFS-RT data.",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def callback() -> None:
+    """CLI tool to fetch, archive, process and explore GTFS-RT data."""
+
+
+app.command()(fetch)

gtfs_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: gtfs-cli
+Version: 0.1.0
+Summary: CLI tool to fetch, archive, process and explore GTFS-RT data
+Project-URL: Homepage, https://github.com/VMois/gtfs-cli
+Project-URL: Repository, https://github.com/VMois/gtfs-cli
+Project-URL: Bug Tracker, https://github.com/VMois/gtfs-cli/issues
+Author: Vladyslav Moisieienkov
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,gtfs,gtfs-rt,realtime,transit
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.11
+Requires-Dist: gtfs-realtime-bindings>=1.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: protobuf>=5.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.15.0
+Description-Content-Type: text/markdown
+
+# gtfs-cli
+
+CLI tool to fetch, archive, process and explore [GTFS-RT](https://gtfs.org/documentation/realtime/reference/) (General Transit Feed Specification — Realtime) data. GTFS-RT feeds provide live transit information: trip updates, vehicle positions, and service alerts in protobuf format.
+
+## Installation
+
+```bash
+uv tool install gtfs-cli
+```
+
+After installation, the `gtfs-cli` command is available globally.
+
+## Commands
+
+### `fetch`
+
+Fetch a GTFS-RT feed from a URL or local file and output it as JSON.
+
+```bash
+# Fetch live trip updates
+gtfs-cli fetch "https://gtfsrt.ttc.ca/trips/update?format=binary"
+
+# Fetch vehicle positions
+gtfs-cli fetch "https://gtfsrt.ttc.ca/vehicles/position?format=binary"
+
+# Fetch service alerts
+gtfs-cli fetch "https://gtfsrt.ttc.ca/alerts/all?format=binary"
+
+# Inspect a previously saved .pb file
+gtfs-cli fetch trips.pb
+```
+
+**Filtering with jq:**
+
+```bash
+# List all active alerts
+gtfs-cli fetch "https://gtfsrt.ttc.ca/alerts/all?format=binary" | jq '.entity[] | .alert'
+
+# Count entities in a feed
+gtfs-cli fetch "https://gtfsrt.ttc.ca/trips/update?format=binary" | jq '.entity | length'
+
+# Extract all trip IDs
+gtfs-cli fetch "https://gtfsrt.ttc.ca/trips/update?format=binary" \
+  | jq '[.entity[].trip_update.trip.trip_id]'
+```
+
+**Watch mode** — continuously poll a feed and stream NDJSON (one JSON object per line):
+
+```bash
+# Poll every 30 seconds
+gtfs-cli fetch --watch 30 "https://gtfsrt.ttc.ca/trips/update?format=binary"
+
+# Count entities on each snapshot
+gtfs-cli fetch --watch 30 "https://gtfsrt.ttc.ca/trips/update?format=binary" \
+  | jq --unbuffered '.entity | length'
+
+# Save a long-running collection to a file
+gtfs-cli fetch --watch 30 "https://gtfsrt.ttc.ca/trips/update?format=binary" \
+  >> snapshots.ndjson
+```
+
+Watch mode handles transient failures gracefully: HTTP and network errors are retried with exponential backoff (1s → 2s → 4s … capped at 60s). Stop with `Ctrl+C` or `SIGTERM`.
+
+For all available options, run:
+
+```bash
+gtfs-cli fetch --help
+```
+
+## Development
+
+```bash
+# Install dependencies
+uv sync
+
+# Run a command
+uv run gtfs-cli fetch "https://gtfsrt.ttc.ca/trips/update?format=binary"
+
+# Run tests
+uv run pytest tests/ -v
+```

gtfs_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+gtfs_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gtfs_cli/__main__.py,sha256=auepT9f8trIQ_vdQ899K1qs8KbgXUI6CrPH6aGH3bcw,37
+gtfs_cli/main.py,sha256=BLLkhrGLtzKyZx42f_2-EFWor1mJ7SfRwgkYs1brdPQ,336
+gtfs_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gtfs_cli/commands/fetch.py,sha256=7-IXi4ia_XF3IyWYC54DQrfqTAfIMziHiC1vW0pObzI,5338
+gtfs_cli-0.1.0.dist-info/METADATA,sha256=vkqwyBOVA3AvNZBmwcfarDG-JBMmxH0B98Jww6XXo3s,3206
+gtfs_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+gtfs_cli-0.1.0.dist-info/entry_points.txt,sha256=9EdFtQDl4DPYW2XiSAp7St3JGNLhla9LDzbrzwLPGog,47
+gtfs_cli-0.1.0.dist-info/licenses/LICENSE,sha256=-cKvf5H86Rx8wbM12rVgGvJhgTbrsDcCBSLyS8PnoDs,1079
+gtfs_cli-0.1.0.dist-info/RECORD,,

gtfs_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gtfs_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gtfs-cli = gtfs_cli.main:app

gtfs_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladyslav Moisieienkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.