gtfs-cli 0.1.0__tar.gz

gtfs_cli-0.1.0/.claude/CLAUDE.md

@@ -0,0 +1,75 @@
+This project is a CLI tool to fetch, archive, process and explore GTFS data, in particular GTFS-RT (Real-Time).
+
+## Tech stack
+
+- Typer for CLI framework, Rich for nice display
+- gtfs-realtime-bindings for protobuf parsing
+- httpx Python library for HTTP connection
+- polars Python library for transformations
+- pyarrow for parquet output
+- uv for Python package and env management
+- pytest for unit tests
+
+## Online resources allowed to fetch
+
+You are allowed to fetch from the following domains (full links provided as a helper):
+
+https://gtfs.org/documentation/realtime/reference - GTFS RT specification
+https://gtfs.org/documentation/realtime/language-bindings/python/ - GTFS Python bindings docs
+https://typer.tiangolo.com/tutorial/ - Typer CLI docs/tutorial
+https://docs.astral.sh/uv/ - uv Python package manager
+https://docs.pola.rs/api/python - for polars docs
+https://www.python-httpx.org/ - HTTPX docs
+
+## GTSF-RT TTC Toronto feed we are using for testing
+
+Base URL: `https://gtfsrt.ttc.ca`
+
+### Available Feeds
+
+**Service Alerts**
+- Combined: `/alerts/all?format=binary` (all alerts: subway, bus, streetcar, accessiblity, stops)
+
+**Trip Updates**
+- Trip Updates: `/trips/update?format=binary`
+- Modified Trip Updates: `/trips/modified_update?format=binary`
+
+**Vehicle Positions**
+- Vehicle Positions: `/vehicles/position?format=binary`
+
+### Testing & Development
+
+**Primary test feeds:**
+- Trip updates: `https://gtfsrt.ttc.ca/trips/update?format=binary`
+- Vehicle positions: `https://gtfsrt.ttc.ca/vehicles/position?format=binary`
+- All alerts: `https://gtfsrt.ttc.ca/alerts/all?format=binary`
+
+**Feed format:** Binary protobuf (use `format=text` for human-readable textproto during debugging)
+
+**Sample fetch command for testing:**
+```bash
+curl https://gtfsrt.ttc.ca/trips/update?format=binary -o test_trip_updates.pb
+```
+
+## Guideline on build CLI
+
+- Include usage examples in --help
+- CLI interfaces are an API - version appropriately with semantic versioning
+- Write unit tests whenever you can; make sure not to use network when they are run
+
+## Project structure
+
+Use console scripts in pyproject.toml
+
+gtfs-cli/
+├── pyproject.toml          # uv managed
+├── src/
+│   └── gtfs_cli/
+│       ├── __main__.py     # Entry point
+│       ├── main.py         # Typer app + version
+│       ├── commands/
+│       │   ├── __init__.py
+├── tests/
+│   └── fixtures/
+│   └── test_abc123.py
+├── docs/  # contains description for different features for implementation

gtfs_cli-0.1.0/.claude/settings.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:typer.tiangolo.com)",
+      "WebFetch(domain:gtfs.org)",
+      "WebFetch(domain:gtfsrt.ttc.ca)",
+      "WebFetch(domain:docs.astral.sh)",
+      "WebFetch(domain:docs.pola.rs)",
+      "WebFetch(domain:python-httpx.org)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

gtfs_cli-0.1.0/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv run pytest:*)",
+      "Bash(git checkout *)",
+      "Bash(git rm *)",
+      "Bash(git commit -m ' *)",
+      "Bash(git add *)"
+    ]
+  }
+}

gtfs_cli-0.1.0/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

gtfs_cli-0.1.0/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.

gtfs_cli-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,81 @@
+# 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/docs/fetch_command.md

