timeo 0.2.0__tar.gz

timeo-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches: [main, dev]
+  pull_request:
+    branches: [main, dev]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --all-groups
+
+      - name: Run pre-commit
+        run: uv run pre-commit run --all-files
+
+      - name: Run tests
+        run: uv run pytest

timeo-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published, released]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # required for OIDC trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

timeo-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,20 @@
+name: release-please
+on:
+  push:
+    branches:
+      - main
+permissions:
+  contents: write         # to push tags and changelog
+  issues: write           # (optional) for any issue linkage
+  pull-requests: write    # to create/modify the release PR
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: googleapis/release-please-action@v4
+        with:
+          # Use a GitHub token or personal access token:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          # A simple release strategy (no code version file):
+          release-type: python

timeo-0.2.0/.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+.eggs/
+
+# uv
+.uv/
+uv.lock   # optional — commit this if you want reproducible installs
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Type checking
+.mypy_cache/
+.ruff_cache/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment variables
+.env
+.env.*
+!.env.example

timeo-0.2.0/.pre-commit-config.yaml

@@ -0,0 +1,11 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/psf/black
+    rev: 22.10.0
+    hooks:
+    -   id: black

timeo-0.2.0/.python-version

@@ -0,0 +1 @@
+3.9

timeo-0.2.0/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+
+## [0.2.0](https://github.com/wtewalt/timeo/compare/v0.1.0...v0.2.0) (2026-04-09)
+
+
+### Features
+
+* add smoke test scripts for sequential, concurrent, and live con… ([92f52a8](https://github.com/wtewalt/timeo/commit/92f52a8f7d5a658afd17d9df0abb33ef95f479f7))
+* add smoke test scripts for sequential, concurrent, and live context modes ([6f14c94](https://github.com/wtewalt/timeo/commit/6f14c94cc424ea4afd1885f674e21e395b5e3007))
+* add test suite for task, hashing, cache, decorator, and learn mode ([754fd86](https://github.com/wtewalt/timeo/commit/754fd86a95280c2e7312ba0a02cb79162531d2aa))
+* implement [@timeo](https://github.com/timeo).track decorator, advance(), and iter() ([8894dbf](https://github.com/wtewalt/timeo/commit/8894dbfe853b4e57ef35a4fed97202f4a07107d5))
+* implement learn mode (learn=True) with EMA-driven progress bar ([946ea49](https://github.com/wtewalt/timeo/commit/946ea49b60fe3d512cf4a10f0922193b3479d9cc))
+* implement learn mode (learn=True) with EMA-driven progress bar ([dda6553](https://github.com/wtewalt/timeo/commit/dda6553476345e62bea4dda0943e6392c14b0fda))
+* implement ProgressManager singleton ([d352bb8](https://github.com/wtewalt/timeo/commit/d352bb87be0baddae592e02359bc90e8456c22d2))
+* implement ProgressManager singleton ([83a9151](https://github.com/wtewalt/timeo/commit/83a91510eb4643f4ab7a0e78bfe4d7463af18fec))
+* implement timing cache and function bytecode hashing ([9bf46fb](https://github.com/wtewalt/timeo/commit/9bf46fb491da12e616f9a5582fe5f3ee91d24012))
+* implement timing cache and function bytecode hashing ([7942968](https://github.com/wtewalt/timeo/commit/7942968c7bbb73b5cd290af1b4258677d9550192))
+* implement TrackedTask model ([b7421e3](https://github.com/wtewalt/timeo/commit/b7421e39146bbfdfcf3a9997a86341486cf8f994))
+* scaffold timeo package structure ([fd042bb](https://github.com/wtewalt/timeo/commit/fd042bbb2f2e5e5c0ffca2d2affa9d09875b6cfe))
+
+
+### Bug Fixes
+
+* add future annotations import to task.py for Python 3.9 compat ([6fc84f3](https://github.com/wtewalt/timeo/commit/6fc84f318a5ab8c7ea58bbc608eb308e5832ac39))
+* add future annotations import to task.py for Python 3.9 compat ([e365cf7](https://github.com/wtewalt/timeo/commit/e365cf793dde69fd8faf8aae6c3a640e2a970225))
+* restore ProgressManager implementation on feat/track-decorator branch ([7366fc7](https://github.com/wtewalt/timeo/commit/7366fc7f823f9f890f8a50f3c26301a1b63e3ebc))
+* updated script for initial test ([a02281d](https://github.com/wtewalt/timeo/commit/a02281de1bb0766b0d42d8cbeab4212a8ab11776))
+* use endswith for qualname assertion in learn mode test ([893dda8](https://github.com/wtewalt/timeo/commit/893dda81955ba21af89fc91d318dac303b7673cb))
+
+
+### Documentation
+
+* add CLAUDE.md with project overview and architecture ([369a524](https://github.com/wtewalt/timeo/commit/369a524e7f39c620018b337653b06c6d9b5bc267))
+* add CONVENTIONS.md with commit, branch, pre-commit, and release standards ([2cdb283](https://github.com/wtewalt/timeo/commit/2cdb283ce5b0ca844eaaa6426973cf762e553ddf))
+* add nix shell requirement to development environment section ([7a2b2ec](https://github.com/wtewalt/timeo/commit/7a2b2ec825e755c0490d1bfe7508fc2a5f90e7dc))
+* add stepwise development plan in steps/ ([300f3b8](https://github.com/wtewalt/timeo/commit/300f3b8f2ca8964455c37285dee161af997a33cf))
+* add timing-based progress estimation design to CLAUDE.md ([d6bcb9b](https://github.com/wtewalt/timeo/commit/d6bcb9bcd5c6ac891c55bd8a950b33720f5f8d84))
+* document release-please, PyPI publishing, and pre-commit setup ([7d82fad](https://github.com/wtewalt/timeo/commit/7d82fad72d1682cf1aab0bfd54d14d001906e507))
+* redesign README with badges, tables, and improved formatting ([bdb3f3f](https://github.com/wtewalt/timeo/commit/bdb3f3f22b644847c7423d68a6218276d01600be))
+* resolve all open design questions in CLAUDE.md ([7acf12a](https://github.com/wtewalt/timeo/commit/7acf12a0861a29cb54f23cce5196b1ba4c7ec033))
+* write README with usage examples for basic, learn, and concurrent modes ([87201b5](https://github.com/wtewalt/timeo/commit/87201b5abfa65d905e9b21f426df99a6ff38e35d))
+
+## 0.1.0 (2026-04-03)
+
+
+### Features
+
+* added rich as a dependency ([262c826](https://github.com/wtewalt/timeo/commit/262c826123b46339d83457578962f8a3e08e2cf1))
+* change to release config ([094f8ea](https://github.com/wtewalt/timeo/commit/094f8ea74b23f885fdfb4e9dd0b6ea10a53d6cdd))
+* enabled pre-commit checks and release tracking ([4ab1608](https://github.com/wtewalt/timeo/commit/4ab160830194534141c411777242a81f188294eb))
+* flake added ([826aac3](https://github.com/wtewalt/timeo/commit/826aac3f67c76fbff8bb85fb1db9f570db22929d))
+* new flake ([0f0b1f9](https://github.com/wtewalt/timeo/commit/0f0b1f93b4da0cb7c1d8a0eef50ef48175756de2))
+* new nix config ([858f3ff](https://github.com/wtewalt/timeo/commit/858f3ff2d2af71f401c9b769ff871487e3f37042))
+* updates to release ([1690435](https://github.com/wtewalt/timeo/commit/1690435928b06eeff239a49b448a80aaed3b580f))
+* working flake with uv and pre-commit hooks ([c49b388](https://github.com/wtewalt/timeo/commit/c49b3888c56d8386b07445c39aa1b849e2abaaad))
+
+
+### Bug Fixes
+
+* added changelog ([59d9c6f](https://github.com/wtewalt/timeo/commit/59d9c6f138d6bd8299a8e8cf87b9d3b1f6a87d54))
+* updates to allow release tracking ([76fa10f](https://github.com/wtewalt/timeo/commit/76fa10f46d56eb37b5b821edce96946b4b3e3dda))

timeo-0.2.0/CLAUDE.md

@@ -0,0 +1,206 @@
+# Timeo — Project Guide
+
+## Overview
+
+**Timeo** is a Python package that lets developers annotate functions with a decorator to automatically track and display their progress in the terminal. When a script runs, all decorated functions are rendered together as a collection of live progress bars using `rich`.
+
+## Core Concept
+
+The user imports `timeo`, applies `@timeo.track` (or similar) to any function, and when the script executes, those functions are monitored and displayed as live progress bars in the terminal — all managed automatically without the user needing to manually wire up progress bar logic.
+
+### Example Usage
+
+```python
+import timeo
+
+@timeo.track
+def process_files(files):
+    for file in files:
+        handle(file)
+        timeo.advance()  # or automatic via iteration hooks
+
+@timeo.track
+def download_data(urls):
+    for url in urls:
+        fetch(url)
+        timeo.advance()
+
+process_files(my_files)
+download_data(my_urls)
+```
+
+Terminal output (while running):
+```
+Processing files   ━━━━━━━━━━━━━━━━━━━━━━  45% 0:00:12
+Downloading data   ━━━━━━━━━━━━━━━━━━━━━━━━━━  72% 0:00:04
+```
+
+## Architecture
+
+### Key Components
+
+- **`timeo/decorator.py`** — The `@timeo.track` decorator. Wraps a function, registers it with the progress manager, and starts/stops tracking around the function's execution.
+- **`timeo/manager.py`** — The `ProgressManager` singleton. Owns the `rich.progress.Progress` instance, maintains the registry of tracked tasks, and controls the live display lifecycle.
+- **`timeo/task.py`** — Represents a single tracked task (name, total, current progress, metadata).
+- **`timeo/__init__.py`** — Public API surface. Exports `track`, `advance`, and any other user-facing symbols.
+
+### Design Principles
+
+- **Minimal user friction** — the decorator should be the only required touchpoint.
+- **Non-intrusive** — does not require users to change the internals of their functions beyond adding `timeo.advance()` calls (or wrapping iterables).
+- **Composable** — multiple decorated functions should render together as a unified live display, not separate progress bars.
+- **Graceful degradation** — if `total` is unknown, show a spinner or indeterminate bar rather than failing.
+
+## Dependencies
+
+- **`rich`** — All progress bar rendering, formatting, and live display. Use `rich.progress.Progress` with `rich.live.Live` for the unified multi-bar display.
+
+## Releasing
+
+### Release Process
+
+This repo uses **[release-please](https://github.com/googleapis/release-please)** to automate versioning and changelog generation. It parses conventional commits on `main` to determine the next version and opens a release PR automatically.
+
+- Merge the release-please PR on `main` to cut a new release.
+- On release, a GitHub Actions workflow automatically builds and publishes the package to **PyPI**.
+- The version in `pyproject.toml` is the source of truth and is updated by release-please.
+
+### Conventional Commits
+
+All commits must follow the [Conventional Commits](https://www.conventionalcommits.org/) spec since release-please relies on them to determine version bumps:
+
+| Prefix | Effect |
+|--------|--------|
+| `fix:` | Patch bump |
+| `feat:` | Minor bump |
+| `feat!:` / `BREAKING CHANGE:` | Major bump |
+| `docs:`, `chore:`, `refactor:`, etc. | No version bump |
+
+## Development
+
+### Setup
+
+```bash
+uv sync          # install dependencies
+task dev         # or however the dev environment is activated
+```
+
+### Code Quality
+
+This repo uses **[pre-commit](https://pre-commit.com/)** to enforce code quality on every commit. Hooks are defined in `.pre-commit-config.yaml`.
+
+Install hooks locally (one-time):
+```bash
+pre-commit install
+```
+
+Hooks enforced:
+- **ruff** — linting and formatting
+- **mypy** — static type checking
+- TOML/YAML validation
+
+Run manually against all files:
+```bash
+pre-commit run --all-files
+```
+
+### Project Structure
+
+```
+timeo/
+├── __init__.py       # public API
+├── decorator.py      # @timeo.track implementation
+├── manager.py        # ProgressManager, rich.Progress integration
+└── task.py           # TrackedTask dataclass/model
+```
+
+## Timing-Based Progress Estimation
+
+### Overview
+
+An opt-in mode (`@timeo.track(learn=True)`) that drives the progress bar using elapsed time against an expected duration gleaned from previous runs of that function. Rather than tracking discrete steps, the bar fills as `elapsed / expected_duration`.
+
+### Opt-In Behavior
+
+- Default behavior is **unchanged** — `@timeo.track` with no arguments works as always (step-based or indeterminate).
+- Time-based estimation is activated explicitly: `@timeo.track(learn=True)`.
+- On the **first run** (no cached data yet), display an indeterminate progress bar with a "Learning timing..." label so the user knows data is being collected but no estimate is available yet.
+- On subsequent runs, use the cached EMA estimate to render a determinate time-driven progress bar.
+
+### Local Timing Cache
+
+- Stored at `~/.cache/timeo/timings.json` (use `platformdirs` for cross-platform path resolution).
+- Each entry is keyed by a **hash of the function's bytecode** (`dis` or `inspect` + `hashlib`) rather than its name or module path. This ensures the cache automatically invalidates when the function's implementation changes — a refactored or updated function is treated as a new function with no prior data.
+- Cache entry schema:
+  ```json
+  {
+    "<fn_hash>": {
+      "name": "my_module.process_files",
+      "ema_duration_seconds": 12.4,
+      "run_count": 7,
+      "last_updated": "2026-04-08T00:00:00Z"
+    }
+  }
+  ```
+- `name` is stored for human readability/debugging only — it is never used as a lookup key.
+
+### EMA Strategy
+
+- After each run completes, update the stored estimate using an **Exponential Moving Average**:
+  ```
+  ema = alpha * actual_duration + (1 - alpha) * previous_ema
+  ```
+- Suggested default `alpha = 0.2` (weights recent runs moderately; can be tuned).
+- On the very first run, `ema` is seeded with the actual duration directly (no prior value to blend with).
+- The EMA converges quickly enough that estimates become useful within 3–5 runs.
+
+### Progress Bar Behavior
+
+- The bar advances by `elapsed_time / ema_duration`, updated on a tick interval.
+- If the function **overruns** the estimate, the bar stalls at ~99% rather than exceeding 100% or erroring — it completes to 100% only when the function actually returns.
+- `rich` custom progress columns will be used to render this time-driven bar alongside any step-based bars in the same live display.
+
+### Function Change Detection
+
+- At call time, hash the function's bytecode (`fn.__code__.co_code` or the full `code` object via `marshal`/`hashlib`).
+- If the hash does not match any cached entry, treat it as a brand-new function (show "Learning timing..." and start fresh).
+- Old/stale entries for the previous hash are not automatically deleted — they accumulate silently. A future cache cleanup utility can address this.
+
+## Design Decisions
+
+### `total` — Inferred from `Sized` args
+`timeo` inspects the arguments passed to a decorated function at call time and looks for any that implement `__len__()`. The first `Sized` argument found is used as `total`. No user input required. If no `Sized` argument is found, the bar is indeterminate.
+
+### `advance()` — `contextvars.ContextVar` (under the hood)
+`timeo.advance()` uses a `ContextVar` internally to know which task to update. The decorator pushes the current task onto the `ContextVar` before the function runs and pops it when it returns. This is fully transparent to the user — they only call `timeo.advance()`, no context management required. This also makes concurrent functions safe: threads and async tasks each see their own isolated `ContextVar` value.
+
+### Iteration wrapping — `timeo.iter()`
+`timeo.iter(items)` is supported as a convenience wrapper that automatically calls `advance()` on each iteration, eliminating the need for manual `advance()` calls:
+
+```python
+@timeo.track
+def process_files(files):
+    for f in timeo.iter(files):
+        handle(f)
+```
+
+### Concurrent functions — Stacked bars with completed tasks collapsed
+Multiple simultaneously-running tracked functions are each given their own row in the live display. When a function completes, its bar collapses to a single summary line with a checkmark and elapsed time. Only in-progress bars are shown in full:
+
+```
+✓ process_files    12.4s
+download_data    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  72% 0:00:04
+compress_output  ━━━━━━━━━━                 20% 0:00:31
+```
+
+### Display lifecycle — Hybrid (automatic with optional explicit control)
+By default, the live display starts automatically on the first decorated function call and tears down when the last tracked function finishes. Teardown is guaranteed via `try/finally` in the decorator so exceptions never leave the terminal in a broken state. A reference counter tracks how many tasks are active; the display is torn down when it reaches zero.
+
+For complex scripts where automatic teardown is insufficient (e.g., conditional branching, multiprocessing), the user can take explicit control with a context manager:
+
+```python
+with timeo.live():
+    process_files(my_files)
+    download_data(my_urls)
+# display always tears down cleanly here
+```

timeo-0.2.0/CONVENTIONS.md

@@ -0,0 +1,171 @@
+# Conventions
+
+Best practices and rules for making changes to this repository.
+
+---
+
+## Development Environment
+
+This repo uses [Nix flakes](https://nixos.wiki/wiki/Flakes) to provide a fully reproducible development environment. **All development and testing must be done inside the Nix shell.** Tools like `uv`, `python`, `task`, and `pre-commit` are provided by the Nix environment and may not be available outside of it.
+
+### Entering the shell
+
+```bash
+nix develop
+```
+
+This drops you into a shell with all dependencies and tools available. Run this before doing anything else in the repo.
+
+### Why
+Running commands outside the Nix shell (e.g., using a system Python or a globally installed `uv`) risks version mismatches and unreproducible behaviour. Always use the Nix shell.
+
+---
+
+## Commits
+
+All commits must follow the [Conventional Commits](https://www.conventionalcommits.org/) spec. This is required — release-please parses commit messages on `main` to determine version bumps and generate the changelog automatically.
+
+### Format
+
+```
+<type>[optional scope]: <short description>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+### Types and version impact
+
+| Type | When to use | Version bump |
+|---|---|---|
+| `feat` | A new user-facing feature | Minor (`0.x.0`) |
+| `fix` | A bug fix | Patch (`0.0.x`) |
+| `feat!` / `fix!` | Breaking change (also add `BREAKING CHANGE:` footer) | Major (`x.0.0`) |
+| `refactor` | Code restructuring with no behaviour change | None |
+| `docs` | Documentation only | None |
+| `chore` | Maintenance, dependency updates, config | None |
+| `test` | Adding or updating tests | None |
+| `ci` | CI/CD workflow changes | None |
+| `style` | Formatting, whitespace (no logic change) | None |
+| `perf` | Performance improvement | None |
+
+### Examples
+
+```
+feat: add timeo.iter() convenience wrapper
+fix: reset ContextVar correctly on exception in track decorator
+feat!: rename advance() to step()
+
+BREAKING CHANGE: advance() has been renamed to step() for clarity
+docs: add learn mode usage examples to README
+chore: update rich to 14.4.0
+test: add cache EMA update unit tests
+ci: add Python 3.13 to test matrix
+```
+
+### Rules
+- Use the **imperative mood** in the description ("add", "fix", "update" — not "added", "fixes", "updating").
+- Keep the description under **72 characters**.
+- Do not end the description with a period.
+- If a commit addresses a GitHub issue, reference it in the footer: `Closes #42`.
+
+---
+
+## Branches
+
+| Branch | Purpose |
+|---|---|
+| `main` | Production-ready code only. release-please runs here. |
+| `dev` | Active development branch. All work happens here or in feature branches off `dev`. |
+| `feat/<name>` | Optional feature branches for larger pieces of work, branched from `dev`. |
+
+- Never commit directly to `main` — always go through a PR.
+- PRs from `dev` → `main` should only be made when the code is ready to release.
+
+---
+
+## Pre-commit
+
+This repo uses [pre-commit](https://pre-commit.com/) to enforce code quality automatically on every commit. Hooks are defined in `.pre-commit-config.yaml`.
+
+### Setup (one-time)
+
+```bash
+pre-commit install
+```
+
+This installs the hooks into `.git/hooks/` so they run automatically on `git commit`.
+
+### Hooks that run on every commit
+
+| Hook | What it checks |
+|---|---|
+| `check-yaml` | YAML files are valid |
+| `end-of-file-fixer` | All files end with a newline |
+| `trailing-whitespace` | No trailing whitespace on any line |
+| `black` | Python code is formatted with Black |
+
+### Running manually
+
+To run all hooks against all files (useful before opening a PR):
+
+```bash
+pre-commit run --all-files
+```
+
+To run a specific hook:
+
+```bash
+pre-commit run black --all-files
+```
+
+### Rules
+- Never bypass hooks with `--no-verify` unless there is a documented, exceptional reason.
+- If a hook fails, fix the issue and re-stage before committing — do **not** amend a previous commit to work around it.
+- The CI pipeline also runs `pre-commit run --all-files` — a passing local run is required before pushing.
+
+---
+
+## Code Style
+
+- **Formatter:** [Black](https://black.readthedocs.io/) (enforced by pre-commit).
+- **Line length:** Black's default (88 characters).
+- **Type annotations:** Required on all public functions and methods. mypy must pass with no errors.
+- **Docstrings:** Use for all public modules, classes, and functions. Keep them concise.
+- **Imports:** Standard library first, third-party second, local last — separated by blank lines.
+
+---
+
+## Testing
+
+- All new features must be accompanied by tests in `tests/`.
+- Tests live in `tests/` at the repo root and mirror the `timeo/` module structure (e.g., `timeo/cache.py` → `tests/test_cache.py`).
+- Use `pytest`. Run with:
+  ```bash
+  uv run pytest
+  ```
+- Do not write tests that render to the terminal or write to `~/.cache/timeo/` — mock `ProgressManager` and patch `timeo.cache._cache_path` in tests that touch the cache.
+- Aim for >80% coverage on all modules.
+
+---
+
+## Releasing
+
+Releases are fully automated — do not manually edit version numbers or create GitHub releases by hand.
+
+1. Merge commits following the Conventional Commits spec into `main`.
+2. release-please automatically opens a release PR updating `pyproject.toml` and `CHANGELOG.md`.
+3. Merge the release PR → a GitHub release is created → the publish workflow pushes the new version to PyPI.
+
+See `CLAUDE.md` for full details on the release process.
+
+---
+
+## Dependencies
+
+- Manage dependencies with `uv`. Never edit `uv.lock` by hand.
+- To add a dependency: `uv add <package>`
+- To add a dev dependency: `uv add --dev <package>`
+- Keep `uv.lock` committed and up to date.
+- Pin dependency versions loosely in `pyproject.toml` (e.g., `rich>=14.0`) and let `uv.lock` handle exact pinning.

timeo-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WilliamTewalt
+
+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.