@@ -0,0 +1,116 @@
+# `gtfs-cli fetch` Command Design
+
+## Purpose
+
+Load GTFS-RT data from any source (URL or local file) and output it in a human-readable format. This is the single entry point for accessing GTFS-RT data — it handles acquisition and decoding as one cohesive step.
+
+## Usage
+
+```
+gtfs-cli fetch <source> [OPTIONS]
+```
+
+`source` is either an HTTP(S) URL or a local file path. Auto-detected.
+
+## Core Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| `source` (argument) | URL or local file path to a GTFS-RT protobuf |
+
+## Output Behavior
+
+- **JSON to stdout by default** — human-readable and machine-parseable
+- Errors and status info go to stderr, never stdout (keeps pipes clean)
+- Exit code 0 on success, non-zero on HTTP/network/parse errors
+
+### Future: Smart Output Detection
+
+When stdout is a **terminal**, output JSON (human-readable). When stdout is a **pipe**, output length-delimited protobuf (efficient binary streaming between gtfs-cli commands). `--format` overrides auto-detection. This avoids wasteful proto-to-JSON-to-proto conversion in pipelines while keeping interactive use friendly.
+
+## Source Detection
+
+- Starts with `http://` or `https://` — treated as URL, fetched via HTTP
+- Otherwise — treated as a local file path, read from disk
+- This means saved snapshots and live feeds use the exact same interface
+
+## Examples
+
+```bash
+# Quick look at a live feed (JSON output)
+gtfs-cli fetch "https://gtfsrt.ttc.ca/trips/update?format=binary"
+
+# Inspect a previously saved file
+gtfs-cli fetch trips.pb
+
+# Pipe JSON to jq for quick filtering
+gtfs-cli fetch "https://gtfsrt.ttc.ca/alerts/all?format=binary" | jq '.entity[] | .alert'
+```
+
+## Use Cases
+
+- **Quick inspection**: `gtfs-cli fetch <url>` to see what a feed looks like right now.
+- **Debugging saved files**: same command works on URLs and local files.
+- **Pipeline integration**: JSON output pipes cleanly into jq, scripts, or future gtfs-cli commands.
+
+## IMPLEMENTED
+- `fetch <source>` — URL or local file
+- JSON output to stdout
+- `--timeout` for HTTP sources
+- `--watch <seconds>` with NDJSON streaming, flush-after-write, graceful SIGINT handling
+
+## Watch Mode
+
+`--watch <seconds>` enables continuous fetching at a fixed interval. Each fetch produces one complete JSON object, output as **NDJSON (Newline-Delimited JSON)** — one JSON document per line, flushed immediately after each write.
+
+```bash
+# Fetch trip updates every 30 seconds, filter with jq
+gtfs-cli fetch --watch 30 "https://gtfsrt.ttc.ca/trips/update?format=binary" | jq --unbuffered '.entity[]'
+```
+
+### Why NDJSON
+
+- Each line is a self-contained JSON document — consumers parse line by line
+- `jq` handles this natively, no special flags needed to parse (use `--unbuffered` to avoid jq's own buffering)
+- Python consumers: `for line in sys.stdin: data = json.loads(line)`
+- Plain concatenated JSON (`{}{}`) is not valid JSON — NDJSON uses `\n` as a delimiter to avoid this
+
+### Implementation Notes
+
+- Flush stdout after each JSON write so data reaches the consumer immediately
+- Graceful SIGINT (Ctrl+C) handling — stop cleanly, exit 0
+- Only applies to URL sources (watching a local file doesn't make sense)
+
+## POTENTIAL FEATURES
+- `--format binary|table` output options
+- `--output` file writing
+- TTY auto-detection for output format (JSON for terminal, length-delimited protobuf for pipes)
+
+### Watch reliability improvements
+
+These improvements target long-running `--watch` sessions (hours/days of data collection):
+
+- **Persistent HTTP client** — reuse a single `httpx.Client` with connection pooling instead of creating a new connection per request. Reduces TCP/TLS handshake overhead and is kinder to the server.
+- **Exponential backoff on consecutive failures** — on transient errors (timeout, 503), increase sleep between retries (e.g. 1s → 2s → 4s → …, capped). Reset backoff on success. Avoids hammering a struggling server.
+- **SIGTERM handling** — catch `SIGTERM` (via `signal` module) for clean shutdown when run as a systemd service or in Docker. Currently only `KeyboardInterrupt` (SIGINT) is handled.
+- **Drift-corrected sleep** — instead of `time.sleep(interval)` after each fetch (which drifts by fetch duration), compute the next wall-clock target and sleep until that time. Keeps spacing consistent.
+
+### Output durability for long-running collection
+
+For serious data collection, NDJSON-to-stdout has limits — a crash mid-write can produce partial lines, and restarts lose context. Two durable storage options:
+
+**SQLite (`--output collection.db`)**
+- Append each snapshot as a row with a timestamp. Inherently atomic per transaction — no partial writes.
+- Good for: moderate volume, easy querying (`SELECT * WHERE timestamp > ...`), single-file portability.
+- Schema: `(id INTEGER PRIMARY KEY, fetched_at TEXT, feed_json TEXT)` or normalized tables for entities.
+- Downside: JSON-in-a-column isn't great for columnar analytics. File can grow large without vacuuming.
+
+**Parquet (`--output collection.parquet` or `--output-dir snapshots/`)**
+- Flatten the protobuf into columnar format using polars. One row per entity (trip update / vehicle position / alert), with the snapshot timestamp added as a column.
+- Good for: large-scale analytics, efficient compression, direct use with polars/pandas/DuckDB.
+- Two strategies:
+  - **Single file with append**: buffer N snapshots in memory, append as a row group periodically. Risk: crash loses the buffer.
+  - **Partitioned directory**: write one parquet file per snapshot (or per time window, e.g. hourly). Crash-safe — each file is complete. Use `polars.scan_parquet("snapshots/*.parquet")` to query across them lazily.
+- Partitioned directory is the safer choice for long-running collection. Hourly rotation keeps file count manageable.
+
+**Recommendation**: start with partitioned parquet directory — it's crash-safe, works naturally with polars, and avoids the JSON-in-SQLite compromise. A future `gtfs-cli explore` command can `scan_parquet` the directory for analysis.

gtfs_cli-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "gtfs-cli"
+version = "0.1.0"
+description = "CLI tool to fetch, archive, process and explore GTFS-RT data"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "Vladyslav Moisieienkov" }]
+keywords = ["gtfs", "gtfs-rt", "transit", "cli", "realtime"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+dependencies = [
+    "typer>=0.15.0",
+    "rich>=13.0.0",
+    "gtfs-realtime-bindings>=1.0.0",
+    "httpx>=0.28.0",
+    "protobuf>=5.0.0",
+]
+
+[project.scripts]
+gtfs-cli = "gtfs_cli.main:app"
+
+[project.urls]
+Homepage = "https://github.com/VMois/gtfs-cli"
+Repository = "https://github.com/VMois/gtfs-cli"
+"Bug Tracker" = "https://github.com/VMois/gtfs-cli/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gtfs_cli"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+]

gtfs_cli-0.1.0/src/gtfs_cli/__main__.py

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