From 62d0b0789cec105b880c34f1d4f581bdb0799f36 Mon Sep 17 00:00:00 2001
From: Levi Neuwirth <ln@levineuwirth.org>
Date: Tue, 14 Apr 2026 09:39:12 -0400
Subject: [PATCH] pin tensorflow, comprehensiveness

---
 .dockerignore                             |   76 +
 CHANGELOG.md                              |  336 +++++
 Dockerfile                                |   89 ++
 README.md                                 |  130 +-
 RESEARCH.md                               |  762 +++++++++++
 docs/getting-started.md                   |   63 +-
 pyproject.toml                            |   36 +-
 scripts/download_model.py                 |   69 +
 src/neuropose/_model.py                   |  356 ++++-
 src/neuropose/analyzer/__init__.py        |   58 +
 src/neuropose/analyzer/dtw.py             |  212 +++
 src/neuropose/analyzer/features.py        |  386 ++++++
 tests/conftest.py                         |   36 +
 tests/integration/test_estimator_smoke.py |  152 ++
 tests/unit/test_analyzer_dtw.py           |  142 ++
 tests/unit/test_analyzer_features.py      |  303 ++++
 uv.lock                                   | 1522 +++++++++++++++++++++
 17 files changed, 4634 insertions(+), 94 deletions(-)
 create mode 100644 .dockerignore
 create mode 100644 CHANGELOG.md
 create mode 100644 Dockerfile
 create mode 100644 RESEARCH.md
 create mode 100644 scripts/download_model.py
 create mode 100644 src/neuropose/analyzer/__init__.py
 create mode 100644 src/neuropose/analyzer/dtw.py
 create mode 100644 src/neuropose/analyzer/features.py
 create mode 100644 tests/integration/test_estimator_smoke.py
 create mode 100644 tests/unit/test_analyzer_dtw.py
 create mode 100644 tests/unit/test_analyzer_features.py
 create mode 100644 uv.lock

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..b5ab46e
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,76 @@
+# ---------------------------------------------------------------------------
+# Files excluded from the Docker build context.
+#
+# The goal is to keep `docker build` fast (small context) and to avoid
+# accidentally baking developer tooling, caches, test data, or
+# IRB-sensitive artifacts into the image. Anything the runtime image
+# actually needs (pyproject.toml, README.md, LICENSE, src/) is copied
+# explicitly in the Dockerfile, so this ignore list can afford to be
+# aggressive.
+# ---------------------------------------------------------------------------
+
+# Version control
+.git
+.gitignore
+.gitattributes
+
+# CI / developer configuration
+.github
+.pre-commit-config.yaml
+.python-version
+
+# Python caches and virtual environments
+.venv
+.venv-*
+venv
+env
+ENV
+**/__pycache__
+**/*.pyc
+**/*.pyo
+**/*.pyd
+*.egg-info
+
+# Lint / type / test caches
+.pytest_cache
+.ruff_cache
+.mypy_cache
+.pyright
+.coverage
+.coverage.*
+htmlcov
+.tox
+
+# Build outputs
+build
+dist
+site
+
+# Editor metadata
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# Documentation sources (mkdocs builds these on the docs CI job, not
+# inside the runtime image) and the mkdocs config itself.
+docs
+mkdocs.yml
+notebooks
+
+# Ancillary developer scripts — the model downloader is useful in a
+# dev context but is redundant inside the image because the daemon
+# pulls the model on first start.
+scripts
+
+# Research / planning artifacts — not needed at runtime.
+RESEARCH.md
+audit.md
+
+# Tests — the image is a runtime artifact, not a test environment.
+tests
+
+# OS / tooling noise
+.DS_Store
+Thumbs.db
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..d8f230a
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,336 @@
+# Changelog
+
+All notable changes to NeuroPose are recorded in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+This section covers the ground-up rewrite of NeuroPose. The entries
+below describe the difference between the previous internal prototype
+and the state of the repository at the first tagged release, and will
+be split into per-release sections once tagging begins.
+
+### Added
+
+#### Package structure and tooling
+
+- `src/neuropose/` package layout with `py.typed` marker, MIT `LICENSE`,
+  policy-enforcing `.gitignore`, pinned Python 3.11 (`.python-version`),
+  and `pyproject.toml` with full project metadata, classifiers, and
+  URL pointers. The runtime TensorFlow dependency is pinned to
+  `tensorflow>=2.16,<3.0` — see *Changed* below for the rationale.
+- `[project.optional-dependencies].analysis` extra for fastdtw, scipy,
+  scikit-learn, and sktime — install via `pip install neuropose[analysis]`.
+- `[project.optional-dependencies].metal` extra pulling
+  `tensorflow-metal>=1.2,<2` under `sys_platform == 'darwin' and
+  platform_machine == 'arm64'` environment markers. Opt-in only via
+  `pip install 'neuropose[metal]'` or `uv sync --extra metal`; silently
+  no-op on every non-Apple-Silicon platform. The Metal path is **not**
+  exercised in CI and is documented as experimental in
+  `docs/getting-started.md` — users enabling it are expected to
+  spot-check numerics against the CPU path before trusting results
+  downstream.
+- `[dependency-groups].dev` (PEP 735) with the full dev + docs + analyzer
+  toolchain: pytest, pytest-cov, ruff, pyright, pre-commit,
+  mkdocs-material, mkdocstrings, fastdtw, and scipy. `uv sync --group dev`
+  gives contributors everything needed to run the whole suite.
+- `AUTHORS.md`, `CITATION.cff` (with a MeTRAbs upstream `references:`
+  entry), and a MIT-licensed `LICENSE` with an explicit MeTRAbs
+  attribution paragraph.
+- Pre-commit configuration (`.pre-commit-config.yaml`) running ruff,
+  ruff-format, gitleaks (secret scanning), a 500 KB-limit
+  large-files hook, end-of-file fixers, trailing-whitespace fixers,
+  and YAML/TOML/JSON validators. Pyright is deliberately **not** in
+  pre-commit — it runs in CI only, so pre-commit stays fast.
+- Ruff configuration in `pyproject.toml` with a deliberately broad
+  rule selection (pycodestyle, pyflakes, isort, bugbear, pyupgrade,
+  simplify, ruff-specific, pep8-naming, comprehensions, pathlib,
+  pytest-style, tidy-imports, numpy-specific, pydocstyle with numpy
+  convention). Per-file ignores for tests and private modules.
+- Pyright configuration in `standard` mode (not `strict` — TF/OpenCV
+  stubs would otherwise drown the signal). Unknown-type reports are
+  explicitly silenced until the TensorFlow version pin is settled.
+- Pytest configuration with strict markers, an opt-in `slow` marker,
+  and a `--runslow` CLI flag implemented in
+  `tests/conftest.py::pytest_collection_modifyitems` so integration
+  tests stay out of the default run.
+
+#### CI / infrastructure
+
+- GitHub Actions workflow `.github/workflows/ci.yml` running three
+  parallel jobs — **lint** (ruff), **typecheck** (pyright), and
+  **test** (pytest) — on every push and PR to `main`. Uses `uv` with
+  a pinned version (`0.9.16`) and cache-enabled setup for fast reruns.
+  Concurrency control cancels superseded runs on the same branch.
+- GitHub Actions workflow `.github/workflows/docs.yml` that builds the
+  mkdocs-material site on every relevant push and uploads the rendered
+  site as a 14-day workflow artifact. GitHub Pages deployment is
+  intentionally not wired up yet; the workflow header comment
+  describes what to add when the repo flips public.
+
+#### Runtime modules
+
+- **`neuropose.config`** — `Settings` class built on
+  `pydantic-settings`. Field-level validation for `device`,
+  `poll_interval_seconds`, and `default_fov_degrees`; explicit
+  `from_yaml()` classmethod (no implicit config-file discovery); XDG
+  defaults for `data_dir` and `model_cache_dir` (`~/.local/share/neuropose/…`)
+  so runtime data never lives inside the repository; `ensure_dirs()`
+  as an explicit method so construction remains filesystem-side-effect-free.
+- **`neuropose.io`** — validated prediction schemas:
+  `FramePrediction` (frozen), `VideoMetadata` (frame count, fps,
+  width, height), `VideoPredictions` (metadata envelope + frames
+  mapping), `JobResults`, `JobStatus` enum, `JobStatusEntry` (with a
+  structured `error` field), and `StatusFile`. Load and save helpers
+  with an atomic tmp-file-then-rename pattern for every state file.
+  `load_status` is deliberately crash-resilient: missing, corrupt,
+  or non-mapping JSON returns an empty `StatusFile` rather than
+  raising.
+- **`neuropose.estimator`** — `Estimator` class that streams frames
+  directly from OpenCV into the model, with no intermediate write-to-
+  disk-then-read-back-as-PNG round trip. Returns a typed
+  `ProcessVideoResult` containing a validated `VideoPredictions`
+  object; does not touch the filesystem. Constructor accepts an
+  injected model for testability; `load_model()` delegates to
+  `neuropose._model.load_metrabs_model()`. Typed exception hierarchy:
+  `EstimatorError`, `ModelNotLoadedError`, `VideoDecodeError`.
+  Optional per-frame `progress` callback for long videos. Frame
+  identifier convention is `frame_000000` (six-digit zero-pad, no
+  extension — no file is implied).
+- **`neuropose.visualize`** — `visualize_predictions()` for per-frame
+  2D + 3D overlay rendering. `matplotlib.use("Agg")` is called inside
+  the function rather than at module import, so `import neuropose.visualize`
+  has no global side effect. Explicit deep-copy of `poses3d` before
+  axis rotation to prevent the aliasing bug from the previous
+  prototype. Supports `frame_indices` for rendering a subset of
+  frames.
+- **`neuropose.interfacer`** — `Interfacer` job-lifecycle daemon with
+  dependency-injected `Settings` and `Estimator`. Single-instance
+  enforcement via `fcntl.flock` on `data_dir/.neuropose.lock`.
+  Crash-recovery `recover_stuck_jobs()` that marks any status entries
+  left in `processing` state as failed with an "interrupted"
+  message and quarantines their inputs. Graceful shutdown on SIGINT/
+  SIGTERM with an interruptible sleep. Structured error fields on
+  every failed job. `run_once()` factored out of the main loop so
+  tests can drive single iterations without threading. Quarantine
+  collision handling (`job_a.1`, `job_a.2`, …) and empty-directory
+  silent-skip heuristic (mid-copy directories are not marked failed).
+- **`neuropose._model`** — MeTRAbs model loader. Downloads the pinned
+  tarball from the upstream RWTH Aachen URL
+  (`metrabs_eff2l_y4_384px_800k_28ds.tar.gz`), verifies its SHA-256
+  checksum, atomically extracts to a staging directory and renames
+  into place, and loads via `tf.saved_model.load`. Streams the
+  download and hash computation in 1 MB chunks so memory is flat.
+  One automatic retry on SHA-256 mismatch (in case the previous
+  download was truncated). Post-load interface check for
+  `detect_poses`, `per_skeleton_joint_names`, and
+  `per_skeleton_joint_edges`.
+- **`neuropose.analyzer`** — post-processing subpackage with lazy
+  imports for the heavy dependencies:
+  - `analyzer.dtw` — three DTW entry points (`dtw_all`,
+    `dtw_per_joint`, `dtw_relation`) over fastdtw, with a frozen
+    `DTWResult` dataclass. See `RESEARCH.md` for the ongoing
+    methodology investigation.
+  - `analyzer.features` — `predictions_to_numpy`,
+    `normalize_pose_sequence` (uniform and axis-wise),
+    `pad_sequences` (edge-padding), `extract_joint_angles` (NaN on
+    degenerate vectors), `extract_feature_statistics`
+    (`FeatureStatistics` frozen dataclass), and a `find_peaks` thin
+    wrapper around `scipy.signal.find_peaks`.
+- **`neuropose.cli`** — Typer-based command-line interface with
+  three subcommands: `watch` (run the daemon), `process <video>`
+  (run the estimator on a single video), and `analyze <results>`
+  (stub). Global options `--config/-c`, `--verbose/-v`, `--quiet/-q`,
+  `--version`. Structured error handling turns expected exceptions
+  (`FileNotFoundError` on config, `ValidationError`, `AlreadyRunningError`,
+  `NotImplementedError`, `KeyboardInterrupt`) into clear stderr
+  messages and distinct exit codes (`EXIT_OK=0`, `EXIT_USAGE=2`,
+  `EXIT_PENDING=3`, `EXIT_INTERRUPTED=130`). The CLI entry point is
+  wired in `[project.scripts]` as `neuropose = "neuropose.cli:run"`.
+
+#### Documentation
+
+- **mkdocs-material documentation site** under `docs/` with the full
+  theme configuration (light/dark toggle, tabs navigation, search),
+  `mkdocstrings` Python handler set to numpy docstring style with
+  source links, and a `pymdownx` extension set for admonitions,
+  tabbed content, collapsible details, and syntax-highlighted code
+  blocks. Nav: Home → Getting Started → Architecture → API Reference
+  (auto-generated from module docstrings) → Development → Deployment.
+- Prose documentation pages: `docs/index.md` (public landing page),
+  `docs/getting-started.md` (install, CLI, output schema, Python API,
+  visualization, troubleshooting), `docs/architecture.md` (three-stage
+  pipeline, data flow, runtime directory layout, design principles),
+  `docs/development.md` (contributor setup, tests, lint/type,
+  commit hygiene, release process stub), and `docs/deployment.md`
+  (systemd user unit, Docker pointer, GPU notes, backup guidance).
+- API reference stubs `docs/api/{config,estimator,interfacer,io,visualize}.md`
+  — each is a two-line file containing a `:::` mkdocstrings directive,
+  so the API documentation is generated from the source docstrings
+  at build time and cannot drift out of sync.
+- `RESEARCH.md` at the repo root: a living R&D log for DTW
+  methodology alternatives and MeTRAbs self-hosting / fine-tuning
+  plans. Not user-facing documentation; not linked from the mkdocs
+  nav.
+
+#### Tests
+
+- `tests/unit/` covering configuration (defaults, validation, YAML
+  loading, env overrides, `ensure_dirs`), IO schema and helpers
+  (roundtrip, atomic save, frozen-model guarantees, corruption
+  tolerance), the estimator (construction, model-guard, process path
+  with fake MeTRAbs model, error paths), the visualize module
+  (smoke tests + an anti-regression check for the audit §6 aliasing
+  bug), the interfacer (construction, discovery, process-job happy
+  and failure paths, stuck-job recovery, lock, run_once,
+  interruptible sleep), the CLI (top-level options, config handling,
+  each subcommand's error path), the analyzer DTW helpers, and the
+  analyzer features helpers.
+- `tests/conftest.py` with an autouse `_isolate_environment` fixture
+  that redirects `$HOME` and `$XDG_DATA_HOME` at a per-test temp
+  directory so no test can accidentally write to the developer's real
+  machine, and clears any `NEUROPOSE_*` env vars. Adds a
+  `synthetic_video` fixture (cv2-generated 5-frame MJPG AVI sized
+  for most unit tests) and a `fake_metrabs_model` fixture.
+- `tests/integration/test_estimator_smoke.py` — end-to-end model
+  loader + estimator smoke test against the real MeTRAbs tarball,
+  marked `@pytest.mark.slow`, skipped by default, opt-in via
+  `--runslow`. Uses a session-scoped model cache so the download
+  happens at most once per run.
+
+#### Operations
+
+- `Dockerfile` — CPU image based on `python:3.11-slim-bookworm`.
+  Installs the package with the `analysis` extra, runs as non-root
+  user `neuropose` (UID 1000), exposes `/data` as a volume, sets
+  `NEUROPOSE_DATA_DIR` and `NEUROPOSE_MODEL_CACHE_DIR` to point at
+  the mounted volume, and uses `ENTRYPOINT ["neuropose"]` with
+  `CMD ["watch"]` so the default is the daemon and overrides are
+  ergonomic.
+- `.dockerignore` that aggressively excludes developer tooling,
+  caches, tests, documentation sources, research notes, and
+  ancillary scripts from the build context.
+- `scripts/download_model.py` — standalone pre-warm script that
+  invokes `load_metrabs_model()` with an optional `--cache-dir`
+  override. Useful for seeding a deployment's cache before cutting
+  off network access.
+
+### Changed
+
+- **Relicensed from AGPL-3.0 (used in the prior internal prototype)
+  to MIT.** The prior license was copied from precedent rather than
+  chosen deliberately; the MIT relicense better matches both the
+  project's "research software others can build on" intent and the
+  upstream MeTRAbs license.
+- Reorganised from the prior `backend/` + runtime-data layout into
+  a `src/neuropose/` Python package. Runtime data now lives outside
+  the repository by default (under `$XDG_DATA_HOME/neuropose/`) so
+  subject-identifying inputs cannot accidentally end up in a
+  `git add`.
+- Frame identifier convention changed from `frame_0000.png` (old,
+  misleading — no PNG file exists) to `frame_000000` (six-digit
+  zero-pad, no extension, pure identifier).
+- Estimator API: `process_video()` now returns a typed
+  `ProcessVideoResult` containing a validated `VideoPredictions`
+  object, instead of a stringly-typed dict with `results_path` and
+  `frame_count`. The estimator no longer owns filesystem
+  destinations — the caller decides where to save.
+- `VideoPredictions` schema now carries a `VideoMetadata` envelope
+  (frame count, fps, width, height) alongside the per-frame
+  predictions. Downstream analysis can convert frame indices to
+  real time without needing access to the original video.
+- Interfacer uses `datetime.now(UTC)` instead of the deprecated
+  `datetime.utcnow()`, addresses the "no-videos"-vs-exception-path
+  inconsistency (both now quarantine), and persists a structured
+  `error` string on every failure for grep-friendly diagnostics.
+- **TensorFlow pin tightened to `tensorflow>=2.16,<3.0`.** The 2.16
+  floor is the first release with native `darwin/arm64` wheels under
+  the `tensorflow` package name on PyPI, so a single dependency line
+  works across Linux x86_64, Linux arm64, and Apple Silicon macOS
+  without platform markers or a separate `tensorflow-macos` package.
+  Empirical verification: the pinned MeTRAbs SavedModel
+  (`metrabs_eff2l_y4_384px_800k_28ds`, serialized with TF 2.10)
+  loads and runs `detect_poses` end-to-end on TF 2.21 + Keras 3 with
+  no errors, and exposes only stock TensorFlow ops (zero MeTRAbs
+  custom kernels). Full test matrix and op inventory in
+  `RESEARCH.md`.
+- Operating-system classifiers in `pyproject.toml` extended from
+  Linux-only to `POSIX` + `POSIX :: Linux` + `MacOS`, reflecting the
+  Apple Silicon support that the TF 2.16 floor makes real.
+
+### Removed
+
+- The previous `backend/analyzer.py` and `backend/validator.py`
+  stubs, which were non-functional and had never been run
+  successfully. `analyzer.py` is reintroduced as a pure-function
+  subpackage (`neuropose.analyzer`) rewritten from the prior
+  code's design intent. `validator.py` is reintroduced as a real
+  pytest suite (`tests/unit/` and `tests/integration/`).
+- The previous `reconstruct_from_frames` helper on the `Estimator`
+  — dead code, broken (dereferenced `self.OUTPUT_PATH`, which did
+  not exist), hardcoded 10 fps, never called. ffmpeg is a better
+  tool for this and can be invoked directly.
+- The previous `__main__` placeholder (`print("in main"); sys.exit()`)
+  on `estimator.py`. The real CLI now lives in `neuropose.cli`.
+- Every file under `docs/` in the previous prototype. All of the
+  pydoc-generated HTML, Org-mode sources, and handwritten markdown
+  described an older version of the API with methods
+  (`bind_and_block`, `construct_paths`, `toggle_visualization`,
+  `propagate_fatal_error`, etc.) that no longer exist. The docs are
+  now auto-generated from source docstrings via mkdocstrings so
+  drift is mechanically impossible.
+- The previous Dockerfile, which referenced a non-existent
+  `backend/requirements.txt`, attempted to `COPY ./model /app/model`
+  (no such directory), and set `CMD ["uvicorn", "main:app"]` for a
+  FastAPI app that never existed.
+- The previous `install/install.sh`, `install/#install.sh#` (an
+  Emacs autosave file), `install/install.sh~` (an Emacs backup file),
+  and `install/environment.yml`. The conda + `git+https` install
+  story is replaced by `uv` + a single `pyproject.toml`.
+- The previous `bit.ly/metrabs_1` URL shortener for the model
+  download, replaced by a pinned canonical URL on the upstream
+  RWTH Aachen "omnomnom" host, with SHA-256 verification on
+  download. See `RESEARCH.md` for the plan to mirror to
+  self-hosted storage.
+
+### Security
+
+- Large-files pre-commit hook (`check-added-large-files` with a
+  500 KB limit) blocks accidental commits of subject data or model
+  weights.
+- Gitleaks pre-commit hook scans every staged change for secret
+  material.
+- Dockerfile runs as a non-root user (UID 1000, `neuropose`) by
+  default.
+- Tarfile extraction uses the `filter="data"` option to block path
+  traversal and other tar-bomb attacks during MeTRAbs model
+  extraction.
+- SHA-256 pinning of the MeTRAbs model artifact. A change to the
+  upstream tarball contents fails the checksum verification and
+  requires a human-reviewed diff before the new artifact is
+  trusted.
+
+### Known limitations
+
+- Apple Silicon support is established by-construction (TF 2.16+
+  publishes native `darwin/arm64` wheels and the MeTRAbs SavedModel
+  uses only stock ops verified portable on TF 2.21) but has not yet
+  been exercised on real Apple Silicon hardware. A `macos-14` CI
+  matrix entry covering the unit tests is the cheapest way to catch
+  any regression and is planned as a follow-up.
+- Classification wrappers on top of sktime are deliberately **not**
+  included in `neuropose.analyzer` for this release. See `RESEARCH.md`
+  for the reasoning and the plan.
+- GPU support in Docker is not yet shipped (`Dockerfile.gpu` is
+  planned). The existing `Dockerfile` runs CPU-only.
+- `neuropose analyze` is a CLI stub that exits with a pending
+  message. The analyzer subpackage is usable from Python directly;
+  the CLI wrapper will follow once the analysis pipeline has a
+  concrete shape worth wrapping.
+- The data-handling policy referenced from `docs/deployment.md` and
+  `docs/index.md` (`docs/data-policy.md`) is being authored
+  separately and is not part of this changelog entry.
+
+[Unreleased]: https://git.levineuwirth.org/neuwirth/neuropose/compare/initial...HEAD
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..695aa53
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,89 @@
+# syntax=docker/dockerfile:1.7
+# ---------------------------------------------------------------------------
+# NeuroPose — CPU Docker image.
+#
+# Builds a minimal CPU-only image running the NeuroPose job-processing
+# daemon (`neuropose watch`). The GPU variant is planned but not
+# shipped in v0.1 — it will live in a separate `Dockerfile.gpu` based
+# on a CUDA-enabled TensorFlow base image.
+#
+# Build:
+#   docker build -t neuropose:latest .
+#
+# Run (daemon mode, the default):
+#   docker run -d \
+#     -v /srv/neuropose/jobs:/data/jobs \
+#     -v /srv/neuropose/models:/data/models \
+#     --name neuropose \
+#     neuropose:latest
+#
+# Run (single-video mode, overriding the default command):
+#   docker run --rm \
+#     -v /srv/neuropose/jobs:/data/jobs \
+#     -v /srv/neuropose/models:/data/models \
+#     -v $PWD/video.mp4:/input.mp4:ro \
+#     neuropose:latest process /input.mp4 --output /data/jobs/result.json
+#
+# Notes:
+# - The Python base image (`python:3.11-slim-bookworm`) is deliberately
+#   not pinned to a specific patch version in this commit. A sha256
+#   digest pin is an easy follow-up once we are ready to commit to a
+#   reproducible build chain.
+# - TensorFlow will be downloaded by pip during the build (~500 MB). The
+#   final image is correspondingly large; optimisation is a future
+#   concern.
+# - The MeTRAbs model itself is NOT baked into the image. It downloads
+#   on first daemon startup into /data/models, which must be mounted
+#   from the host to avoid repeating the download on every container
+#   start.
+# ---------------------------------------------------------------------------
+
+FROM python:3.11-slim-bookworm AS runtime
+
+# System dependencies:
+# - ca-certificates: HTTPS for the MeTRAbs model download.
+# - ffmpeg:          video I/O backend OpenCV calls into.
+# - libgl1, libglib2.0-0: transitive requirements of
+#                         opencv-python-headless on slim images.
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+      ca-certificates \
+      ffmpeg \
+      libgl1 \
+      libglib2.0-0 \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy package metadata first so that source-only edits do not bust
+# the pip cache layer on rebuilds.
+COPY pyproject.toml README.md LICENSE ./
+COPY src/ ./src/
+
+# Install the package system-wide. The `[analysis]` extra pulls in
+# fastdtw / scipy / scikit-learn / sktime so `neuropose analyze`
+# works out of the box inside the container.
+RUN pip install --no-cache-dir ".[analysis]"
+
+# Non-root runtime user. Using UID 1000 to line up with most host-side
+# /data directories; override with `docker run --user` if needed.
+RUN useradd --create-home --uid 1000 neuropose \
+ && mkdir -p /data/jobs /data/models \
+ && chown -R neuropose:neuropose /data
+
+# Point NeuroPose's Settings at the mounted /data volume. These are
+# read by pydantic-settings via the NEUROPOSE_ prefix and override the
+# XDG defaults that would otherwise resolve inside the container's
+# ephemeral filesystem.
+ENV NEUROPOSE_DATA_DIR=/data/jobs \
+    NEUROPOSE_MODEL_CACHE_DIR=/data/models \
+    PYTHONUNBUFFERED=1
+
+USER neuropose
+VOLUME ["/data"]
+
+# The entrypoint is the `neuropose` CLI; the default command is
+# `watch` (daemon mode). Override at `docker run` time to invoke
+# `process` or `analyze` instead.
+ENTRYPOINT ["neuropose"]
+CMD ["watch"]
diff --git a/README.md b/README.md
index fd3d1b6..2db77ad 100644
--- a/README.md
+++ b/README.md
@@ -1,71 +1,119 @@
 # NeuroPose (rewrite)
 
-Ground-up rewrite of the prior NeuroPose internal prototype. 
+Ground-up rewrite of the prior NeuroPose internal prototype. The repository
+is private while the IRB data-handling policy is being authored; this README
+is aimed at contributors working on the rewrite, not external users.
 
-## Target layout
+## Layout
 
 ```text
 neuropose/
-├── .github/workflows/           # CI on the GitHub mirror (ruff + pyright + pytest)
+├── .github/workflows/           # CI: ruff + pyright + pytest (ci.yml), mkdocs (docs.yml)
 ├── src/neuropose/
 │   ├── __init__.py              # version only
 │   ├── config.py                # pydantic-settings Settings class
 │   ├── io.py                    # prediction schema, load/save helpers
-│   ├── estimator.py             # per-video MeTRAbs worker (ported, cleaned)
-│   ├── interfacer.py            # filesystem-polling daemon (ported, cleaned)
-│   ├── cli.py                   # typer app (`neuropose run|watch|analyze`)
-│   ├── _model.py                # MeTRAbs model load + local cache
-│   └── analyzer/                # rewrite of the prior analyzer.py
+│   ├── estimator.py             # per-video MeTRAbs worker
+│   ├── interfacer.py            # filesystem-polling daemon
+│   ├── visualize.py             # per-frame 2D + 3D overlay rendering
+│   ├── cli.py                   # typer app (watch | process | analyze)
+│   ├── _model.py                # MeTRAbs download + SHA-256 verify + load
+│   └── analyzer/                # post-processing subpackage
 │       ├── dtw.py               # FastDTW helpers
-│       ├── features.py          # normalization, padding, joint angles
-│       └── classification.py    # sktime classifier wrappers
+│       └── features.py          # normalization, padding, joint angles, stats
 ├── tests/
+│   ├── conftest.py              # env isolation, synthetic video, fake model
 │   ├── unit/                    # fast, no model download
-│   ├── integration/             # marked @slow, downloads the model
-│   └── fixtures/                # synthetic video + reference predictions
-├── docs/                        # mkdocs-material site
-├── notebooks/                   # getting_started.ipynb, tested in CI via nbval
-├── config/default.yaml          # example runtime config
-├── scripts/download_model.py
-├── pyproject.toml               # hatchling build, typer + pydantic + TF stack
-├── Dockerfile                   # CPU, pinned deps
+│   └── integration/             # marked @slow, downloads the real MeTRAbs model
+├── docs/                        # mkdocs-material site (mkdocs.yml at repo root)
+├── scripts/download_model.py    # pre-warm the model cache
+├── pyproject.toml               # hatchling build, dev group (PEP 735)
+├── Dockerfile                   # CPU image, non-root, /data volume
+├── CHANGELOG.md                 # Keep a Changelog format
+├── RESEARCH.md                  # DTW methodology + MeTRAbs self-hosting R&D log
 ├── AUTHORS.md
 ├── CITATION.cff
 └── LICENSE                      # MIT
 ```
+
 ## Architecture
 
 Three stages, one module each:
 
-- **`estimator`** — per-video worker. Extracts frames from an input video,
-  runs MeTRAbs on each frame, and writes per-frame predictions (`boxes`,
-  `poses3d`, `poses2d`) to JSON. No daemon logic; usable directly from Python.
+- **`estimator`** — per-video worker. Streams frames from an input video via
+  OpenCV, runs MeTRAbs on each frame, and returns a validated
+  `VideoPredictions` (per-frame `boxes`, `poses3d`, `poses2d` plus a
+  `VideoMetadata` envelope with frame count, fps, and resolution). Pure
+  library — no filesystem semantics.
 - **`interfacer`** — filesystem-polling daemon. Watches the configured input
   directory for new job subdirectories, dispatches each to an `Estimator`,
-  and persists job state (`status.json`) across crashes and restarts. Owns
-  the input → output → failed directory lifecycle.
+  and persists job state (`status.json`) across crashes and restarts. Single
+  instance enforced via `fcntl.flock`. Owns the input → output → failed
+  directory lifecycle.
 - **`analyzer`** — post-processing subpackage. FastDTW-based motion
-  comparison, joint-angle feature extraction, and sktime classifier wrappers.
-  Operates on the JSON output of the estimator.
+  comparison (`dtw_all`, `dtw_per_joint`, `dtw_relation`) and joint-angle /
+  feature-statistics helpers. Pure functions operating on `VideoPredictions`.
+  Heavy dependencies (fastdtw, scipy) are lazy-imported so
+  `import neuropose.analyzer` works without the `analysis` extra.
 
 Configuration is centralized in `src/neuropose/config.py` (a
 pydantic-settings `Settings` class). The runtime data directory defaults to
 `$XDG_DATA_HOME/neuropose/jobs/` and never lives inside the repository.
 
-## Commit plan
+## Development setup
 
-| # | Scope | State |
-|---|---|---|
-| 1 | Scaffolding: package layout, MIT license, authors, citation, policy-aware `.gitignore` | in review |
-| 2 | Dev tooling: pre-commit, ruff, pyright, gitleaks | planned |
-| 3 | CI workflow on the GitHub mirror | planned |
-| 4 | `config.py`, `io.py`, unit tests | planned |
-| 5 | Port `estimator.py` with typing and audit §6 fixes | planned |
-| 6 | Port `interfacer.py` with audit §7 fixes | planned |
-| 7 | Typer CLI (`neuropose run|watch|analyze`) | planned |
-| 8 | mkdocs-material docs site | planned |
-| 9 | Data-handling policy (gates going public) | blocked on IRB prose |
-| 10 | `analyzer/` subpackage rewrite | planned |
-| 11 | MeTRAbs model loader + integration smoke test | blocked on upstream URL + TF pin |
-| 12 | Dockerfile | blocked on 11 |
-| 13 | Comprehensive `CHANGELOG.md` retroactive entry | blocked on 12 |
+Requires Python 3.11 and [`uv`](https://github.com/astral-sh/uv).
+
+```bash
+git clone https://git.levineuwirth.org/neuwirth/neuropose.git
+cd neuropose
+uv sync --group dev
+```
+
+`uv sync --group dev` creates `.venv/` automatically and installs the
+runtime stack (pydantic, typer, OpenCV, TensorFlow, matplotlib) plus the
+full dev toolchain (pytest, ruff, pyright, pre-commit, mkdocs-material,
+fastdtw, scipy). First sync downloads ~600 MB of TensorFlow; subsequent
+runs hit the uv cache.
+
+Install the pre-commit hooks:
+
+```bash
+uv run pre-commit install
+```
+
+### Running tests
+
+```bash
+uv run pytest                  # unit tests only (default)
+uv run pytest --runslow        # unit + integration; downloads ~2 GB MeTRAbs model
+uv run pytest -m "not slow"    # explicitly exclude slow tests
+```
+
+Integration tests live under `tests/integration/` and are gated behind
+`@pytest.mark.slow` plus a custom `--runslow` flag implemented in
+`tests/conftest.py`. Without the flag, slow tests are skipped at collection
+time. The first `--runslow` run downloads the pinned MeTRAbs tarball
+(~2 GB) into a session-scoped temp cache; subsequent tests in the same run
+reuse it.
+
+### Lint and type-check
+
+```bash
+uv run ruff check .
+uv run ruff format .
+uv run pyright
+```
+
+CI runs lint, typecheck, and test as three parallel jobs on every push and
+PR to `main` — see `.github/workflows/ci.yml`.
+
+### Docs
+
+```bash
+uv run mkdocs serve            # live-reload preview at http://127.0.0.1:8000
+uv run mkdocs build --strict   # same check CI runs
+```
+
+The API reference pages under `docs/api/` are auto-generated from source
+docstrings via mkdocstrings, so they cannot drift out of sync.
diff --git a/RESEARCH.md b/RESEARCH.md
new file mode 100644
index 0000000..d263f91
--- /dev/null
+++ b/RESEARCH.md
@@ -0,0 +1,762 @@
+# NeuroPose Research and Ideation Notes
+
+A living R&D log for open design questions, speculative directions, and
+planned experiments that are larger in scope than individual commits.
+This is **not** user-facing documentation — items in here are
+*candidates* for future work, and inclusion does not imply commitment.
+
+## How to use this document
+
+- Add a section when you start thinking about a new area of investigation.
+- Each section should end with an **Open questions** or **Next steps**
+  block so it's obvious to a future you (or a new contributor) what the
+  active threads are.
+- When something in here is decided and implemented, move it to the
+  relevant place in `docs/` or in the code itself and leave a short
+  pointer behind ("*See `docs/architecture.md` for the resolved design.*").
+- Consider the audience: yourself, Dr. Shu, David, Praneeth, and future
+  contributors. Assume they know pose estimation at a grad-student level
+  but may not have followed every prior conversation.
+
+## Contents
+
+- [DTW methodology](#dtw-methodology)
+- [TensorFlow version compatibility](#tensorflow-version-compatibility)
+- [MeTRAbs hosting and extensibility](#metrabs-hosting-and-extensibility)
+
+---
+
+## DTW methodology
+
+### Current implementation (v0.1, commit 10)
+
+`neuropose.analyzer.dtw` ships three entry points, all built on top of
+[`fastdtw`](https://github.com/slaypni/fastdtw) with
+`scipy.spatial.distance.euclidean` as the point-distance function:
+
+- **`dtw_all(a, b)`** — single DTW on flattened `(frames, joints × 3)`
+  vectors. One scalar distance for the whole sequence.
+- **`dtw_per_joint(a, b)`** — one DTW call per joint, returning a list
+  of per-joint distances and warping paths. Preserves per-joint
+  temporal alignment at J× the cost.
+- **`dtw_relation(a, b, joint_i, joint_j)`** — DTW on the per-frame
+  displacement vector between two specific joints. The intent here is
+  to capture "how does the relationship between these two joints change
+  over time", which is translation-invariant and so immune to raw
+  camera-frame changes.
+
+These three correspond directly to the three helpers that existed
+(broken) in the previous prototype's `analyzer.py`, ported forward with
+bug fixes, types, and tests. **The port was mechanical — not a
+methodological choice.** We inherited the FastDTW + Euclidean defaults
+without validating them against the clinical research use cases, and
+that validation is overdue.
+
+### Known limitations of the v0.1 approach
+
+#### FastDTW is an approximation, not exact DTW
+
+[FastDTW](https://cs.fit.edu/~pkc/papers/tdm04.pdf) is a multi-scale
+approximation that runs in linear time by recursively refining a coarse
+alignment. For the radius-based implementation in
+`slaypni/fastdtw`, the distance is not guaranteed to match exact DTW,
+and in pathological cases the error can be significant. For a research
+codebase where the DTW distance is going to show up in a figure, that
+matters.
+
+**Candidate exact alternatives** (all pip-installable):
+
+- [`dtaidistance`](https://github.com/wannesm/dtaidistance) — C-based,
+  supports both exact DTW and a `fast=True` approximation; also
+  supports shape-DTW and various constraint bands. Actively maintained,
+  and the underlying algorithms match the textbook.
+- [`tslearn`](https://tslearn.readthedocs.io/) — ML-flavored toolkit
+  with exact DTW, soft-DTW (differentiable), Sakoe-Chiba banding, and
+  kernel-DTW. Good fit if we ever want to feed DTW distances into an
+  sklearn/PyTorch pipeline.
+- [`cdtw`](https://github.com/statefb/dtw-python) / `dtw-python` —
+  Python port of the R `dtw` package; exhaustive options for windowing,
+  step patterns, and open-ended alignment. Less friendly API but the
+  most rigorously documented.
+
+#### Euclidean is a choice, not a default
+
+Treating `(x, y, z)` joint positions as a point in R³ and taking
+Euclidean distances implicitly assumes the three axes are commensurable
+in the same units, which is fine for MeTRAbs (mm) but throws away prior
+knowledge about human motion. Alternatives worth considering:
+
+- **Angular distance on joint angles.** Compute joint angles per frame
+  (`extract_joint_angles` already exists) and run DTW on the angle
+  sequences rather than raw coordinates. Translation- and
+  scale-invariant by construction; well-matched to clinical metrics
+  like knee flexion angle.
+- **Geodesic distance on SO(3)** for local joint rotations. Requires a
+  skeleton-rooted rotation parameterization; more work to set up but
+  the right metric for "how different are these two poses?" in a
+  biomechanics sense.
+- **Mahalanobis distance** against a learned pose prior. This is the
+  "machine learning" answer — fit a covariance to a reference corpus
+  (normal gait from a healthy cohort), then measure distances in the
+  whitened space. Requires enough data to fit the prior without
+  overfitting, but makes "is this gait abnormal?" a calibrated question.
+
+#### Preprocessing: what invariance do we want?
+
+The v0.1 implementation is not invariant to anything. Two videos of the
+same subject with a different camera position will give a different
+DTW distance, which is almost certainly not what a clinician wants.
+Candidate preprocessing steps:
+
+- **Translation invariance**: subtract the root joint (pelvis or torso
+  centroid) from every joint per frame, so all poses are expressed in a
+  body-relative coordinate frame. Cheap and almost always desired.
+- **Scale invariance**: divide by a reference length (e.g., torso
+  length, or total skeleton span) so tall and short subjects produce
+  comparable distances. Important for comparing across subjects.
+- **Rotation invariance**: align to a canonical frame (e.g., hip-to-hip
+  vector = x-axis, hip-to-shoulder = z-axis) per frame. Required if the
+  subject's orientation relative to the camera varies between trials.
+- **Procrustes alignment per frame**: fit the best rigid transform
+  (rotation + translation) between pose A's frame and pose B's frame
+  before computing distance. The closed-form
+  [Kabsch algorithm](https://en.wikipedia.org/wiki/Kabsch_algorithm) is
+  fast and exact. This is likely the *right* thing for most comparison
+  use cases but has never been wired up.
+
+The `dtw_relation` helper is translation- and (for unit-vector
+displacements) scale-invariant by construction, which is why it ends up
+being the most useful of the three existing entry points in practice.
+
+#### Representation: coordinates, angles, velocities, or dual?
+
+The v0.1 DTW operates on **3D joint coordinates** (translation-dependent)
+or **joint-pair displacements** (`dtw_relation`). Other representations
+worth comparing:
+
+- **Joint angles.** Using `extract_joint_angles` output as the DTW
+  input gives a rotation-and-translation-invariant comparison that's
+  also directly interpretable in clinical terms.
+- **Joint velocities.** Temporal derivatives of position. Emphasizes
+  *how the pose changes* rather than *what it is* — good for
+  discriminating smooth from jerky motion in gait.
+- **Dual (position + angle).** Concatenate normalized position and
+  angle features into a single per-frame vector. More expressive but
+  requires tuning the relative weights.
+- **Learned embeddings.** Feed each frame through a pretrained
+  pose-representation network (there are a few) and DTW on the
+  embedding space. Expensive and opaque but may capture
+  higher-order structure.
+
+#### Multi-scale approaches
+
+FastDTW is already multi-scale internally. Other ideas:
+
+- **Coarse-to-fine DTW.** Downsample aggressively, run exact DTW on
+  the coarse version to get a sub-quadratic alignment, then refine
+  locally. This is essentially what FastDTW does, but with an explicit
+  signal-processing hat on.
+- **Wavelet-decomposed DTW.** Decompose each joint's trajectory into
+  wavelet coefficients and run DTW on the low-frequency coefficients.
+  Unclear whether this actually helps; interesting because it separates
+  posture (low-frequency) from tremor / micro-motion (high-frequency).
+
+#### Clinical gait: cycle-aware DTW
+
+Gait is approximately periodic, and "the 4th heel-strike of trial A"
+is the clinically meaningful comparison point to "the 4th heel-strike
+of trial B", not "frame 120 of A vs frame 120 of B". A natural two-stage
+approach:
+
+1. **Cycle detection.** Find heel-strikes (or other gait events) via
+   peak detection on a joint's vertical coordinate, and segment each
+   trial into individual cycles.
+2. **Per-cycle DTW.** Time-warp within each cycle independently to
+   normalize cycle duration. The distance between trials is then the
+   sum / mean of per-cycle distances.
+
+This is standard in the biomechanics literature
+([Sadeghi et al. 2000](https://doi.org/10.1016/S0966-6362(00)00074-3)
+and descendants) and is almost certainly a better fit for clinical
+comparison than the naive full-trial DTW we ship today.
+
+#### Soft-DTW for learning applications
+
+[Soft-DTW](https://arxiv.org/abs/1703.01541) is a differentiable
+relaxation of DTW, which means gradients can flow through it. This
+matters if we ever want to train a network to *learn* a distance
+metric or an embedding under a DTW objective — for example, a pose
+encoder whose output space is calibrated to gait similarity. Worth
+keeping on the radar even if we're not training anything today.
+`tslearn` implements it.
+
+### Evaluation strategy
+
+Validating a DTW implementation is harder than validating most things.
+Some ideas for how to know we got it right:
+
+- **Synthetic perturbations.** Take a reference sequence and apply
+  known perturbations (time stretch, added noise, spatial offset) and
+  verify that distance scales monotonically with perturbation magnitude
+  and that invariance properties are honored.
+- **Reference implementation parity.** For a small set of hand-picked
+  pairs, compute DTW distance using `dtaidistance` exact DTW and
+  our implementation, and verify the approximation error is below a
+  documented threshold.
+- **Inter-rater clinical benchmark.** When we have labeled clinical
+  data, measure how well DTW distance correlates with clinician
+  ratings of gait similarity. This is the real test but is gated on
+  having data we can use.
+- **Pathology discrimination.** Can DTW distance separate healthy
+  from impaired gait in a held-out set? This is the usefulness test.
+
+### Open questions
+
+1. Is FastDTW good enough, or should we move to `dtaidistance` exact
+   DTW as the default? (First concrete experiment: pick 20 pairs from
+   whatever reference data we can source, compute distance both ways,
+   see if the approximation error is acceptable.)
+2. What's the right representation for clinical gait DTW — raw
+   coordinates, joint angles, or per-pair displacements?
+3. Should we implement Procrustes alignment as a preprocessing step
+   before any DTW call? (If yes, it belongs in `neuropose.analyzer.features`.)
+4. Should the clinical pipeline use cycle-segmented DTW instead of
+   full-trial DTW? This is a methodological choice with real
+   downstream implications.
+5. Is soft-DTW useful to us, or is it a solution looking for a
+   problem we don't have?
+6. What reference corpus do we use to develop and validate any of this?
+
+### Reading list
+
+- Sakoe, H. & Chiba, S. (1978). "Dynamic programming algorithm
+  optimization for spoken word recognition." The original DTW paper.
+- Salvador, S. & Chan, P. (2007). "Toward accurate dynamic time
+  warping in linear time and space."
+  [PDF](https://cs.fit.edu/~pkc/papers/tdm04.pdf). The FastDTW paper.
+- Cuturi, M. & Blondel, M. (2017). "Soft-DTW: a Differentiable Loss
+  Function for Time-Series." [arXiv 1703.01541](https://arxiv.org/abs/1703.01541).
+- Sadeghi, H. et al. (2000). "Symmetry and limb dominance in able-bodied
+  gait: a review." Biomechanics reference for cycle-aware analysis.
+- `dtaidistance` documentation —
+  <https://dtaidistance.readthedocs.io/>. Worth reading even if we
+  don't switch, for the overview of DTW variants and constraints.
+
+### Next steps
+
+- [ ] Pick 10–20 reference pose-sequence pairs and run both FastDTW and
+      exact DTW on them to quantify the approximation error.
+- [ ] Prototype a Procrustes-aligned preprocessing wrapper and
+      re-run the same pairs.
+- [ ] Sketch a cycle-aware DTW pipeline against a gait dataset we can
+      actually use (identity- and IRB-safe).
+- [ ] Decide whether to keep FastDTW as the default or replace it.
+- [ ] If we replace it: migrate `neuropose.analyzer.dtw` to the new
+      backend in a single commit with no API change.
+
+---
+
+## TensorFlow version compatibility
+
+### The question
+
+The pinned MeTRAbs model artifact
+(`metrabs_eff2l_y4_384px_800k_28ds.tar.gz`) is a TensorFlow SavedModel.
+SavedModels embed a producer TF version and depend on a set of TF op
+kernels. Picking a TF version pin that is too low risks Apple Silicon
+install pain (pre-2.16 has no native `darwin/arm64` wheel under the
+`tensorflow` package name); picking one that is too high risks loading
+or runtime failures if MeTRAbs uses ops that have been renamed,
+deprecated, or removed. The goal of this investigation was to find the
+**minimum** pin that works on Linux x86_64, Linux arm64, and macOS arm64
+without forcing platform-conditional dependencies or shipping
+`tensorflow-metal` as a default.
+
+### Method
+
+Phase 0 of the procedure laid out earlier in this document was to
+inspect the SavedModel directly and run `detect_poses` end-to-end on a
+synthetic input. The probe script (`test.py` at the repo root, kept
+during the investigation and removed in the same commit that landed the
+pin) did three things:
+
+1. Parsed `saved_model.pb` with `saved_model_pb2.SavedModel` and read
+   the `tensorflow_version` and `tensorflow_git_version` fields out of
+   each `meta_info_def` to establish the **producer** version.
+2. Walked every `node.op` and `library.function[*].node_def[*].op` in
+   the graph to enumerate the **complete set of ops** the model relies
+   on. This is the binary-compatibility surface — anything in this set
+   that gets removed in a future TF release breaks the model.
+3. Called `tf.saved_model.load(MODEL_DIR)`, accessed
+   `per_skeleton_joint_names["berkeley_mhad_43"]`, and invoked
+   `model.detect_poses(image, intrinsic_matrix=..., skeleton="berkeley_mhad_43")`
+   on a 288×384 black frame to confirm the consumer TF version actually
+   *runs* the model (not just loads it — these are different failure
+   modes).
+
+The probe ran on Linux x86_64 against whatever `uv sync --group dev`
+resolved at the time, which was **TensorFlow 2.21.0** with **Keras
+3.14.0** — i.e. the most recent TF release as of 2026-04 and a version
+that crosses the Keras-3 cutover at TF 2.16.
+
+### Result
+
+- **Producer version:** `tf version: 2.10.0`,
+  `producer: v2.10.0-0-g359c3cdfc5f`. The model was serialized in
+  September 2022, consistent with the file mtimes in the extracted
+  tarball.
+- **Custom ops:** **zero**. `tf.raw_ops.__dict__` filtered for
+  `"metrabs"` returned `[]`. Every op in the SavedModel is a stock
+  TensorFlow kernel that has been stable since at least TF 2.4.
+- **Op inventory** (recorded for posterity so a future contributor can
+  diff against a newer MeTRAbs release without re-running the probe):
+
+  ```
+  Abs, Add, AddV2, All, Any, Assert, AssignVariableOp, AvgPool,
+  BatchMatMulV2, BiasAdd, Bitcast, BroadcastArgs, BroadcastTo, Cast,
+  Ceil, Cholesky, CombinedNonMaxSuppression, ConcatV2, Const, Conv2D,
+  Cos, Cross, Cumsum, DepthwiseConv2dNative, Einsum, EnsureShape, Equal,
+  Exp, ExpandDims, Fill, Floor, FloorDiv, FloorMod, FusedBatchNormV3,
+  GatherV2, Greater, GreaterEqual, Identity, IdentityN, If,
+  ImageProjectiveTransformV3, LeakyRelu, Less, LessEqual, Log,
+  LogicalAnd, LogicalNot, LogicalOr, LookupTableExportV2,
+  LookupTableFindV2, LookupTableImportV2, MatMul, MatrixDiagV3,
+  MatrixInverse, MatrixSolveLs, MatrixTriangularSolve, Max, MaxPool,
+  Maximum, Mean, MergeV2Checkpoints, Min, Minimum, Mul,
+  MutableDenseHashTableV2, Neg, NoOp, NonMaxSuppressionWithOverlaps,
+  NotEqual, Pack, Pad, PadV2, PartitionedCall, Placeholder, Pow, Prod,
+  RaggedRange, RaggedTensorFromVariant, RaggedTensorToTensor,
+  RaggedTensorToVariant, Range, Rank, ReadVariableOp, RealDiv, Relu,
+  Reshape, ResizeArea, ResizeBilinear, RestoreV2, ReverseV2,
+  RngReadAndSkip, SaveV2, Select, SelectV2, Shape, ShardedFilename,
+  Sigmoid, Sin, Size, Slice, Softplus, Split, SplitV, Sqrt, Square,
+  Squeeze, StatefulPartitionedCall, StatelessIf,
+  StatelessRandomUniformV2, StatelessWhile, StaticRegexFullMatch,
+  StridedSlice, StringJoin, Sub, Sum, Tan, Tanh, TensorListConcatV2,
+  TensorListFromTensor, TensorListGetItem, TensorListReserve,
+  TensorListSetItem, TensorListStack, Tile, TopKV2, Transpose, Unpack,
+  VarHandleOp, Where, While, ZerosLike
+  ```
+
+- **Load:** `tf.saved_model.load` returned a `_UserObject` with
+  `detect_poses` exposed. No warnings about deprecated kernels, no
+  errors. The 11-minor-version forward jump from producer 2.10 to
+  consumer 2.21 was a non-event, including the Keras 3 cutover at 2.16.
+- **Skeleton check:** `per_skeleton_joint_names["berkeley_mhad_43"]` had
+  shape `(43,)` and `per_skeleton_joint_edges["berkeley_mhad_43"]` had
+  shape `(42, 2)`, exactly matching what
+  `tests/integration/test_estimator_smoke.py` asserts.
+- **End-to-end inference:** `model.detect_poses` on a black 288×384
+  frame returned `{'poses3d': (0, 43, 3), 'boxes': (0, 5),
+  'poses2d': (0, 43, 2)}`, all `float32`. Zero detections is the
+  correct output for a black frame — the important signal is that the
+  shapes, dtypes, and key names exactly match what `FramePrediction` in
+  `neuropose.io` is built to ingest, so the entire estimator pipeline
+  is wire-compatible with this TF version.
+
+### Decision
+
+Pin `tensorflow>=2.16,<3.0`. Reasoning:
+
+1. **2.16 is the Apple Silicon floor that matters.** TF 2.16 is the
+   first release with native `darwin/arm64` wheels published on PyPI
+   under the `tensorflow` package name. Below 2.16, Mac users would
+   need `tensorflow-macos` (a separate Apple-maintained package), which
+   forces ugly platform markers in `pyproject.toml` and means Linux and
+   Mac users run subtly different codebases. Above 2.16, the same
+   single dependency line installs cleanly on every supported platform.
+2. **MeTRAbs imposes no upper bound below 3.0.** Producer 2.10 → consumer
+   2.21 (an 11-minor-version jump across the Keras 3 boundary) loaded
+   and ran without a single complaint. The op inventory is 100% stock,
+   so future TF 2.x releases would only break this if they removed
+   stable kernels — which would itself be a TF 2.x SemVer violation.
+3. **`tensorflow-metal` is an opt-in extra, not a default.**
+   `tensorflow-metal` is a PluggableDevice that Apple ships separately
+   to add a Metal-backed `/GPU:0`. It has its own version-compatibility
+   table (Apple maintains it at
+   `developer.apple.com/metal/tensorflow-plugin/`), has a documented
+   history of producing silently-wrong numerics on specific TF ops,
+   and breaks intermittently on Keras 3. For a clinical-research
+   pipeline where reproducibility matters more than inference latency,
+   CPU inference on Mac is the right default. We do ship a
+   `[project.optional-dependencies].metal` extra that pulls
+   `tensorflow-metal>=1.2,<2` under darwin/arm64 platform markers, so
+   users who want the speedup can opt in via
+   `pip install 'neuropose[metal]'` — but the Metal path is not
+   exercised in CI, is documented as experimental in
+   `docs/getting-started.md`, and users are expected to spot-check
+   `poses3d` output against the CPU path before trusting it for any
+   clinical measurement.
+
+### What is **not** yet verified
+
+- The probe ran on Linux x86_64 only. macOS arm64 has not been exercised
+  on real hardware. The argument that it should work is by construction
+  — `tensorflow==2.16+` ships native arm64 macOS wheels, the SavedModel
+  uses zero custom ops, and there is no MeTRAbs-side platform code — but
+  empirical confirmation is still pending.
+- Linux arm64 has likewise not been exercised. Same by-construction
+  argument applies.
+- A `macos-14` GitHub Actions matrix entry (which would run the unit
+  tests on Apple Silicon hardware) is the cheapest way to catch any
+  regression and is the intended follow-up.
+- Inference-output numerics have not been compared across platforms.
+  This is the next layer of rigor below "does it run" — we expect
+  fp32 results to match within ~1e-3 mm on `poses3d`, but a real
+  cross-platform diff against a reference set has not been done.
+- The `[metal]` optional-dependencies extra exists in `pyproject.toml`
+  but the Metal code path has never been exercised against the
+  pinned MeTRAbs SavedModel. Enabling it is a pure opt-in and comes
+  with a documented "verify your own numerics" caveat in
+  `docs/getting-started.md`. Whether it actually produces a speedup
+  on EfficientNetV2-L-based inference on real clinical videos —
+  and whether that speedup is worth the numerical-divergence risk
+  — is unknown.
+
+### Open questions
+
+1. Does the same `detect_poses` call produce numerically equivalent
+   `poses3d` on macOS arm64 as on Linux x86_64 against a real (non-black)
+   reference image? Within what tolerance?
+2. If a future MeTRAbs release introduces a custom op (e.g. for a new
+   detector head), how do we want the loader to fail? Currently the
+   `_REQUIRED_MODEL_ATTRS` interface check would still pass; the failure
+   would surface at first `detect_poses` call, which is late.
+3. Does it make sense to upper-bound the pin more tightly than `<3.0`
+   (e.g. `<2.22` to bound to tested versions), or is the SemVer guard
+   sufficient given the all-stock-ops result?
+
+### Next steps
+
+- [ ] Run the same probe on real macOS arm64 hardware and log the
+      result (load success, detect_poses success, output numerics
+      diff against the Linux baseline).
+- [ ] Add a `macos-14` matrix entry to `.github/workflows/ci.yml` for
+      the unit tests. Slow tests stay Linux-only to avoid doubling the
+      MeTRAbs download cost in CI.
+- [ ] Re-run the probe whenever MeTRAbs upstream publishes a new model
+      tarball, and diff the op inventory above. Any new op that is not
+      in the list above is a flag worth investigating before raising
+      the pin.
+- [ ] Benchmark `[metal]` vs CPU on a real Apple Silicon Mac against
+      a short reference clip: measure (a) per-frame latency, (b) peak
+      memory, and (c) `poses3d` divergence from the CPU baseline. If
+      the speedup is meaningful and the numerics are within
+      ~1e-2 mm, move the `metal` extra from "experimental" to
+      "supported" in the docs. If not, document the failure mode
+      here and keep the extra where it is.
+
+---
+
+## MeTRAbs hosting and extensibility
+
+### Current state (v0.1, commit 11)
+
+The model loader in `neuropose._model.load_metrabs_model` will pin the
+canonical upstream URL:
+
+```
+https://omnomnom.vision.rwth-aachen.de/data/metrabs/metrabs_eff2l_y4_384px_800k_28ds.tar.gz
+```
+
+This is the RWTH Aachen "omnomnom" host — a raw HTTP file server run
+by the MeTRAbs authors' lab. There is no current HuggingFace mirror
+of the relevant MeTRAbs variant at the time of commit 11.
+
+The URL encodes the model configuration:
+`metrabs_eff2l_y4_384px_800k_28ds` means the EfficientNetV2-L backbone,
+YOLOv4 detector head, 384-pixel input, 800k training steps, trained on
+28 datasets. This name pattern is worth preserving when we host the
+model ourselves so future variants stay self-describing.
+
+### Supply-chain concerns
+
+Pinning a single upstream URL to a third-party academic host is a
+real supply-chain risk, and the audit of the previous prototype called
+it out explicitly (the old code used `bit.ly/metrabs_1`, which was
+even worse). Concrete failure modes:
+
+- The RWTH Aachen host goes down or is decommissioned.
+- The URL changes when Sárándi releases a new MeTRAbs version.
+- The tarball contents change under the same URL without a version bump.
+
+**Minimum mitigation** (should land in or immediately after commit 11):
+
+- **Pin a SHA-256 checksum** alongside the URL, and verify on download
+  before unpacking. If the checksum doesn't match, fail hard with a
+  clear error.
+- **Cache aggressively.** Once downloaded and verified, never hit the
+  network again for the same configuration. `model_cache_dir` is
+  already in `Settings`.
+- **Document the exact filename and checksum** in `RESEARCH.md` (or
+  migrate to a `MODEL_ARTIFACTS.md` file) so operators have a way to
+  manually download the model out-of-band if the primary URL is dead.
+
+### Self-hosting options
+
+We want to host the model ourselves, both for reliability and because
+it opens the door to future fine-tuning and redistribution of our own
+variants. Candidate hosting approaches:
+
+#### Forgejo LFS
+
+Pros:
+- Lives next to the code.
+- Version-controlled artifacts.
+- Access control mirrors repo access.
+
+Cons:
+- LFS is designed for git-tracked binary assets, not for large
+  infrequently-updated model weights — you pay LFS overhead on every
+  clone unless you configure `lfs.fetchexclude`.
+- Model is ~2.2 GB; Forgejo LFS performance at that size is untested
+  for our instance.
+- Pinning is by LFS pointer, which means the model is coupled to a
+  particular repo revision. Messy if we want multiple code revisions
+  to share the same model.
+
+**Verdict:** Workable but not the best fit.
+
+#### Forgejo generic package registry
+
+Forgejo supports a [generic package
+registry](https://forgejo.org/docs/latest/user/packages/generic/) that
+can host arbitrary binary artifacts with versioned URLs. This is
+closer to what we want:
+
+```
+https://git.levineuwirth.org/api/packages/neuwirth/generic/metrabs/eff2l_y4_384px_800k_28ds/metrabs.tar.gz
+```
+
+Pros:
+- Versioned URLs decoupled from repo revisions.
+- Upload once, download many times, no clone coupling.
+- Integrated auth if we want to gate access.
+- Can be made public even if the repo is private.
+
+Cons:
+- Requires uploading the file manually or via an API call.
+- Forgejo registry size / bandwidth limits depend on the instance.
+
+**Verdict:** Probably the best fit for "we want it hosted alongside
+the project."
+
+#### Plain HTTP server on a VPS subdomain
+
+A dedicated subdomain like `models.levineuwirth.org` backed by a
+simple HTTP file server (nginx `autoindex`, or Caddy with a tidy
+directory layout). Example URL:
+
+```
+https://models.levineuwirth.org/metrabs/metrabs_eff2l_y4_384px_800k_28ds.tar.gz
+```
+
+Pros:
+- Simplest possible story. No API, no auth machinery.
+- Easy to mirror from — anyone can curl the URL.
+- Decoupled from the git forge, so we can share models publicly even
+  when the repo itself is private.
+- Easy to put a CDN in front (Cloudflare) if bandwidth ever matters.
+
+Cons:
+- Manual upload via scp/rsync.
+- No access control unless we add it.
+- No versioning beyond filename convention.
+
+**Verdict:** Strong candidate. This is probably the right choice for
+v0.1 of self-hosted models.
+
+#### S3-compatible object storage (MinIO self-hosted)
+
+Run MinIO on the VPS, get S3-compatible API for free, and serve models
+via pre-signed URLs or a public bucket.
+
+Pros:
+- Proper object storage with ETags, range requests, multipart uploads.
+- Integration story is straightforward if we ever move to cloud-hosted
+  storage.
+- Industry-standard API.
+
+Cons:
+- More operational complexity than a plain HTTP server for what might
+  be a handful of files.
+
+**Verdict:** Overkill for v0.1 but worth revisiting if model storage
+becomes a real operational concern.
+
+### Integrity: SHA-256 pinning
+
+Regardless of which hosting approach we pick, **the model loader should
+always verify a SHA-256 checksum** before trusting the downloaded
+artifact. This is the one piece of supply-chain hygiene that has to be
+in place before we ship commit 11 to any user outside the Shu lab.
+
+Implementation sketch for `neuropose/_model.py`:
+
+```python
+def load_metrabs_model(cache_dir: Path | None = None) -> Any:
+    cache_dir = cache_dir or _default_model_cache_dir()
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    tarball = cache_dir / _MODEL_FILENAME
+    if not tarball.exists():
+        _download(_MODEL_URL, tarball)
+    _verify_sha256(tarball, _MODEL_SHA256)
+    extracted = _extract_if_needed(tarball, cache_dir)
+    return tfhub.load(str(extracted))  # or tf.saved_model.load
+```
+
+The `_MODEL_SHA256` constant is the source of truth; if it ever has
+to change, the constant change is visible in the git diff and a human
+reviews it.
+
+### Fine-tuning
+
+The next research direction after we have inference working is
+fine-tuning MeTRAbs on clinical-specific data. Open questions:
+
+- **What data?** Any clinical data is IRB-gated. Even de-identified
+  pose data may carry subject information if the recording conditions
+  (lighting, room layout) are distinctive enough. Any training plan
+  has to run through the data-handling policy that lives (will live)
+  in `docs/data-policy.md`.
+- **Transfer learning strategy.**
+  - *Head-only fine-tuning*: freeze the EfficientNetV2-L backbone and
+    re-train the pose regression head on clinical data. Fast, low
+    compute, unlikely to overfit, but also unlikely to capture
+    clinical-pose idiosyncrasies.
+  - *Low-LR full fine-tune*: unfreeze everything, use a learning rate
+    1/100th of the original, train for a few epochs. Better
+    adaptation, higher risk of catastrophic forgetting.
+  - *Adapter layers*: insert small trainable adapters into the frozen
+    backbone. Parameter-efficient, well-studied in NLP, less common
+    for pose but should work.
+- **Compute requirements.** EfficientNetV2-L is roughly 120M parameters;
+  fine-tuning on a single modern GPU (24 GB VRAM) is feasible at
+  reduced batch size. A multi-GPU node is friendlier but not strictly
+  required.
+- **Evaluation.** We need held-out clinical data with trusted ground
+  truth. MoCap-derived poses are the gold standard; marker-based MoCap
+  systems provide sub-millimeter accuracy at the cost of subject
+  instrumentation. The Shu lab's access to MoCap is the gating factor.
+- **Sharing fine-tuned weights.** If we fine-tune on clinical data, the
+  resulting weights may encode subject information in ways that are
+  non-obvious and potentially IRB-relevant. Sharing fine-tuned weights
+  externally has to be cleared through the same channels as sharing the
+  training data.
+
+### Training our own pose estimator
+
+The long-range version of the research direction: train a pose
+estimator from scratch that extends MeTRAbs's methodology. MeTRAbs is
+a good starting point because the method is well-documented:
+
+- Sárándi, I., et al. (2020). "MeTRAbs: Metric-Scale Truncation-Robust
+  Heatmaps for Absolute 3D Human Pose Estimation."
+  [arXiv 2007.07227](https://arxiv.org/abs/2007.07227),
+  IEEE Transactions on Biometrics, Behavior, and Identity Science.
+
+Core contributions (worth knowing if you modify any of this):
+
+- **Truncation-robust heatmaps.** Instead of predicting a 2D heatmap
+  bounded by the image, MeTRAbs predicts a heatmap that extends
+  *outside* the image and can place a joint at coordinates the image
+  alone could not disambiguate. Critical for crops where the subject
+  is partially out of frame.
+- **Metric scale regression.** MeTRAbs predicts the absolute 3D
+  positions of joints in millimetres by combining a 2D heatmap with a
+  per-joint depth regressor. Most 3D pose methods produce only
+  relative coordinates, which are useless for clinical measurement.
+- **Multi-dataset training with a common skeleton.** The 28-dataset
+  training set unifies disparate skeleton topologies into a common
+  43-joint Berkeley MHAD skeleton, which we carry forward in
+  NeuroPose.
+
+**Natural extensions worth considering:**
+
+- **Temporal smoothing head.** MeTRAbs is a per-frame model. Clinical
+  gait analysis wants temporally smooth trajectories. Adding a
+  lightweight temporal head (1D CNN or small transformer over frame
+  sequences) could produce smoother outputs without touching the
+  backbone.
+- **Clinical-specific heatmap supervision.** If we have MoCap data for
+  clinical poses, we can use it as ground-truth heatmap supervision to
+  improve accuracy in the pose ranges the model sees least often in
+  the 28-dataset training corpus (e.g., pathological gaits, walker-
+  assisted ambulation).
+- **Multi-person identity tracking.** MeTRAbs produces detections per
+  frame without continuity across frames. Adding a Hungarian-matched
+  tracker (or a learned tracker) would solve the multi-person
+  identity problem that `predictions_to_numpy` currently dodges with
+  a `person_index` parameter.
+- **Alternative backbones.** EfficientNetV2-L is a 2020-era choice.
+  Newer backbones (ConvNeXt, DINOv2-initialized ViTs) may give
+  meaningful gains, especially for clinical poses that are
+  under-represented in the original training set.
+- **Uncertainty estimation.** Clinical users want to know when the
+  model is unsure. A Gaussian output head (mean + variance per joint)
+  or an ensemble-based approach would let us propagate uncertainty
+  into downstream analysis.
+
+**Compute requirements:** training MeTRAbs from scratch was reported
+as "a few weeks" on 8x V100 in the original paper. A from-scratch
+re-training is a substantial undertaking. Fine-tuning is much more
+accessible.
+
+### Collaboration opportunities
+
+- **István Sárándi** (now at University of Tübingen, formerly RWTH
+  Aachen) is the author of MeTRAbs. The code is MIT-licensed and he
+  has historically been responsive to collaboration requests. If we
+  end up publishing work that significantly extends MeTRAbs, at the
+  very least we should reach out about co-authorship or
+  acknowledgment; at best we might find an active collaborator.
+- **The Shu Lab's existing collaborators** on clinical gait research
+  at Brown and partner institutions may have MoCap-validated datasets
+  we can use for fine-tuning and evaluation. Worth asking Dr. Shu.
+
+### Open questions
+
+1. Does Forgejo's generic package registry actually handle a 2.2 GB
+   upload cleanly, or do we need the plain HTTP server route?
+2. What's the right SHA-256 pin to commit alongside the URL? (Need to
+   download the tarball first and run `sha256sum`.)
+3. Do we have access to MoCap-validated clinical gait data for
+   fine-tuning evaluation? This gates every training-related
+   experiment.
+4. Is fine-tuning even worth pursuing before we have inference results
+   that are clearly *not* good enough on clinical data? (I.e.,
+   motivate the work with concrete failure cases rather than assuming
+   a delta we haven't measured.)
+5. Does it make sense to reach out to Sárándi now, or wait until we
+   have something concrete to collaborate on?
+
+### Reading list
+
+- Sárándi, I. et al. (2020). "MeTRAbs: Metric-Scale Truncation-Robust
+  Heatmaps for Absolute 3D Human Pose Estimation."
+  [arXiv 2007.07227](https://arxiv.org/abs/2007.07227). **Essential
+  reading** for anyone planning to extend the method.
+- Sárándi's personal site and the MeTRAbs GitHub repo
+  (<https://github.com/isarandi/metrabs>) — the code, model zoo, and
+  training scripts live here.
+- Zheng, C. et al. (2023). "Deep Learning-Based Human Pose Estimation: A
+  Survey." Good survey paper for orienting on the state of the art.
+- The original 28-dataset training composition referenced in the
+  MeTRAbs paper — worth tracing through to understand what poses are
+  in- and out-of-distribution for the pretrained model.
+
+### Next steps
+
+- [ ] Download the pinned tarball and compute its SHA-256 for the
+      commit-11 model loader.
+- [ ] Decide between Forgejo generic registry and plain HTTP subdomain
+      for self-hosting. Prototype whichever one wins.
+- [ ] Mirror the pinned tarball to the chosen self-hosted location so
+      we can fall over to it the moment the RWTH URL changes or goes
+      down.
+- [ ] Write a one-page "MODEL_ARTIFACTS.md" that documents every model
+      version we use, its checksum, and its canonical source URL.
+- [ ] Have the data-access conversation with Dr. Shu about clinical
+      training data. Everything else is blocked on this.
+- [ ] (Much later) Reach out to Sárándi about potential collaboration
+      once we have something concrete to talk about.
diff --git a/docs/getting-started.md b/docs/getting-started.md
index c59db0b..e7ed146 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -2,25 +2,49 @@
 
 This page walks through installing NeuroPose, running your first pose
 estimation, and understanding the output. It targets researchers who are
-comfortable on a Linux command line but may not have used the package
+comfortable on a Unix command line but may not have used the package
 before.
 
-!!! info "Model loader status"
-    The MeTRAbs model loader is pending the commit-11 rewrite, during
-    which the upstream model URL and TensorFlow version will be pinned.
-    Until it lands, the `neuropose watch` and `neuropose process`
-    commands will exit with a clear "pending commit 11" message. The
-    Python API still works if you inject a model manually — see the
-    *Python API* section below for the current workaround.
-
 ## Prerequisites
 
-- Linux (Ubuntu 22.04+ or equivalent)
+- Linux (Ubuntu 22.04+ or equivalent) **or** macOS on Apple Silicon
+  (M1 / M2 / M3 / M4). Both are first-class targets — the same `uv`
+  install command works on either.
 - Python 3.11
 - [`uv`](https://github.com/astral-sh/uv) for dependency management
-- CUDA-capable GPU (optional, recommended for long videos)
-- Internet access on first run (for the model download, once the loader
-  lands)
+- CUDA-capable GPU (optional, recommended for long videos on Linux)
+- Internet access on first run (for the ~2 GB MeTRAbs model download)
+
+!!! note "Apple Silicon"
+    NeuroPose pins `tensorflow>=2.16`, which is the first TensorFlow
+    release with native `darwin/arm64` wheels on PyPI. Mac users get a
+    working CPU install from the same command Linux users run — no
+    `tensorflow-macos`, no platform markers, no extra configuration.
+
+    Metal GPU acceleration is available as an **opt-in extra** for
+    users who need it:
+
+    ```bash
+    uv sync --group dev --extra metal
+    # or, for non-editable installs:
+    pip install 'neuropose[metal]'
+    ```
+
+    This installs `tensorflow-metal`, Apple's PluggableDevice for TF,
+    which registers a Metal-backed `/GPU:0` device. It is **not
+    enabled by default** for two reasons:
+
+    1. **Untested in this codebase.** The default install (CPU) is
+       the path we verify in CI. The Metal path has not been
+       exercised against the MeTRAbs SavedModel; users are on their
+       own for validation.
+    2. **Numerical caveats.** `tensorflow-metal` has a documented
+       history of producing silently-divergent fp32 results on some
+       TF ops, especially under Keras 3. For clinical research where
+       reproducibility matters more than inference latency, CPU
+       inference is the safer default. If you enable Metal, spot-check
+       a few `poses3d` outputs against the CPU equivalent before
+       trusting results for any downstream measurement.
 
 ## Installation
 
@@ -170,20 +194,15 @@ back into a validated `VideoPredictions` object.
 ## Python API
 
 For scripting, debugging, or integrating NeuroPose into a larger
-pipeline, you can use the `Estimator` class directly. This is also the
-current workaround for the pending model loader:
+pipeline, you can use the `Estimator` class directly:
 
 ```python
+from neuropose._model import load_metrabs_model
 from neuropose.estimator import Estimator
 from neuropose.io import save_video_predictions
 from pathlib import Path
 
-# Load the MeTRAbs model however you like — e.g. via tensorflow_hub once
-# you know the canonical URL. Until commit 11 pins it, you'll need to
-# load it yourself here.
-import tensorflow_hub as tfhub
-model = tfhub.load("...")  # TODO: pin upstream URL
-
+model = load_metrabs_model()  # uses the XDG cache dir; downloads on first call
 estimator = Estimator(model=model, device="/GPU:0")
 result = estimator.process_video(Path("trial_01.mp4"))
 
@@ -228,8 +247,8 @@ function, so importing `neuropose.visualize` has no global side effects.
 
 | Problem | Resolution |
 |---|---|
-| `error: pending commit 11` from `neuropose watch` or `process` | The model loader is not yet implemented. Use the Python API with a manually-loaded model. |
 | `AlreadyRunningError` from the daemon | Another NeuroPose daemon already holds the lock file. Check `data_dir/.neuropose.lock` for the PID. |
 | `VideoDecodeError` on valid-looking video | The file may be corrupted or in a codec OpenCV was built without. Try re-encoding with `ffmpeg -i in.mov -c:v libx264 out.mp4`. |
 | Jobs stuck in `processing` state on startup | The daemon now recovers these automatically — they'll be marked failed and quarantined to `data_dir/failed/` on the next run. |
 | Daemon not detecting a new job | Check that the job is inside a **subdirectory** of `data_dir/in/`, not directly in `data_dir/in/`. Empty subdirectories are silently skipped (the daemon assumes you are still copying files). |
+| `SHA-256 mismatch` from the model loader | The MeTRAbs tarball download was truncated or the upstream artifact has changed. The loader retries once automatically; if it still fails, delete `model_cache_dir/metrabs_eff2l_y4_384px_800k_28ds.tar.gz` and let it re-download, or check `RESEARCH.md` for the canonical pin. |
diff --git a/pyproject.toml b/pyproject.toml
index 3950a8a..b38142f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,7 +29,9 @@ classifiers = [
   "Development Status :: 2 - Pre-Alpha",
   "Intended Audience :: Science/Research",
   "License :: OSI Approved :: MIT License",
+  "Operating System :: POSIX",
   "Operating System :: POSIX :: Linux",
+  "Operating System :: MacOS",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.11",
   "Topic :: Scientific/Engineering :: Image Recognition",
@@ -37,10 +39,14 @@ classifiers = [
   "Typing :: Typed",
 ]
 
-# Runtime dependencies. Versions intentionally unpinned at this stage: the
-# TensorFlow / MeTRAbs stack is pending a sanity check against the updated
-# upstream MeTRAbs release. Tightened pins will land alongside the MeTRAbs
-# model loader and smoke test.
+# Runtime dependencies. The TensorFlow floor is set to 2.16 because that is
+# the first release with native ``darwin/arm64`` wheels published under the
+# ``tensorflow`` package name on PyPI. Older versions would force a marker
+# split to ``tensorflow-macos`` on Apple Silicon. The MeTRAbs SavedModel was
+# serialized with TF 2.10 and uses only stock ops (no custom kernels), so
+# any TF >= 2.10 loads it; 2.16 is chosen for cross-platform install
+# uniformity, not for any MeTRAbs-side requirement. End-to-end verification
+# against TF 2.21 is logged in RESEARCH.md.
 dependencies = [
   "typer>=0.12",
   "pydantic>=2.6",
@@ -49,7 +55,7 @@ dependencies = [
   "numpy>=1.26",
   "opencv-python-headless>=4.9",
   "matplotlib>=3.8",
-  "tensorflow>=2.15,<3.0",
+  "tensorflow>=2.16,<3.0",
   "tensorflow-hub>=0.16",
 ]
 
@@ -60,11 +66,23 @@ analysis = [
   "scikit-learn>=1.4",
   "sktime>=0.28",
 ]
+# Optional Apple Silicon GPU acceleration via Metal Performance Shaders.
+# This is a PluggableDevice maintained by Apple, NOT by the TensorFlow team,
+# with its own version-compatibility table (see
+# https://developer.apple.com/metal/tensorflow-plugin/) and a documented
+# history of producing numerically-divergent results on some ops under
+# Keras 3. It is deliberately opt-in. Install with
+# `pip install 'neuropose[metal]'` or `uv sync --extra metal`. The platform
+# markers ensure it is silently ignored on every non-Apple-Silicon install.
+metal = [
+  "tensorflow-metal>=1.2,<2; sys_platform == 'darwin' and platform_machine == 'arm64'",
+]
 
 [project.urls]
 Homepage = "https://git.levineuwirth.org/neuwirth/neuropose"
 Repository = "https://git.levineuwirth.org/neuwirth/neuropose"
 Issues = "https://git.levineuwirth.org/neuwirth/neuropose/issues"
+Changelog = "https://git.levineuwirth.org/neuwirth/neuropose/src/branch/main/CHANGELOG.md"
 
 [project.scripts]
 neuropose = "neuropose.cli:run"
@@ -82,6 +100,13 @@ dev = [
   "pre-commit>=4.0",
   "mkdocs-material>=9.5",
   "mkdocstrings[python]>=0.26",
+  # Analyzer subpackage runtime deps. Duplicated from the `analysis`
+  # optional-dependencies extra so dev contributors can run the analyzer
+  # tests without also having to install the extra. sktime is NOT
+  # included here because we do not (yet) wrap it — users who want
+  # classification install `pip install neuropose[analysis]` themselves.
+  "fastdtw>=0.3.4",
+  "scipy>=1.12",
 ]
 
 # ---------------------------------------------------------------------------
@@ -175,6 +200,7 @@ include = [
   "src/neuropose",
   "README.md",
   "LICENSE",
+  "CHANGELOG.md",
   "AUTHORS.md",
   "CITATION.cff",
 ]
diff --git a/scripts/download_model.py b/scripts/download_model.py
new file mode 100644
index 0000000..8bc8acd
--- /dev/null
+++ b/scripts/download_model.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+"""Pre-download the pinned MeTRAbs model into the NeuroPose cache.
+
+Run this on a machine with network access before going offline, or to
+pre-warm a deployment target's cache so the first ``neuropose watch``
+or ``neuropose process`` invocation does not stall on a ~2 GB
+download.
+
+Usage::
+
+    uv run python scripts/download_model.py [--cache-dir PATH]
+
+If ``--cache-dir`` is omitted, the script uses
+``Settings().model_cache_dir`` (``$XDG_DATA_HOME/neuropose/models`` by
+default), which is the same location the daemon and the direct
+``Estimator`` entry points read from.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+
+def _parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--cache-dir",
+        type=Path,
+        default=None,
+        help="Destination directory for the cached model. Defaults to "
+        "the value of Settings().model_cache_dir.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(sys.argv[1:] if argv is None else argv)
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # Deferred imports so --help runs cheaply without importing TF.
+    from neuropose._model import load_metrabs_model
+    from neuropose.config import Settings
+
+    if args.cache_dir is None:
+        settings = Settings()
+        cache_dir = settings.model_cache_dir
+    else:
+        cache_dir = args.cache_dir
+
+    print(f"Fetching MeTRAbs model into {cache_dir}", file=sys.stderr)
+    try:
+        load_metrabs_model(cache_dir=cache_dir)
+    except Exception as exc:
+        print(f"error: model download failed: {exc}", file=sys.stderr)
+        return 1
+
+    print("Download complete", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/neuropose/_model.py b/src/neuropose/_model.py
index bdbcf9c..959e95b 100644
--- a/src/neuropose/_model.py
+++ b/src/neuropose/_model.py
@@ -1,51 +1,355 @@
-"""MeTRAbs model loading — stub pending commit 11.
+"""MeTRAbs model loading with download, checksum verification, and caching.
 
-This module exists so that :mod:`neuropose.estimator` can import a single,
-well-typed loader function even before the upstream MeTRAbs URL is pinned
-and the TensorFlow version is settled.
+The :func:`load_metrabs_model` function is the single entry point through
+which :class:`neuropose.estimator.Estimator` acquires its TensorFlow
+model. It handles:
 
-Commit 11 will replace :func:`load_metrabs_model` with an implementation
-that:
+1. First-call download from the pinned upstream URL.
+2. SHA-256 verification of the downloaded tarball against a known-good
+   checksum. A mismatch triggers exactly one automatic retry (in case
+   the download was truncated), after which the error surfaces.
+3. Atomic extraction to a staging directory and a single rename into
+   the final cache location, so a crash mid-extraction cannot leave
+   the cache in a half-extracted state.
+4. SavedModel load via ``tf.saved_model.load``.
+5. A post-load interface sanity check that verifies the loaded model
+   exposes the ``detect_poses``, ``per_skeleton_joint_names``, and
+   ``per_skeleton_joint_edges`` attributes the estimator needs.
 
-1. Pins the canonical MeTRAbs tfhub / Kaggle Models handle (replacing the
-   ``bit.ly/metrabs_1`` shortener from the previous prototype).
-2. Caches the downloaded model under ``Settings.model_cache_dir`` so the
-   first run downloads it and subsequent runs are offline.
-3. Returns a typed handle that the estimator can invoke without hitting the
-   network on each instantiation.
+Model artifact
+--------------
+The pinned model is MeTRAbs's EfficientNetV2-L variant
+(``metrabs_eff2l_y4_384px_800k_28ds``):
+
+- **URL**: hosted on the RWTH Aachen "omnomnom" server, which is the
+  canonical distribution point for the MeTRAbs authors' lab.
+- **SHA-256**: pinned below. Any change to the URL or the upstream
+  tarball will surface as a verification failure, forcing a human
+  review of the new checksum before downstream code trusts the new
+  artifact.
+
+See ``RESEARCH.md`` at the repo root for the ongoing discussion of
+self-hosting the model on our own infrastructure instead of relying on
+a single third-party URL.
 """
 
 from __future__ import annotations
 
+import hashlib
+import logging
+import os
+import shutil
+import tarfile
+import urllib.request
 from pathlib import Path
 from typing import Any
 
+logger = logging.getLogger(__name__)
 
-def load_metrabs_model(cache_dir: Path | None = None) -> Any:  # noqa: ARG001
+# ---------------------------------------------------------------------------
+# Model artifact: pinned URL and checksum.
+# ---------------------------------------------------------------------------
+#
+# If the URL or checksum below changes, the diff should be reviewed by a
+# human. These are supply-chain constants.
+
+_MODEL_URL = (
+    "https://omnomnom.vision.rwth-aachen.de/data/metrabs/"
+    "metrabs_eff2l_y4_384px_800k_28ds.tar.gz"
+)
+_MODEL_SHA256 = "fa31b5b043f227588c3d224e56db89307d021bfbbb52e36028919f90e1f96c89"
+_MODEL_ARCHIVE_NAME = "metrabs_eff2l_y4_384px_800k_28ds.tar.gz"
+_MODEL_DIR_NAME = "metrabs_eff2l_y4_384px_800k_28ds"
+
+_DOWNLOAD_CHUNK_BYTES = 1024 * 1024  # 1 MB
+_DOWNLOAD_SOCKET_TIMEOUT = 120.0  # seconds between bytes, not total
+_REQUIRED_MODEL_ATTRS = (
+    "detect_poses",
+    "per_skeleton_joint_names",
+    "per_skeleton_joint_edges",
+)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def load_metrabs_model(cache_dir: Path | None = None) -> Any:
     """Load the MeTRAbs model, downloading and caching on first use.
 
     Parameters
     ----------
     cache_dir
-        Directory where the model should be cached. Typically
-        ``Settings.model_cache_dir``. If ``None``, the implementation picks
-        a default location.
+        Directory where the model tarball and extracted SavedModel are
+        cached. If ``None``, defaults to
+        ``$XDG_DATA_HOME/neuropose/models`` (matching
+        :attr:`neuropose.config.Settings.model_cache_dir`).
 
     Returns
     -------
     object
-        An opaque model handle that exposes ``detect_poses`` and the
-        per-skeleton joint metadata attributes used by
-        :class:`neuropose.estimator.Estimator`.
+        A TensorFlow SavedModel handle exposing ``detect_poses`` and
+        the ``per_skeleton_joint_names`` / ``per_skeleton_joint_edges``
+        attributes used by :class:`neuropose.estimator.Estimator`.
 
     Raises
     ------
-    NotImplementedError
-        Always, at this commit. Commit 11 provides the real implementation
-        once the upstream MeTRAbs URL is pinned.
+    RuntimeError
+        If the download fails, the SHA-256 does not match (after one
+        automatic retry), extraction fails, TensorFlow is not
+        installed, or the loaded model does not expose the expected
+        interface.
     """
-    raise NotImplementedError(
-        "load_metrabs_model is stubbed pending commit 11. "
-        "Inject a model directly via Estimator(model=...) for now, "
-        "or wait for the upstream MeTRAbs URL and TensorFlow version pin."
+    resolved_cache = Path(cache_dir) if cache_dir is not None else _default_cache_dir()
+    resolved_cache.mkdir(parents=True, exist_ok=True)
+
+    model_dir = resolved_cache / _MODEL_DIR_NAME
+
+    if model_dir.exists():
+        try:
+            saved_model_dir = _find_saved_model(model_dir)
+        except RuntimeError:
+            logger.warning(
+                "Cached model at %s appears incomplete; removing and re-downloading.",
+                model_dir,
+            )
+            shutil.rmtree(model_dir, ignore_errors=True)
+        else:
+            return _tf_load(saved_model_dir)
+
+    tarball = resolved_cache / _MODEL_ARCHIVE_NAME
+
+    if not tarball.exists():
+        _download_with_progress(_MODEL_URL, tarball)
+
+    try:
+        _verify_sha256(tarball, _MODEL_SHA256)
+    except RuntimeError as first_exc:
+        logger.warning(
+            "SHA-256 mismatch on cached tarball; re-downloading once: %s",
+            first_exc,
+        )
+        tarball.unlink(missing_ok=True)
+        _download_with_progress(_MODEL_URL, tarball)
+        _verify_sha256(tarball, _MODEL_SHA256)
+
+    _extract_tarball(tarball, model_dir)
+    saved_model_dir = _find_saved_model(model_dir)
+    return _tf_load(saved_model_dir)
+
+
+# ---------------------------------------------------------------------------
+# Cache directory resolution
+# ---------------------------------------------------------------------------
+
+
+def _default_cache_dir() -> Path:
+    """Return the default model cache directory under ``$XDG_DATA_HOME``.
+
+    Duplicates :func:`neuropose.config._default_model_cache_dir` rather
+    than importing it, to keep this module free of a dependency on the
+    config layer. The two must agree; a regression test in
+    :mod:`tests.unit.test_config` verifies the Settings default and any
+    future change here should be cross-checked there.
+    """
+    xdg = os.environ.get("XDG_DATA_HOME")
+    base = Path(xdg) if xdg else Path.home() / ".local" / "share"
+    return base / "neuropose" / "models"
+
+
+# ---------------------------------------------------------------------------
+# Download
+# ---------------------------------------------------------------------------
+
+
+def _download_with_progress(url: str, dest: Path) -> None:
+    """Download ``url`` to ``dest`` with progress reporting via the logger.
+
+    Streams the response in 1 MB chunks so memory usage stays flat
+    regardless of the file size. Progress is logged at 10 % increments.
+    On any exception, the partial file at ``dest`` is removed so the
+    caller does not see a truncated file.
+    """
+    logger.info("Downloading %s → %s", url, dest)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+
+    request = urllib.request.Request(  # noqa: S310
+        url,
+        headers={"User-Agent": "neuropose/0.1"},
     )
+
+    try:
+        with urllib.request.urlopen(  # noqa: S310
+            request,
+            timeout=_DOWNLOAD_SOCKET_TIMEOUT,
+        ) as response:
+            total_bytes_header = response.headers.get("Content-Length")
+            total_bytes = int(total_bytes_header) if total_bytes_header else 0
+
+            downloaded = 0
+            next_progress_log = 0.10  # log at 10 %, 20 %, ...
+
+            with dest.open("wb") as out_file:
+                while True:
+                    chunk = response.read(_DOWNLOAD_CHUNK_BYTES)
+                    if not chunk:
+                        break
+                    out_file.write(chunk)
+                    downloaded += len(chunk)
+                    if total_bytes > 0:
+                        fraction = downloaded / total_bytes
+                        if fraction >= next_progress_log:
+                            logger.info(
+                                "  %d / %d MB (%.0f%%)",
+                                downloaded // (1024 * 1024),
+                                total_bytes // (1024 * 1024),
+                                fraction * 100,
+                            )
+                            next_progress_log += 0.10
+    except Exception as exc:
+        # Clean up partial file so the next call re-downloads cleanly.
+        dest.unlink(missing_ok=True)
+        raise RuntimeError(
+            f"Failed to download MeTRAbs model from {url}: {exc}"
+        ) from exc
+
+    if total_bytes > 0 and downloaded != total_bytes:
+        dest.unlink(missing_ok=True)
+        raise RuntimeError(
+            f"Download from {url} was truncated: "
+            f"got {downloaded} bytes, expected {total_bytes}."
+        )
+    logger.info("Download complete: %d bytes", downloaded)
+
+
+# ---------------------------------------------------------------------------
+# Checksum verification
+# ---------------------------------------------------------------------------
+
+
+def _verify_sha256(path: Path, expected_hex: str) -> None:
+    """Verify that ``path``'s SHA-256 digest matches ``expected_hex``.
+
+    Streams the file through ``hashlib.sha256`` in 1 MB chunks so we do
+    not pay for loading a 2 GB tarball into memory.
+    """
+    logger.info("Verifying SHA-256 of %s", path)
+    hasher = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(_DOWNLOAD_CHUNK_BYTES), b""):
+            hasher.update(chunk)
+    actual_hex = hasher.hexdigest()
+    if actual_hex != expected_hex:
+        raise RuntimeError(
+            f"SHA-256 mismatch for {path}: "
+            f"expected {expected_hex}, got {actual_hex}. "
+            f"The downloaded file is corrupt, truncated, or has been tampered with."
+        )
+    logger.info("SHA-256 verified")
+
+
+# ---------------------------------------------------------------------------
+# Extraction
+# ---------------------------------------------------------------------------
+
+
+def _extract_tarball(tarball: Path, dest_dir: Path) -> None:
+    """Extract ``tarball`` atomically to ``dest_dir``.
+
+    Extracts first to a sibling ``<dest_dir>.staging`` directory, then
+    replaces ``dest_dir`` with a single ``rename`` once extraction
+    completes. A crash mid-extraction therefore cannot leave behind a
+    half-populated ``dest_dir``.
+
+    Uses tarfile's ``data`` filter to block path traversal and other
+    tar-bomb patterns.
+    """
+    logger.info("Extracting %s → %s", tarball, dest_dir)
+    staging = dest_dir.parent / (dest_dir.name + ".staging")
+    if staging.exists():
+        shutil.rmtree(staging)
+    staging.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with tarfile.open(tarball, "r:gz") as tf_archive:
+            # ``filter="data"`` guards against path traversal and other
+            # malicious tar contents. Available in Python 3.11.4+ and
+            # required in 3.14+.
+            tf_archive.extractall(staging, filter="data")
+    except Exception as exc:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise RuntimeError(f"Failed to extract {tarball}: {exc}") from exc
+
+    if dest_dir.exists():
+        shutil.rmtree(dest_dir)
+    staging.rename(dest_dir)
+    logger.info("Extracted to %s", dest_dir)
+
+
+# ---------------------------------------------------------------------------
+# SavedModel discovery and TF load
+# ---------------------------------------------------------------------------
+
+
+def _find_saved_model(root: Path) -> Path:
+    """Return the directory containing ``saved_model.pb`` under ``root``.
+
+    The MeTRAbs tarball extracts to a directory containing a SavedModel
+    directory, which itself contains ``saved_model.pb``. The exact
+    layout of intermediate directories is not contractually stable, so
+    we search rather than hardcoding a path.
+
+    Raises
+    ------
+    RuntimeError
+        If no ``saved_model.pb`` is found, or if multiple candidates
+        are found (which would make the choice ambiguous).
+    """
+    candidates = list(root.rglob("saved_model.pb"))
+    if not candidates:
+        raise RuntimeError(
+            f"no saved_model.pb found under {root}; tarball layout unexpected"
+        )
+    if len(candidates) > 1:
+        raise RuntimeError(
+            f"multiple saved_model.pb files found under {root}: "
+            f"{[str(p) for p in candidates]}. "
+            f"Cannot determine which one to load."
+        )
+    return candidates[0].parent
+
+
+def _tf_load(saved_model_dir: Path) -> Any:
+    """Load a SavedModel from ``saved_model_dir`` and sanity-check it.
+
+    TensorFlow is imported lazily here so that importing
+    :mod:`neuropose._model` does not require TF for test or docs
+    code paths that never reach the loader.
+    """
+    try:
+        import tensorflow as tf  # noqa: PLC0415
+    except ImportError as exc:
+        raise RuntimeError(
+            "TensorFlow is required to load the MeTRAbs model but is not installed. "
+            "Install the NeuroPose runtime dependencies with: "
+            "pip install neuropose (or uv sync from a dev checkout)."
+        ) from exc
+
+    logger.info("Loading SavedModel from %s", saved_model_dir)
+    try:
+        model = tf.saved_model.load(str(saved_model_dir))
+    except Exception as exc:
+        raise RuntimeError(
+            f"Failed to load SavedModel from {saved_model_dir}: {exc}"
+        ) from exc
+
+    missing = [attr for attr in _REQUIRED_MODEL_ATTRS if not hasattr(model, attr)]
+    if missing:
+        raise RuntimeError(
+            f"Loaded SavedModel at {saved_model_dir} is missing expected "
+            f"attributes {missing}. The tarball may not be a MeTRAbs model."
+        )
+
+    logger.info("MeTRAbs model loaded successfully from %s", saved_model_dir)
+    return model
diff --git a/src/neuropose/analyzer/__init__.py b/src/neuropose/analyzer/__init__.py
new file mode 100644
index 0000000..4c97557
--- /dev/null
+++ b/src/neuropose/analyzer/__init__.py
@@ -0,0 +1,58 @@
+"""Post-processing and analysis utilities for NeuroPose predictions.
+
+This subpackage operates on :class:`~neuropose.io.VideoPredictions`
+objects (and the numpy arrays derived from them) rather than on raw
+dicts or JSON files. The intent is a set of composable pure functions —
+feature extraction, normalization, joint-angle computation, and Dynamic
+Time Warping — that researchers can assemble into their own pipelines.
+
+.. note::
+    The analyzer's heavy dependencies (:mod:`fastdtw`, :mod:`scipy`) are
+    declared under the ``analysis`` optional-dependencies extra in
+    :file:`pyproject.toml`. Install them with::
+
+        pip install neuropose[analysis]
+
+    The imports inside :mod:`neuropose.analyzer.dtw` and the peak-finding
+    helper in :mod:`neuropose.analyzer.features` are lazy, so importing
+    this subpackage does not require those dependencies. You will only
+    hit a clear :class:`ImportError` at call time if they are missing.
+
+Public API
+----------
+See :mod:`neuropose.analyzer.dtw` and :mod:`neuropose.analyzer.features`
+for per-module details; the most commonly used names are re-exported
+here for ergonomic access.
+"""
+
+from __future__ import annotations
+
+from neuropose.analyzer.dtw import (
+    DTWResult,
+    dtw_all,
+    dtw_per_joint,
+    dtw_relation,
+)
+from neuropose.analyzer.features import (
+    FeatureStatistics,
+    extract_feature_statistics,
+    extract_joint_angles,
+    find_peaks,
+    normalize_pose_sequence,
+    pad_sequences,
+    predictions_to_numpy,
+)
+
+__all__ = [
+    "DTWResult",
+    "FeatureStatistics",
+    "dtw_all",
+    "dtw_per_joint",
+    "dtw_relation",
+    "extract_feature_statistics",
+    "extract_joint_angles",
+    "find_peaks",
+    "normalize_pose_sequence",
+    "pad_sequences",
+    "predictions_to_numpy",
+]
diff --git a/src/neuropose/analyzer/dtw.py b/src/neuropose/analyzer/dtw.py
new file mode 100644
index 0000000..20f3351
--- /dev/null
+++ b/src/neuropose/analyzer/dtw.py
@@ -0,0 +1,212 @@
+"""Dynamic Time Warping helpers for pose sequence comparison.
+
+Three entry points, ordered by increasing precision (and increasing cost):
+
+- :func:`dtw_all` — DTW on the flattened per-frame joint vector. Fast but
+  coarse; collapses every joint axis into a single per-frame vector.
+- :func:`dtw_per_joint` — DTW on each joint independently. Preserves
+  per-joint temporal alignment at the cost of one DTW call per joint.
+- :func:`dtw_relation` — DTW on the displacement vector between two
+  specific joints. This is the right tool when the research question is
+  about the *relative* motion of a specific pair of joints (e.g. the
+  hand-to-hip vector during a reach-and-grasp trial).
+
+All three return a :class:`DTWResult` dataclass with the DTW distance
+and the warping path. Inputs are expected to be ``(frames, joints, 3)``
+numpy arrays — the shape :func:`~neuropose.analyzer.features.predictions_to_numpy`
+produces.
+
+Dependency note
+---------------
+This module requires :mod:`fastdtw` and :mod:`scipy`, which are part of
+the ``analysis`` optional extra. Imports are performed lazily inside
+:func:`_require_fastdtw` so that ``import neuropose.analyzer.dtw``
+succeeds even when the extra is not installed; the error surfaces with
+a clear installation hint the first time a DTW function is actually
+called.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class DTWResult:
+    """Result of a single DTW computation.
+
+    Attributes
+    ----------
+    distance
+        Scalar DTW distance between the two input sequences.
+    path
+        Warping path as a list of ``(i, j)`` index pairs, where ``i`` is
+        an index into the first sequence and ``j`` is an index into the
+        second.
+    """
+
+    distance: float
+    path: list[tuple[int, int]]
+
+
+def _require_fastdtw() -> tuple[Callable, Callable]:
+    """Lazily import fastdtw and scipy.spatial.distance.euclidean.
+
+    Returns
+    -------
+    tuple
+        ``(fastdtw_callable, euclidean_callable)``.
+
+    Raises
+    ------
+    ImportError
+        If either ``fastdtw`` or ``scipy`` is unavailable. The message
+        points the user at the ``analysis`` optional-dependencies extra.
+    """
+    try:
+        from fastdtw import fastdtw
+        from scipy.spatial.distance import euclidean
+    except ImportError as exc:
+        raise ImportError(
+            "neuropose.analyzer.dtw requires fastdtw and scipy. "
+            "Install them with: pip install neuropose[analysis]"
+        ) from exc
+    return fastdtw, euclidean
+
+
+def dtw_all(a: np.ndarray, b: np.ndarray) -> DTWResult:
+    """DTW on the flattened per-frame joint vector.
+
+    Each frame's joints are collapsed into a single vector before DTW
+    is applied. This is fast — one DTW call regardless of the joint
+    count — but loses per-joint temporal structure, so a small
+    timing mismatch on one joint can dominate the distance metric.
+
+    Parameters
+    ----------
+    a, b
+        Pose sequences as ``(frames, joints, 3)`` numpy arrays. The two
+        sequences do not need to have the same number of frames, but
+        they must have the same number of joints.
+
+    Returns
+    -------
+    DTWResult
+        The DTW distance and warping path between the flattened
+        sequences.
+
+    Raises
+    ------
+    ValueError
+        If ``a`` and ``b`` do not have the same joint count.
+    """
+    _validate_same_joint_count(a, b)
+    fastdtw, euclidean = _require_fastdtw()
+    a_flat = a.reshape(a.shape[0], -1)
+    b_flat = b.reshape(b.shape[0], -1)
+    distance, path = fastdtw(a_flat, b_flat, dist=euclidean)
+    return DTWResult(distance=float(distance), path=[tuple(p) for p in path])
+
+
+def dtw_per_joint(a: np.ndarray, b: np.ndarray) -> list[DTWResult]:
+    """DTW on each joint independently.
+
+    Performs one DTW computation per joint, yielding a list of
+    :class:`DTWResult` objects in joint-index order. More precise than
+    :func:`dtw_all` because each joint's temporal alignment is optimised
+    separately, at the cost of J times more DTW calls for J joints.
+
+    Parameters
+    ----------
+    a, b
+        Pose sequences as ``(frames, joints, 3)`` numpy arrays. The two
+        sequences do not need to have the same number of frames but
+        must have the same number of joints.
+
+    Returns
+    -------
+    list[DTWResult]
+        One DTW result per joint, in index order.
+
+    Raises
+    ------
+    ValueError
+        If ``a`` and ``b`` do not have the same joint count.
+    """
+    _validate_same_joint_count(a, b)
+    fastdtw, euclidean = _require_fastdtw()
+    results: list[DTWResult] = []
+    for joint_idx in range(a.shape[1]):
+        a_joint = a[:, joint_idx, :]
+        b_joint = b[:, joint_idx, :]
+        distance, path = fastdtw(a_joint, b_joint, dist=euclidean)
+        results.append(
+            DTWResult(distance=float(distance), path=[tuple(p) for p in path])
+        )
+    return results
+
+
+def dtw_relation(
+    a: np.ndarray,
+    b: np.ndarray,
+    joint_i: int,
+    joint_j: int,
+) -> DTWResult:
+    """DTW on the displacement vector between two specific joints.
+
+    For each frame, the input is reduced to the vector from ``joint_i``
+    to ``joint_j``. DTW is then applied to the two sequences of
+    displacement vectors. This is the right tool when the question is
+    "how does the relationship between joint A and joint B change over
+    time?" — for example, "does the subject's hand track a consistent
+    distance from the hip during the reach trial?"
+
+    Parameters
+    ----------
+    a, b
+        Pose sequences as ``(frames, joints, 3)`` numpy arrays.
+    joint_i, joint_j
+        Indices of the two joints whose relative position should be
+        compared. Must be valid indices into ``a`` and ``b``'s joint
+        axis.
+
+    Returns
+    -------
+    DTWResult
+        DTW distance and path between the two displacement sequences.
+
+    Raises
+    ------
+    ValueError
+        If the sequences have different joint counts or if either joint
+        index is out of range.
+    """
+    _validate_same_joint_count(a, b)
+    num_joints = a.shape[1]
+    if not (0 <= joint_i < num_joints) or not (0 <= joint_j < num_joints):
+        raise ValueError(
+            f"joint indices must be in [0, {num_joints}); "
+            f"got joint_i={joint_i}, joint_j={joint_j}"
+        )
+    fastdtw, euclidean = _require_fastdtw()
+    disp_a = a[:, joint_j, :] - a[:, joint_i, :]
+    disp_b = b[:, joint_j, :] - b[:, joint_i, :]
+    distance, path = fastdtw(disp_a, disp_b, dist=euclidean)
+    return DTWResult(distance=float(distance), path=[tuple(p) for p in path])
+
+
+def _validate_same_joint_count(a: np.ndarray, b: np.ndarray) -> None:
+    """Raise :class:`ValueError` if ``a`` and ``b`` disagree on joint count."""
+    if a.ndim < 2 or b.ndim < 2:
+        raise ValueError(
+            f"expected 3D arrays of shape (frames, joints, 3); "
+            f"got a.ndim={a.ndim}, b.ndim={b.ndim}"
+        )
+    if a.shape[1] != b.shape[1]:
+        raise ValueError(
+            f"input arrays disagree on joint count: "
+            f"a has {a.shape[1]} joints, b has {b.shape[1]} joints"
+        )
diff --git a/src/neuropose/analyzer/features.py b/src/neuropose/analyzer/features.py
new file mode 100644
index 0000000..edfc6e7
--- /dev/null
+++ b/src/neuropose/analyzer/features.py
@@ -0,0 +1,386 @@
+"""Feature extraction helpers for pose sequences.
+
+All functions in this module operate on numpy arrays of shape
+``(frames, joints, 3)`` — the output of
+:func:`predictions_to_numpy`. They are pure functions: none of them
+mutate their inputs, and none of them touch the filesystem or the
+model.
+
+The following helpers are provided:
+
+- :func:`predictions_to_numpy` — convert a validated
+  :class:`~neuropose.io.VideoPredictions` into a numpy pose sequence.
+- :func:`normalize_pose_sequence` — scale a sequence so joint positions
+  fit in the unit cube (either per-axis or uniform).
+- :func:`pad_sequences` — edge-pad a batch of sequences to a common
+  length, suitable for downstream tensor-based analysis.
+- :func:`extract_joint_angles` — compute joint angles at specified
+  triplet positions across a pose sequence.
+- :func:`extract_feature_statistics` — summary statistics
+  (mean / std / min / max / range) for a 1D feature series.
+- :func:`find_peaks` — thin :mod:`scipy.signal` wrapper returning only
+  the peak indices.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+
+from neuropose.io import VideoPredictions
+
+
+# ---------------------------------------------------------------------------
+# VideoPredictions → numpy
+# ---------------------------------------------------------------------------
+
+
+def predictions_to_numpy(
+    predictions: VideoPredictions,
+    *,
+    person_index: int = 0,
+) -> np.ndarray:
+    """Convert a :class:`VideoPredictions` to a 3D pose sequence.
+
+    Parameters
+    ----------
+    predictions
+        The predictions to convert.
+    person_index
+        Which detected person to extract per frame. Defaults to ``0``
+        (the first detected person) which matches the single-subject
+        clinical case. Frames that do not have at least
+        ``person_index + 1`` detections raise :class:`ValueError`.
+
+    Returns
+    -------
+    numpy.ndarray
+        A ``(frames, joints, 3)`` array in the same physical units as
+        the underlying predictions (millimetres for MeTRAbs output).
+
+    Raises
+    ------
+    ValueError
+        If any frame lacks sufficient detections for ``person_index``,
+        or if the predictions contain no frames.
+    """
+    if len(predictions) == 0:
+        raise ValueError("predictions contains zero frames")
+    frames: list[list[list[float]]] = []
+    for frame_name in predictions.frame_names():
+        per_person = predictions[frame_name].poses3d
+        if person_index >= len(per_person):
+            raise ValueError(
+                f"frame {frame_name} has {len(per_person)} detections; "
+                f"person_index={person_index} is out of range"
+            )
+        frames.append(per_person[person_index])
+    return np.asarray(frames, dtype=float)
+
+
+# ---------------------------------------------------------------------------
+# Normalization
+# ---------------------------------------------------------------------------
+
+
+def normalize_pose_sequence(
+    sequence: np.ndarray,
+    *,
+    axis_wise: bool = False,
+) -> np.ndarray:
+    """Translate and scale a pose sequence so joints fit in the unit cube.
+
+    The minimum coordinate along each spatial axis is subtracted, and
+    the result is divided by a single scalar (the range of the largest
+    axis, when ``axis_wise=False``) or by the per-axis range (when
+    ``axis_wise=True``).
+
+    Parameters
+    ----------
+    sequence
+        Array of shape ``(frames, joints, 3)``.
+    axis_wise
+        If ``False`` (default), preserve the geometric aspect ratio by
+        using a single scalar denominator (the maximum axis extent).
+        If ``True``, scale each axis independently to ``[0, 1]``, which
+        distorts the geometry but guarantees full-range normalization
+        on every axis.
+
+    Returns
+    -------
+    numpy.ndarray
+        A new array of the same shape as ``sequence``, with joint
+        positions translated to start at the origin and scaled as
+        described above. The input is not modified.
+
+    Raises
+    ------
+    ValueError
+        If ``sequence`` does not have a final axis of size 3, or if the
+        sequence is degenerate (zero extent on every axis).
+    """
+    if sequence.ndim != 3 or sequence.shape[-1] != 3:
+        raise ValueError(
+            f"expected (frames, joints, 3); got shape {sequence.shape}"
+        )
+    result = sequence.astype(float, copy=True)
+    mins = result.reshape(-1, 3).min(axis=0)
+    maxs = result.reshape(-1, 3).max(axis=0)
+    ranges = maxs - mins
+
+    if np.all(ranges == 0):
+        raise ValueError("cannot normalize a degenerate (zero-extent) sequence")
+
+    result -= mins  # broadcasts over (frames, joints, 3)
+
+    if axis_wise:
+        # Replace zero ranges with 1 to avoid division-by-zero on axes
+        # where all joints share a coordinate; those axes will remain 0.
+        safe_ranges = np.where(ranges == 0, 1.0, ranges)
+        result = result / safe_ranges
+    else:
+        scale = float(ranges.max())
+        result = result / scale
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Padding
+# ---------------------------------------------------------------------------
+
+
+def pad_sequences(
+    sequences: Sequence[np.ndarray],
+    *,
+    target_length: int | None = None,
+) -> list[np.ndarray]:
+    """Edge-pad a list of pose sequences to a common length.
+
+    Each input sequence is extended by repeating its last frame until
+    it reaches ``target_length``. Sequences that are already longer
+    than ``target_length`` are **truncated** to that length. The input
+    list itself and the input arrays are never mutated.
+
+    Parameters
+    ----------
+    sequences
+        List of ``(frames_i, joints, 3)`` arrays. ``frames_i`` may
+        differ per sequence, but all sequences must share the same
+        joint count and spatial dimensionality.
+    target_length
+        Desired number of frames. If ``None``, the maximum
+        ``frames_i`` in the input is used.
+
+    Returns
+    -------
+    list[numpy.ndarray]
+        A new list of arrays, each with ``target_length`` frames.
+
+    Raises
+    ------
+    ValueError
+        If ``sequences`` is empty and ``target_length`` is ``None``, or
+        if any sequence has mismatched trailing dimensions.
+    """
+    if not sequences:
+        if target_length is None:
+            raise ValueError(
+                "cannot infer target_length from an empty sequence list"
+            )
+        return []
+
+    first = sequences[0]
+    trailing_shape = first.shape[1:]
+    for idx, seq in enumerate(sequences):
+        if seq.shape[1:] != trailing_shape:
+            raise ValueError(
+                f"sequence {idx} has trailing shape {seq.shape[1:]}; "
+                f"expected {trailing_shape}"
+            )
+
+    length = target_length if target_length is not None else max(
+        s.shape[0] for s in sequences
+    )
+
+    padded: list[np.ndarray] = []
+    for seq in sequences:
+        if seq.shape[0] == length:
+            padded.append(seq.copy())
+        elif seq.shape[0] > length:
+            padded.append(seq[:length].copy())
+        else:
+            pad_amount = length - seq.shape[0]
+            padding = [(0, pad_amount)] + [(0, 0)] * (seq.ndim - 1)
+            padded.append(np.pad(seq, padding, mode="edge"))
+    return padded
+
+
+# ---------------------------------------------------------------------------
+# Joint angles
+# ---------------------------------------------------------------------------
+
+
+def extract_joint_angles(
+    sequence: np.ndarray,
+    triplets: Sequence[tuple[int, int, int]],
+) -> np.ndarray:
+    """Compute angles at specified joints across a pose sequence.
+
+    For each triplet ``(a, b, c)``, the angle at ``b`` is defined as
+    the angle between the vectors ``(a - b)`` and ``(c - b)``, in
+    radians. Frames where either vector has zero length (e.g. joint
+    degeneracy) produce ``NaN`` in the output rather than raising.
+
+    Parameters
+    ----------
+    sequence
+        Array of shape ``(frames, joints, 3)``.
+    triplets
+        Iterable of ``(a, b, c)`` joint index tuples. Each index must
+        be in ``[0, joints)``.
+
+    Returns
+    -------
+    numpy.ndarray
+        Array of shape ``(frames, len(triplets))``, where each column
+        is the time-series of angles at the corresponding triplet's
+        centre joint. Angles are in radians, in ``[0, pi]``.
+
+    Raises
+    ------
+    ValueError
+        If any joint index in ``triplets`` is out of range.
+    """
+    if sequence.ndim != 3 or sequence.shape[-1] != 3:
+        raise ValueError(
+            f"expected (frames, joints, 3); got shape {sequence.shape}"
+        )
+    num_joints = sequence.shape[1]
+    columns: list[np.ndarray] = []
+    for a_idx, b_idx, c_idx in triplets:
+        for idx in (a_idx, b_idx, c_idx):
+            if not (0 <= idx < num_joints):
+                raise ValueError(
+                    f"joint index {idx} out of range [0, {num_joints})"
+                )
+        v1 = sequence[:, a_idx, :] - sequence[:, b_idx, :]
+        v2 = sequence[:, c_idx, :] - sequence[:, b_idx, :]
+        n1 = np.linalg.norm(v1, axis=1)
+        n2 = np.linalg.norm(v2, axis=1)
+        with np.errstate(invalid="ignore", divide="ignore"):
+            cosine = np.sum(v1 * v2, axis=1) / (n1 * n2)
+            cosine = np.clip(cosine, -1.0, 1.0)
+            angle = np.arccos(cosine)
+        columns.append(angle)
+    return np.stack(columns, axis=1)
+
+
+# ---------------------------------------------------------------------------
+# Summary statistics
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class FeatureStatistics:
+    """Summary statistics for a 1D feature series.
+
+    Attributes
+    ----------
+    mean, std, min, max
+        Standard summary statistics of the input values.
+    range
+        ``max - min``. Precomputed for convenience.
+    """
+
+    mean: float
+    std: float
+    min: float
+    max: float
+    range: float
+
+
+def extract_feature_statistics(values: np.ndarray) -> FeatureStatistics:
+    """Compute summary statistics for a 1D feature series.
+
+    Parameters
+    ----------
+    values
+        A 1D numpy array. Higher-dimensional inputs are rejected to
+        keep the semantics unambiguous — callers that want per-column
+        statistics should reduce along their axis of interest first.
+
+    Returns
+    -------
+    FeatureStatistics
+        Mean, standard deviation, minimum, maximum, and range of
+        ``values``.
+
+    Raises
+    ------
+    ValueError
+        If ``values`` is not 1D or is empty.
+    """
+    if values.ndim != 1:
+        raise ValueError(f"expected 1D array; got shape {values.shape}")
+    if values.size == 0:
+        raise ValueError("cannot compute statistics of an empty array")
+    mn = float(values.min())
+    mx = float(values.max())
+    return FeatureStatistics(
+        mean=float(values.mean()),
+        std=float(values.std()),
+        min=mn,
+        max=mx,
+        range=mx - mn,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Peak finding
+# ---------------------------------------------------------------------------
+
+
+def find_peaks(values: np.ndarray, **kwargs: object) -> np.ndarray:
+    """Return indices of local maxima in a 1D series.
+
+    Thin wrapper around :func:`scipy.signal.find_peaks` that returns
+    just the peak-index array (scipy's function also returns a
+    properties dict, which callers rarely need).
+
+    Parameters
+    ----------
+    values
+        1D numpy array of feature values (e.g. a joint's Y-coordinate
+        across frames).
+    **kwargs
+        Forwarded to :func:`scipy.signal.find_peaks`. Common options
+        include ``height``, ``threshold``, ``distance``, and
+        ``prominence``.
+
+    Returns
+    -------
+    numpy.ndarray
+        1D integer array of peak indices, in ascending order.
+
+    Raises
+    ------
+    ImportError
+        If scipy is not installed. The error message points at the
+        ``analysis`` optional extra.
+    ValueError
+        If ``values`` is not 1D.
+    """
+    if values.ndim != 1:
+        raise ValueError(f"expected 1D array; got shape {values.shape}")
+    try:
+        from scipy.signal import find_peaks as _sp_find_peaks
+    except ImportError as exc:
+        raise ImportError(
+            "neuropose.analyzer.features.find_peaks requires scipy. "
+            "Install it with: pip install neuropose[analysis]"
+        ) from exc
+    indices, _properties = _sp_find_peaks(values, **kwargs)
+    return indices
diff --git a/tests/conftest.py b/tests/conftest.py
index d9897e9..d8f73bc 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -12,6 +12,42 @@ import numpy as np
 import pytest
 
 
+# ---------------------------------------------------------------------------
+# Slow test opt-in
+# ---------------------------------------------------------------------------
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Register the ``--runslow`` command-line flag.
+
+    Tests marked ``@pytest.mark.slow`` (typically the integration tests
+    under ``tests/integration/`` that download the MeTRAbs model) are
+    skipped by default and run only when ``--runslow`` is passed. This
+    keeps the default ``pytest`` invocation fast and offline-safe, and
+    keeps CI's default test job from burning minutes on a 2 GB download
+    on every push.
+    """
+    parser.addoption(
+        "--runslow",
+        action="store_true",
+        default=False,
+        help="run tests marked @pytest.mark.slow (model download required)",
+    )
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config,
+    items: list[pytest.Item],
+) -> None:
+    """Skip ``@slow`` tests unless ``--runslow`` was given on the command line."""
+    if config.getoption("--runslow"):
+        return
+    skip_slow = pytest.mark.skip(reason="need --runslow to run slow tests")
+    for item in items:
+        if "slow" in item.keywords:
+            item.add_marker(skip_slow)
+
+
 # ---------------------------------------------------------------------------
 # Environment isolation
 # ---------------------------------------------------------------------------
diff --git a/tests/integration/test_estimator_smoke.py b/tests/integration/test_estimator_smoke.py
new file mode 100644
index 0000000..5178b92
--- /dev/null
+++ b/tests/integration/test_estimator_smoke.py
@@ -0,0 +1,152 @@
+"""End-to-end smoke test for the MeTRAbs model loader and estimator.
+
+This module lives under ``tests/integration/`` and every test in it is
+marked ``@pytest.mark.slow``. That means:
+
+- ``pytest`` with no flags **skips** these tests. The conftest hook
+  in ``tests/conftest.py`` requires the ``--runslow`` flag to run
+  anything marked ``slow``.
+- ``pytest --runslow`` runs them. On a cold cache this triggers a
+  ~2 GB download of the MeTRAbs model tarball from its upstream URL;
+  on a warm cache (subsequent runs with the same ``cache_dir``) it
+  completes in seconds.
+
+The intent of this file is **plumbing verification**, not accuracy
+benchmarking:
+
+- Does the loader download, verify, extract, and load the tarball?
+- Does the loader's second call hit the cache without re-downloading?
+- Does the estimator run end-to-end against a real MeTRAbs model on a
+  synthetic video and produce a valid :class:`VideoPredictions` object?
+
+Accuracy against reference pose data is out of scope here and will
+live in a separate benchmark harness once the project has data it is
+cleared to test against.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import cv2
+import numpy as np
+import pytest
+
+from neuropose._model import load_metrabs_model
+from neuropose.estimator import Estimator
+from neuropose.io import FramePrediction, VideoPredictions
+
+pytestmark = pytest.mark.slow
+
+
+@pytest.fixture
+def integration_video(tmp_path: Path) -> Path:
+    """Generate a 384×288 synthetic video sized for MeTRAbs input.
+
+    The default ``synthetic_video`` fixture in ``tests/conftest.py``
+    produces 32×32 frames, which is too small for MeTRAbs's 384 px
+    input and may cause the detector pipeline to short-circuit
+    unpredictably. This fixture produces a modestly-sized video so
+    the smoke test's plumbing assertions are meaningful.
+    """
+    path = tmp_path / "integration.avi"
+    fourcc = cv2.VideoWriter_fourcc(*"MJPG")
+    writer = cv2.VideoWriter(str(path), fourcc, 30.0, (384, 288))
+    assert writer.isOpened(), "cv2.VideoWriter failed to open; MJPG codec missing?"
+    for i in range(5):
+        # Flat gray with a shifting offset per frame. There are no
+        # humans in the frame; MeTRAbs should produce zero detections
+        # per frame but the pipeline must still return valid structures.
+        frame = np.full((288, 384, 3), 100 + i * 10, dtype=np.uint8)
+        writer.write(frame)
+    writer.release()
+    assert path.exists() and path.stat().st_size > 0
+    return path
+
+
+@pytest.fixture(scope="session")
+def shared_model_cache_dir(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    """Session-scoped cache dir so the model is downloaded at most once per run.
+
+    Without this, each test in the file would trigger a fresh download
+    because the default ``tmp_path`` is function-scoped. The session
+    scope means the first test pays for the download and subsequent
+    tests load from the cache.
+    """
+    return tmp_path_factory.mktemp("neuropose_model_cache")
+
+
+class TestMetrabsLoader:
+    """Exercises the loader's download → verify → extract → load path."""
+
+    def test_download_and_load(self, shared_model_cache_dir: Path) -> None:
+        model = load_metrabs_model(cache_dir=shared_model_cache_dir)
+        assert model is not None
+        for attr in ("detect_poses", "per_skeleton_joint_names", "per_skeleton_joint_edges"):
+            assert hasattr(model, attr), f"loaded model is missing {attr}"
+
+    def test_second_call_uses_cache(self, shared_model_cache_dir: Path) -> None:
+        """Idempotent: second call should return the cached model cheaply."""
+        model_a = load_metrabs_model(cache_dir=shared_model_cache_dir)
+        model_b = load_metrabs_model(cache_dir=shared_model_cache_dir)
+        # tf.saved_model.load returns a new Python object each call, so
+        # identity comparison doesn't work — but both should still
+        # expose the MeTRAbs interface.
+        assert hasattr(model_a, "detect_poses")
+        assert hasattr(model_b, "detect_poses")
+
+    def test_berkeley_mhad_skeleton_is_present(
+        self, shared_model_cache_dir: Path
+    ) -> None:
+        """The estimator pins skeleton='berkeley_mhad_43'; verify it exists."""
+        model = load_metrabs_model(cache_dir=shared_model_cache_dir)
+        joint_names = model.per_skeleton_joint_names["berkeley_mhad_43"]
+        joint_edges = model.per_skeleton_joint_edges["berkeley_mhad_43"]
+        # MeTRAbs exposes these as tf.Tensor objects; just verify we
+        # can pull a shape out.
+        assert joint_names.shape[0] == 43
+        assert joint_edges.shape[0] > 0
+
+
+class TestEndToEndInference:
+    """Runs the estimator against a real model on a synthetic video."""
+
+    def test_estimator_produces_valid_predictions(
+        self,
+        integration_video: Path,
+        shared_model_cache_dir: Path,
+    ) -> None:
+        model = load_metrabs_model(cache_dir=shared_model_cache_dir)
+        estimator = Estimator(model=model)
+
+        result = estimator.process_video(integration_video)
+
+        assert isinstance(result.predictions, VideoPredictions)
+        assert result.frame_count == 5
+        assert result.predictions.metadata.width == 384
+        assert result.predictions.metadata.height == 288
+
+        # Each frame's predictions must validate as a FramePrediction,
+        # regardless of whether MeTRAbs detects any people in it.
+        for frame_name in result.predictions.frame_names():
+            frame = result.predictions[frame_name]
+            assert isinstance(frame, FramePrediction)
+            assert isinstance(frame.boxes, list)
+            assert isinstance(frame.poses3d, list)
+            assert isinstance(frame.poses2d, list)
+
+    def test_progress_callback_invoked_per_frame(
+        self,
+        integration_video: Path,
+        shared_model_cache_dir: Path,
+    ) -> None:
+        model = load_metrabs_model(cache_dir=shared_model_cache_dir)
+        estimator = Estimator(model=model)
+
+        processed_counts: list[int] = []
+        estimator.process_video(
+            integration_video,
+            progress=lambda processed, _total: processed_counts.append(processed),
+        )
+
+        assert processed_counts == [1, 2, 3, 4, 5]
diff --git a/tests/unit/test_analyzer_dtw.py b/tests/unit/test_analyzer_dtw.py
new file mode 100644
index 0000000..aceb53e
--- /dev/null
+++ b/tests/unit/test_analyzer_dtw.py
@@ -0,0 +1,142 @@
+"""Tests for :mod:`neuropose.analyzer.dtw`."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from neuropose.analyzer.dtw import (
+    DTWResult,
+    dtw_all,
+    dtw_per_joint,
+    dtw_relation,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def simple_sequence() -> np.ndarray:
+    """A 5-frame, 3-joint sequence of linearly-moving joints."""
+    rng = np.random.default_rng(seed=42)
+    return rng.standard_normal((5, 3, 3))
+
+
+# ---------------------------------------------------------------------------
+# dtw_all
+# ---------------------------------------------------------------------------
+
+
+class TestDtwAll:
+    def test_identical_sequences_distance_zero(
+        self, simple_sequence: np.ndarray
+    ) -> None:
+        result = dtw_all(simple_sequence, simple_sequence)
+        assert isinstance(result, DTWResult)
+        assert result.distance == pytest.approx(0.0, abs=1e-9)
+        # Identical sequences produce a diagonal warping path.
+        assert all(i == j for i, j in result.path)
+
+    def test_shifted_sequences_distance_zero(
+        self, simple_sequence: np.ndarray
+    ) -> None:
+        """DTW should absorb a pure time shift without penalty."""
+        # Duplicate the first frame to create a one-frame shift.
+        shifted = np.concatenate([simple_sequence[:1], simple_sequence], axis=0)
+        result = dtw_all(simple_sequence, shifted)
+        assert result.distance == pytest.approx(0.0, abs=1e-9)
+
+    def test_different_sequences_positive_distance(self) -> None:
+        a = np.zeros((5, 3, 3))
+        b = np.ones((5, 3, 3))
+        result = dtw_all(a, b)
+        assert result.distance > 0.0
+
+    def test_mismatched_joint_count_rejected(self) -> None:
+        a = np.zeros((5, 3, 3))
+        b = np.zeros((5, 4, 3))
+        with pytest.raises(ValueError, match="joint count"):
+            dtw_all(a, b)
+
+    def test_non_3d_input_rejected(self) -> None:
+        a = np.zeros((5, 3))  # missing trailing axis
+        b = np.zeros((5, 3))
+        with pytest.raises(ValueError, match="expected 3D"):
+            dtw_all(a, b)
+
+
+# ---------------------------------------------------------------------------
+# dtw_per_joint
+# ---------------------------------------------------------------------------
+
+
+class TestDtwPerJoint:
+    def test_returns_one_result_per_joint(
+        self, simple_sequence: np.ndarray
+    ) -> None:
+        results = dtw_per_joint(simple_sequence, simple_sequence)
+        assert len(results) == simple_sequence.shape[1]
+        for result in results:
+            assert isinstance(result, DTWResult)
+            assert result.distance == pytest.approx(0.0, abs=1e-9)
+
+    def test_independent_joint_distances(self) -> None:
+        # Construct two sequences where joint 0 matches exactly but
+        # joint 1 is offset by a constant. Per-joint DTW should give
+        # distance 0 for joint 0 and distance > 0 for joint 1.
+        a = np.array(
+            [
+                [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0]],
+            ]
+        )
+        b = a.copy()
+        b[:, 1, :] += 10.0
+        results = dtw_per_joint(a, b)
+        assert results[0].distance == pytest.approx(0.0, abs=1e-9)
+        assert results[1].distance > 0.0
+
+    def test_mismatched_joint_count_rejected(self) -> None:
+        a = np.zeros((5, 3, 3))
+        b = np.zeros((5, 2, 3))
+        with pytest.raises(ValueError, match="joint count"):
+            dtw_per_joint(a, b)
+
+
+# ---------------------------------------------------------------------------
+# dtw_relation
+# ---------------------------------------------------------------------------
+
+
+class TestDtwRelation:
+    def test_identical_sequences_distance_zero(
+        self, simple_sequence: np.ndarray
+    ) -> None:
+        result = dtw_relation(simple_sequence, simple_sequence, joint_i=0, joint_j=1)
+        assert result.distance == pytest.approx(0.0, abs=1e-9)
+
+    def test_same_relative_position_is_zero_even_under_translation(self) -> None:
+        """Translating the whole body does not change the
+        joint-to-joint displacement, so dtw_relation should be 0."""
+        a = np.zeros((4, 3, 3))
+        a[:, 0, :] = [0.0, 0.0, 0.0]
+        a[:, 1, :] = [1.0, 0.0, 0.0]
+        a[:, 2, :] = [0.0, 1.0, 0.0]
+        b = a + 50.0  # translate the whole body
+        result = dtw_relation(a, b, joint_i=0, joint_j=1)
+        assert result.distance == pytest.approx(0.0, abs=1e-9)
+
+    def test_joint_index_out_of_range_rejected(self) -> None:
+        a = np.zeros((3, 2, 3))
+        b = np.zeros((3, 2, 3))
+        with pytest.raises(ValueError, match="joint indices"):
+            dtw_relation(a, b, joint_i=0, joint_j=5)
+
+    def test_mismatched_joint_count_rejected(self) -> None:
+        a = np.zeros((3, 3, 3))
+        b = np.zeros((3, 2, 3))
+        with pytest.raises(ValueError, match="joint count"):
+            dtw_relation(a, b, joint_i=0, joint_j=1)
diff --git a/tests/unit/test_analyzer_features.py b/tests/unit/test_analyzer_features.py
new file mode 100644
index 0000000..5b06709
--- /dev/null
+++ b/tests/unit/test_analyzer_features.py
@@ -0,0 +1,303 @@
+"""Tests for :mod:`neuropose.analyzer.features`."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import pytest
+
+from neuropose.analyzer.features import (
+    FeatureStatistics,
+    extract_feature_statistics,
+    extract_joint_angles,
+    find_peaks,
+    normalize_pose_sequence,
+    pad_sequences,
+    predictions_to_numpy,
+)
+from neuropose.io import VideoPredictions
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+def _make_predictions(num_frames: int, num_persons: int = 1) -> VideoPredictions:
+    """Build a minimal VideoPredictions object for tests."""
+    frames = {}
+    for i in range(num_frames):
+        frames[f"frame_{i:06d}"] = {
+            "boxes": [[0.0, 0.0, 1.0, 1.0, 0.9]] * num_persons,
+            "poses3d": [
+                [[float(i), float(i) * 2, float(i) * 3], [0.0, 0.0, 0.0]]
+            ]
+            * num_persons,
+            "poses2d": [[[0.0, 0.0], [1.0, 1.0]]] * num_persons,
+        }
+    return VideoPredictions.model_validate(
+        {
+            "metadata": {
+                "frame_count": num_frames,
+                "fps": 30.0,
+                "width": 640,
+                "height": 480,
+            },
+            "frames": frames,
+        }
+    )
+
+
+# ---------------------------------------------------------------------------
+# predictions_to_numpy
+# ---------------------------------------------------------------------------
+
+
+class TestPredictionsToNumpy:
+    def test_single_person_shape(self) -> None:
+        predictions = _make_predictions(num_frames=4)
+        arr = predictions_to_numpy(predictions)
+        assert arr.shape == (4, 2, 3)
+        assert arr.dtype == np.float64
+
+    def test_values_preserved(self) -> None:
+        predictions = _make_predictions(num_frames=3)
+        arr = predictions_to_numpy(predictions)
+        # Frame i has joint 0 at (i, 2i, 3i) per _make_predictions.
+        for i in range(3):
+            np.testing.assert_allclose(arr[i, 0], [i, 2 * i, 3 * i])
+            np.testing.assert_allclose(arr[i, 1], [0, 0, 0])
+
+    def test_person_index_out_of_range(self) -> None:
+        predictions = _make_predictions(num_frames=2, num_persons=1)
+        with pytest.raises(ValueError, match="out of range"):
+            predictions_to_numpy(predictions, person_index=1)
+
+    def test_multi_person_with_explicit_index(self) -> None:
+        predictions = _make_predictions(num_frames=2, num_persons=2)
+        arr = predictions_to_numpy(predictions, person_index=1)
+        assert arr.shape == (2, 2, 3)
+
+    def test_empty_predictions_raises(self) -> None:
+        predictions = _make_predictions(num_frames=0)
+        with pytest.raises(ValueError, match="zero frames"):
+            predictions_to_numpy(predictions)
+
+
+# ---------------------------------------------------------------------------
+# normalize_pose_sequence
+# ---------------------------------------------------------------------------
+
+
+class TestNormalize:
+    def test_uniform_preserves_ratio(self) -> None:
+        # (frames, joints, 3) — one joint per frame, two frames.
+        seq = np.array(
+            [
+                [[0.0, 0.0, 0.0]],
+                [[3.0, 6.0, 9.0]],
+            ]
+        )
+        # Ranges: x=3, y=6, z=9. Uniform scale = 9. All values / 9.
+        result = normalize_pose_sequence(seq, axis_wise=False)
+        np.testing.assert_allclose(result, seq / 9.0)
+
+    def test_axis_wise_each_axis_to_unit_range(self) -> None:
+        seq = np.array(
+            [
+                [[0.0, 0.0, 0.0]],
+                [[3.0, 6.0, 9.0]],
+            ]
+        )
+        result = normalize_pose_sequence(seq, axis_wise=True)
+        # Per-axis normalization → each axis's max becomes 1.
+        np.testing.assert_allclose(result[0, 0], [0.0, 0.0, 0.0])
+        np.testing.assert_allclose(result[1, 0], [1.0, 1.0, 1.0])
+
+    def test_does_not_mutate_input(self) -> None:
+        seq = np.array([[[0.0, 0.0, 0.0]], [[1.0, 2.0, 3.0]]])
+        before = seq.copy()
+        normalize_pose_sequence(seq)
+        np.testing.assert_array_equal(seq, before)
+
+    def test_degenerate_sequence_rejected(self) -> None:
+        seq = np.zeros((3, 2, 3))
+        with pytest.raises(ValueError, match="degenerate"):
+            normalize_pose_sequence(seq)
+
+    def test_bad_shape_rejected(self) -> None:
+        seq = np.zeros((3, 2))  # Missing the xyz axis.
+        with pytest.raises(ValueError, match="expected"):
+            normalize_pose_sequence(seq)
+
+    def test_axis_wise_with_zero_axis_keeps_it_zero(self) -> None:
+        # Sequence where the Z axis never moves — axis_wise should not
+        # divide by zero; the Z column should remain at 0.
+        seq = np.array(
+            [
+                [[0.0, 0.0, 5.0]],
+                [[4.0, 8.0, 5.0]],
+            ]
+        )
+        result = normalize_pose_sequence(seq, axis_wise=True)
+        np.testing.assert_allclose(result[:, 0, 2], [0.0, 0.0])
+
+
+# ---------------------------------------------------------------------------
+# pad_sequences
+# ---------------------------------------------------------------------------
+
+
+class TestPadSequences:
+    def test_pads_to_max_when_target_length_none(self) -> None:
+        a = np.zeros((3, 2, 3))
+        b = np.zeros((5, 2, 3))
+        padded = pad_sequences([a, b])
+        assert all(seq.shape[0] == 5 for seq in padded)
+
+    def test_pads_to_explicit_target_length(self) -> None:
+        a = np.zeros((3, 2, 3))
+        padded = pad_sequences([a], target_length=10)
+        assert padded[0].shape == (10, 2, 3)
+
+    def test_edge_padding_repeats_last_frame(self) -> None:
+        a = np.array([[[1.0, 2.0, 3.0]]])  # shape (1, 1, 3)
+        padded = pad_sequences([a], target_length=4)
+        # All 4 frames should equal the original single frame.
+        for i in range(4):
+            np.testing.assert_allclose(padded[0][i, 0], [1.0, 2.0, 3.0])
+
+    def test_truncates_longer_than_target(self) -> None:
+        a = np.zeros((10, 2, 3))
+        padded = pad_sequences([a], target_length=4)
+        assert padded[0].shape == (4, 2, 3)
+
+    def test_does_not_mutate_input(self) -> None:
+        a = np.zeros((3, 2, 3))
+        pad_sequences([a], target_length=5)
+        assert a.shape == (3, 2, 3)
+
+    def test_mismatched_trailing_shape_rejected(self) -> None:
+        a = np.zeros((3, 2, 3))
+        b = np.zeros((3, 4, 3))  # Different joint count.
+        with pytest.raises(ValueError, match="trailing shape"):
+            pad_sequences([a, b])
+
+    def test_empty_input_with_target(self) -> None:
+        assert pad_sequences([], target_length=5) == []
+
+    def test_empty_input_without_target_raises(self) -> None:
+        with pytest.raises(ValueError, match="empty"):
+            pad_sequences([])
+
+
+# ---------------------------------------------------------------------------
+# extract_joint_angles
+# ---------------------------------------------------------------------------
+
+
+class TestExtractJointAngles:
+    def test_right_angle(self) -> None:
+        # Three joints forming a right angle at joint 1.
+        # joint 0 at (1, 0, 0), joint 1 at origin, joint 2 at (0, 1, 0).
+        sequence = np.array(
+            [
+                [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
+            ]
+        )
+        angles = extract_joint_angles(sequence, triplets=[(0, 1, 2)])
+        assert angles.shape == (1, 1)
+        assert angles[0, 0] == pytest.approx(math.pi / 2)
+
+    def test_collinear_gives_pi(self) -> None:
+        sequence = np.array(
+            [
+                [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [-1.0, 0.0, 0.0]],
+            ]
+        )
+        angles = extract_joint_angles(sequence, triplets=[(0, 1, 2)])
+        assert angles[0, 0] == pytest.approx(math.pi)
+
+    def test_multiple_triplets(self) -> None:
+        sequence = np.array(
+            [
+                [
+                    [1.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0],
+                    [0.0, 0.0, 1.0],
+                ],
+            ]
+        )
+        # Right angle at 1 (first triplet) and right angle at 1 again
+        # using joint 3 as the other arm — still 90°.
+        angles = extract_joint_angles(sequence, triplets=[(0, 1, 2), (0, 1, 3)])
+        assert angles.shape == (1, 2)
+        assert angles[0, 0] == pytest.approx(math.pi / 2)
+        assert angles[0, 1] == pytest.approx(math.pi / 2)
+
+    def test_zero_length_vector_yields_nan(self) -> None:
+        # Joints 0 and 1 coincide → v1 is the zero vector → NaN angle.
+        sequence = np.array(
+            [
+                [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 0.0, 0.0]],
+            ]
+        )
+        angles = extract_joint_angles(sequence, triplets=[(0, 1, 2)])
+        assert math.isnan(angles[0, 0])
+
+    def test_out_of_range_index_rejected(self) -> None:
+        sequence = np.zeros((1, 3, 3))
+        with pytest.raises(ValueError, match="out of range"):
+            extract_joint_angles(sequence, triplets=[(0, 1, 10)])
+
+
+# ---------------------------------------------------------------------------
+# extract_feature_statistics
+# ---------------------------------------------------------------------------
+
+
+class TestExtractFeatureStatistics:
+    def test_basic_stats(self) -> None:
+        values = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        stats = extract_feature_statistics(values)
+        assert isinstance(stats, FeatureStatistics)
+        assert stats.mean == pytest.approx(3.0)
+        assert stats.min == pytest.approx(1.0)
+        assert stats.max == pytest.approx(5.0)
+        assert stats.range == pytest.approx(4.0)
+        assert stats.std == pytest.approx(np.std(values))
+
+    def test_rejects_2d(self) -> None:
+        values = np.zeros((3, 3))
+        with pytest.raises(ValueError, match="1D"):
+            extract_feature_statistics(values)
+
+    def test_rejects_empty(self) -> None:
+        with pytest.raises(ValueError, match="empty"):
+            extract_feature_statistics(np.array([]))
+
+
+# ---------------------------------------------------------------------------
+# find_peaks
+# ---------------------------------------------------------------------------
+
+
+class TestFindPeaks:
+    def test_sine_wave_peaks(self) -> None:
+        # A sine wave over two full cycles has two peaks at quarter
+        # cycles — roughly at t=pi/2 and t=5pi/2 given 4pi duration.
+        t = np.linspace(0, 4 * np.pi, 401)
+        values = np.sin(t)
+        indices = find_peaks(values)
+        assert indices.ndim == 1
+        assert len(indices) == 2
+
+    def test_flat_signal_has_no_peaks(self) -> None:
+        indices = find_peaks(np.zeros(100))
+        assert indices.size == 0
+
+    def test_rejects_2d_input(self) -> None:
+        with pytest.raises(ValueError, match="1D"):
+            find_peaks(np.zeros((5, 5)))
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..77826ae
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1522 @@
+version = 1
+revision = 3
+requires-python = "==3.11.*"
+
+[[package]]
+name = "absl-py"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/c7/8de93764ad66968d19329a7e0c147a2bb3c7054c554d4a119111b8f9440f/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4", size = 116543, upload-time = "2026-01-28T10:17:05.322Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/a6/907a406bb7d359e6a63f99c313846d9eec4f7e6f7437809e03aa00fa3074/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d", size = 135750, upload-time = "2026-01-28T10:17:04.19Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "astunparse"
+version = "1.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+    { name = "wheel" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/af/4182184d3c338792894f34a62672919db7ca008c89abee9b564dd34d8029/astunparse-1.6.3.tar.gz", hash = "sha256:5ad93a8456f0d084c3456d059fd9a92cce667963232cbf763eac3bc5b7940872", size = 18290, upload-time = "2019-12-22T18:12:13.129Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/03/13dde6512ad7b4557eb792fbcf0c653af6076b81e5941d36ec61f7ce6028/astunparse-1.6.3-py2.py3-none-any.whl", hash = "sha256:c2652417f2c8b5bb325c885ae329bdf3f86424075c4fd1a128674bc6fba4b8e8", size = 12732, upload-time = "2019-12-22T18:12:11.297Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
+]
+
+[[package]]
+name = "backrefs"
+version = "6.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/a6/e325ec73b638d3ede4421b5445d4a0b8b219481826cc079d510100af356c/backrefs-6.2.tar.gz", hash = "sha256:f44ff4d48808b243b6c0cdc6231e22195c32f77046018141556c66f8bab72a49", size = 7012303, upload-time = "2026-02-16T19:10:15.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/39/3765df263e08a4df37f4f43cb5aa3c6c17a4bdd42ecfe841e04c26037171/backrefs-6.2-py310-none-any.whl", hash = "sha256:0fdc7b012420b6b144410342caeb8adc54c6866cf12064abc9bb211302e496f8", size = 381075, upload-time = "2026-02-16T19:10:04.322Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/f0/35240571e1b67ffb19dafb29ab34150b6f59f93f717b041082cdb1bfceb1/backrefs-6.2-py311-none-any.whl", hash = "sha256:08aa7fae530c6b2361d7bdcbda1a7c454e330cc9dbcd03f5c23205e430e5c3be", size = 392874, upload-time = "2026-02-16T19:10:06.314Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f8/d02f650c47d05034dcd6f9c8cf94f39598b7a89c00ecda0ecb2911bc27e9/backrefs-6.2-py39-none-any.whl", hash = "sha256:664e33cd88c6840b7625b826ecf2555f32d491800900f5a541f772c485f7cda7", size = 381077, upload-time = "2026-02-16T19:10:13.74Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" },
+    { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" },
+    { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" },
+    { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" },
+    { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/75/31212c6bf2503fdf920d87fee5d7a86a2e3bcf444984126f13d8e4016804/click-8.3.2.tar.gz", hash = "sha256:14162b8b3b3550a7d479eafa77dfd3c38d9dc8951f6f69c78913a8f9a7540fd5", size = 302856, upload-time = "2026-04-03T19:14:45.118Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/20/71885d8b97d4f3dde17b1fdb92dbd4908b00541c5a3379787137285f602e/click-8.3.2-py3-none-any.whl", hash = "sha256:1924d2c27c5653561cd2cae4548d1406039cb79b858b747cfea24924bbc1616d", size = 108379, upload-time = "2026-04-03T19:14:43.505Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" },
+    { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" },
+    { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" },
+    { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "fastdtw"
+version = "0.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/99/43/30f2d8db076f216b15c10db663b46e22d1750b1ebacd7af6e62b83d6ab98/fastdtw-0.3.4.tar.gz", hash = "sha256:2350fa6ec36bcad186eaf81f46eff35181baf04e324f522de8aeb43d0243f64f", size = 133402, upload-time = "2019-10-07T16:02:29.982Z" }
+
+[[package]]
+name = "filelock"
+version = "3.25.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
+]
+
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.62.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/08/7012b00a9a5874311b639c3920270c36ee0c445b69d9989a85e5c92ebcb0/fonttools-4.62.1.tar.gz", hash = "sha256:e54c75fd6041f1122476776880f7c3c3295ffa31962dc6ebe2543c00dca58b5d", size = 3580737, upload-time = "2026-03-13T13:54:25.52Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/39/23ff32561ec8d45a4d48578b4d241369d9270dc50926c017570e60893701/fonttools-4.62.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:40975849bac44fb0b9253d77420c6d8b523ac4dcdcefeff6e4d706838a5b80f7", size = 2871039, upload-time = "2026-03-13T13:52:33.127Z" },
+    { url = "https://files.pythonhosted.org/packages/24/7f/66d3f8a9338a9b67fe6e1739f47e1cd5cee78bd3bc1206ef9b0b982289a5/fonttools-4.62.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9dde91633f77fa576879a0c76b1d89de373cae751a98ddf0109d54e173b40f14", size = 2416346, upload-time = "2026-03-13T13:52:35.676Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/53/5276ceba7bff95da7793a07c5284e1da901cf00341ce5e2f3273056c0cca/fonttools-4.62.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6acb4109f8bee00fec985c8c7afb02299e35e9c94b57287f3ea542f28bd0b0a7", size = 5100897, upload-time = "2026-03-13T13:52:38.102Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a1/40a5c4d8e28b0851d53a8eeeb46fbd73c325a2a9a165f290a5ed90e6c597/fonttools-4.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1c5c25671ce8805e0d080e2ffdeca7f1e86778c5cbfbeae86d7f866d8830517b", size = 5071078, upload-time = "2026-03-13T13:52:41.305Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/be/d378fca4c65ea1956fee6d90ace6e861776809cbbc5af22388a090c3c092/fonttools-4.62.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a5d8825e1140f04e6c99bb7d37a9e31c172f3bc208afbe02175339e699c710e1", size = 5076908, upload-time = "2026-03-13T13:52:44.122Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d9/ae6a1d0693a4185a84605679c8a1f719a55df87b9c6e8e817bfdd9ef5936/fonttools-4.62.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:268abb1cb221e66c014acc234e872b7870d8b5d4657a83a8f4205094c32d2416", size = 5202275, upload-time = "2026-03-13T13:52:46.591Z" },
+    { url = "https://files.pythonhosted.org/packages/54/6c/af95d9c4efb15cabff22642b608342f2bd67137eea6107202d91b5b03184/fonttools-4.62.1-cp311-cp311-win32.whl", hash = "sha256:942b03094d7edbb99bdf1ae7e9090898cad7bf9030b3d21f33d7072dbcb51a53", size = 2293075, upload-time = "2026-03-13T13:52:48.711Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/97/bf54c5b3f2be34e1f143e6db838dfdc54f2ffa3e68c738934c82f3b2a08d/fonttools-4.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:e8514f4924375f77084e81467e63238b095abda5107620f49421c368a6017ed2", size = 2344593, upload-time = "2026-03-13T13:52:50.725Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ba/56147c165442cc5ba7e82ecf301c9a68353cede498185869e6e02b4c264f/fonttools-4.62.1-py3-none-any.whl", hash = "sha256:7487782e2113861f4ddcc07c3436450659e3caa5e470b27dc2177cade2d8e7fd", size = 1152647, upload-time = "2026-03-13T13:54:22.735Z" },
+]
+
+[[package]]
+name = "gast"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/f6/e73969782a2ecec280f8a176f2476149dd9dba69d5f8779ec6108a7721e6/gast-0.7.0.tar.gz", hash = "sha256:0bb14cd1b806722e91ddbab6fb86bba148c22b40e7ff11e248974e04c8adfdae", size = 33630, upload-time = "2025-11-29T15:30:05.266Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/33/f1c6a276de27b7d7339a34749cc33fa87f077f921969c47185d34a887ae2/gast-0.7.0-py3-none-any.whl", hash = "sha256:99cbf1365633a74099f69c59bd650476b96baa5ef196fec88032b00b31ba36f7", size = 22966, upload-time = "2025-11-29T15:30:03.983Z" },
+]
+
+[[package]]
+name = "ghp-import"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
+]
+
+[[package]]
+name = "google-pasta"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/35/4a/0bd53b36ff0323d10d5f24ebd67af2de10a1117f5cf4d7add90df92756f1/google-pasta-0.2.0.tar.gz", hash = "sha256:c9f2c8dfc8f96d0d5808299920721be30c9eec37f2389f28904f454565c8a16e", size = 40430, upload-time = "2020-03-13T18:57:50.34Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/de/c648ef6835192e6e2cc03f40b19eeda4382c49b5bafb43d88b931c4c74ac/google_pasta-0.2.0-py3-none-any.whl", hash = "sha256:b32482794a366b5366a32c92a9a9201b107821889935a02b3e51f6b432ea84ed", size = 57471, upload-time = "2020-03-13T18:57:48.872Z" },
+]
+
+[[package]]
+name = "griffelib"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/82/74f4a3310cdabfbb10da554c3a672847f1ed33c6f61dd472681ce7f1fe67/griffelib-2.0.2.tar.gz", hash = "sha256:3cf20b3bc470e83763ffbf236e0076b1211bac1bc67de13daf494640f2de707e", size = 166461, upload-time = "2026-03-27T11:34:51.091Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/8c/c9138d881c79aa0ea9ed83cbd58d5ca75624378b38cee225dcf5c42cc91f/griffelib-2.0.2-py3-none-any.whl", hash = "sha256:925c857658fb1ba40c0772c37acbc2ab650bd794d9c1b9726922e36ea4117ea1", size = 142357, upload-time = "2026-03-27T11:34:46.275Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" },
+    { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" },
+    { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" },
+    { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" },
+]
+
+[[package]]
+name = "h5py"
+version = "3.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5d/57/dfb3c5c3f1bf5f5ef2e59a22dec4ff1f3d7408b55bfcefcfb0ea69ef21c6/h5py-3.14.0.tar.gz", hash = "sha256:2372116b2e0d5d3e5e705b7f663f7c8d96fa79a4052d250484ef91d24d6a08f4", size = 424323, upload-time = "2025-06-06T14:06:15.01Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/1b/ad24a8ce846cf0519695c10491e99969d9d203b9632c4fcd5004b1641c2e/h5py-3.14.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f30dbc58f2a0efeec6c8836c97f6c94afd769023f44e2bb0ed7b17a16ec46088", size = 3352382, upload-time = "2025-06-06T14:04:37.95Z" },
+    { url = "https://files.pythonhosted.org/packages/36/5b/a066e459ca48b47cc73a5c668e9924d9619da9e3c500d9fb9c29c03858ec/h5py-3.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:543877d7f3d8f8a9828ed5df6a0b78ca3d8846244b9702e99ed0d53610b583a8", size = 2852492, upload-time = "2025-06-06T14:04:42.092Z" },
+    { url = "https://files.pythonhosted.org/packages/08/0c/5e6aaf221557314bc15ba0e0da92e40b24af97ab162076c8ae009320a42b/h5py-3.14.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c497600c0496548810047257e36360ff551df8b59156d3a4181072eed47d8ad", size = 4298002, upload-time = "2025-06-06T14:04:47.106Z" },
+    { url = "https://files.pythonhosted.org/packages/21/d4/d461649cafd5137088fb7f8e78fdc6621bb0c4ff2c090a389f68e8edc136/h5py-3.14.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:723a40ee6505bd354bfd26385f2dae7bbfa87655f4e61bab175a49d72ebfc06b", size = 4516618, upload-time = "2025-06-06T14:04:52.467Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0c/6c3f879a0f8e891625817637fad902da6e764e36919ed091dc77529004ac/h5py-3.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:d2744b520440a996f2dae97f901caa8a953afc055db4673a993f2d87d7f38713", size = 2874888, upload-time = "2025-06-06T14:04:56.95Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/c4/7fb4db12296cdb11893d61c92048fe617ee853f8523b9b296ac03b43757e/identify-2.6.18.tar.gz", hash = "sha256:873ac56a5e3fd63e7438a7ecbc4d91aca692eb3fefa4534db2b7913f3fc352fd", size = 99580, upload-time = "2026-03-15T18:39:50.319Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/33/92ef41c6fad0233e41d3d84ba8e8ad18d1780f1e5d99b3c683e6d7f98b63/identify-2.6.18-py2.py3-none-any.whl", hash = "sha256:8db9d3c8ea9079db92cafb0ebf97abdc09d52e97f4dcf773a2e694048b7cd737", size = 99394, upload-time = "2026-03-15T18:39:48.915Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "joblib"
+version = "1.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
+]
+
+[[package]]
+name = "keras"
+version = "3.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "h5py" },
+    { name = "ml-dtypes" },
+    { name = "namex" },
+    { name = "numpy" },
+    { name = "optree" },
+    { name = "packaging" },
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/ce/47874047a49eedc2a5d3b41bc4f1f572bb637f51e4351ef3538e49a63800/keras-3.14.0.tar.gz", hash = "sha256:86fcf8249a25264a566ac393c287c7ad657000e5e62615dcaad4b3472a17aeda", size = 1263098, upload-time = "2026-04-03T01:42:16.386Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/20/78d26f81115d570bdf0e57d19b81de9ad8aa55ddb68eb10c8f0699fccb63/keras-3.14.0-py3-none-any.whl", hash = "sha256:19ce94b798caaba4d404ab6ef4753b44219170e5c2868156de8bb0494a260114", size = 1627362, upload-time = "2026-04-03T01:42:11.606Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" },
+    { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" },
+    { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" },
+    { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" },
+    { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" },
+    { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" },
+    { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" },
+]
+
+[[package]]
+name = "libclang"
+version = "18.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6e/5c/ca35e19a4f142adffa27e3d652196b7362fa612243e2b916845d801454fc/libclang-18.1.1.tar.gz", hash = "sha256:a1214966d08d73d971287fc3ead8dfaf82eb07fb197680d8b3859dbbbbf78250", size = 39612, upload-time = "2024-03-17T16:04:37.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/49/f5e3e7e1419872b69f6f5e82ba56e33955a74bd537d8a1f5f1eff2f3668a/libclang-18.1.1-1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:0b2e143f0fac830156feb56f9231ff8338c20aecfe72b4ffe96f19e5a1dbb69a", size = 25836045, upload-time = "2024-06-30T17:40:31.646Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e5/fc61bbded91a8830ccce94c5294ecd6e88e496cc85f6704bf350c0634b70/libclang-18.1.1-py2.py3-none-macosx_10_9_x86_64.whl", hash = "sha256:6f14c3f194704e5d09769108f03185fce7acaf1d1ae4bbb2f30a72c2400cb7c5", size = 26502641, upload-time = "2024-03-18T15:52:26.722Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/1df62b44db2583375f6a8a5e2ca5432bbdc3edb477942b9b7c848c720055/libclang-18.1.1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:83ce5045d101b669ac38e6da8e58765f12da2d3aafb3b9b98d88b286a60964d8", size = 26420207, upload-time = "2024-03-17T15:00:26.63Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/716c1e62e512ef1c160e7984a73a5fc7df45166f2ff3f254e71c58076f7c/libclang-18.1.1-py2.py3-none-manylinux2010_x86_64.whl", hash = "sha256:c533091d8a3bbf7460a00cb6c1a71da93bffe148f172c7d03b1c31fbf8aa2a0b", size = 24515943, upload-time = "2024-03-17T16:03:45.942Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/3d/f0ac1150280d8d20d059608cf2d5ff61b7c3b7f7bcf9c0f425ab92df769a/libclang-18.1.1-py2.py3-none-manylinux2014_aarch64.whl", hash = "sha256:54dda940a4a0491a9d1532bf071ea3ef26e6dbaf03b5000ed94dd7174e8f9592", size = 23784972, upload-time = "2024-03-17T16:12:47.677Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/2f/d920822c2b1ce9326a4c78c0c2b4aa3fde610c7ee9f631b600acb5376c26/libclang-18.1.1-py2.py3-none-manylinux2014_armv7l.whl", hash = "sha256:cf4a99b05376513717ab5d82a0db832c56ccea4fd61a69dbb7bccf2dfb207dbe", size = 20259606, upload-time = "2024-03-17T16:17:42.437Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c2/de1db8c6d413597076a4259cea409b83459b2db997c003578affdd32bf66/libclang-18.1.1-py2.py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:69f8eb8f65c279e765ffd28aaa7e9e364c776c17618af8bff22a8df58677ff4f", size = 24921494, upload-time = "2024-03-17T16:14:20.132Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/2d/3f480b1e1d31eb3d6de5e3ef641954e5c67430d5ac93b7fa7e07589576c7/libclang-18.1.1-py2.py3-none-win_amd64.whl", hash = "sha256:4dd2d3b82fab35e2bf9ca717d7b63ac990a3519c7e312f19fa8e86dcc712f7fb", size = 26415083, upload-time = "2024-03-17T16:42:21.703Z" },
+    { url = "https://files.pythonhosted.org/packages/71/cf/e01dc4cc79779cd82d77888a88ae2fa424d93b445ad4f6c02bfc18335b70/libclang-18.1.1-py2.py3-none-win_arm64.whl", hash = "sha256:3f0e1f49f04d3cd198985fea0511576b0aee16f9ff0e0f0cad7f9c57ec3c20e8", size = 22361112, upload-time = "2024-03-17T16:42:59.565Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/f4/69fa6ed85ae003c2378ffa8f6d2e3234662abd02c10d216c0ba96081a238/markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", size = 368805, upload-time = "2026-02-09T14:57:26.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/1f/77fa3081e4f66ca3576c896ae5d31c3002ac6607f9747d2e3aa49227e464/markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36", size = 108180, upload-time = "2026-02-09T14:57:25.787Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" },
+    { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" },
+    { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mergedeep"
+version = "1.3.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
+]
+
+[[package]]
+name = "mkdocs"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "ghp-import" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mergedeep" },
+    { name = "mkdocs-get-deps" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "pyyaml" },
+    { name = "pyyaml-env-tag" },
+    { name = "watchdog" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" },
+]
+
+[[package]]
+name = "mkdocs-autorefs"
+version = "1.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/c0/f641843de3f612a6b48253f39244165acff36657a91cc903633d456ae1ac/mkdocs_autorefs-1.4.4.tar.gz", hash = "sha256:d54a284f27a7346b9c38f1f852177940c222da508e66edc816a0fa55fc6da197", size = 56588, upload-time = "2026-02-10T15:23:55.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/de/a3e710469772c6a89595fc52816da05c1e164b4c866a89e3cb82fb1b67c5/mkdocs_autorefs-1.4.4-py3-none-any.whl", hash = "sha256:834ef5408d827071ad1bc69e0f39704fa34c7fc05bc8e1c72b227dfdc5c76089", size = 25530, upload-time = "2026-02-10T15:23:53.817Z" },
+]
+
+[[package]]
+name = "mkdocs-get-deps"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mergedeep" },
+    { name = "platformdirs" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/25/b3cccb187655b9393572bde9b09261d267c3bf2f2cdabe347673be5976a6/mkdocs_get_deps-0.2.2.tar.gz", hash = "sha256:8ee8d5f316cdbbb2834bc1df6e69c08fe769a83e040060de26d3c19fad3599a1", size = 11047, upload-time = "2026-03-10T02:46:33.632Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/29/744136411e785c4b0b744d5413e56555265939ab3a104c6a4b719dad33fd/mkdocs_get_deps-0.2.2-py3-none-any.whl", hash = "sha256:e7878cbeac04860b8b5e0ca31d3abad3df9411a75a32cde82f8e44b6c16ff650", size = 9555, upload-time = "2026-03-10T02:46:32.256Z" },
+]
+
+[[package]]
+name = "mkdocs-material"
+version = "9.7.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "backrefs" },
+    { name = "colorama" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "mkdocs" },
+    { name = "mkdocs-material-extensions" },
+    { name = "paginate" },
+    { name = "pygments" },
+    { name = "pymdown-extensions" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/29/6d2bcf41ae40802c4beda2432396fff97b8456fb496371d1bc7aad6512ec/mkdocs_material-9.7.6.tar.gz", hash = "sha256:00bdde50574f776d328b1862fe65daeaf581ec309bd150f7bff345a098c64a69", size = 4097959, upload-time = "2026-03-19T15:41:58.161Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/01/bc663630c510822c95c47a66af9fa7a443c295b47d5f041e5e6ae62ef659/mkdocs_material-9.7.6-py3-none-any.whl", hash = "sha256:71b84353921b8ea1ba84fe11c50912cc512da8fe0881038fcc9a0761c0e635ba", size = 9305470, upload-time = "2026-03-19T15:41:55.217Z" },
+]
+
+[[package]]
+name = "mkdocs-material-extensions"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" },
+]
+
+[[package]]
+name = "mkdocstrings"
+version = "1.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+    { name = "mkdocs-autorefs" },
+    { name = "pymdown-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/62/0dfc5719514115bf1781f44b1d7f2a0923fcc01e9c5d7990e48a05c9ae5d/mkdocstrings-1.0.3.tar.gz", hash = "sha256:ab670f55040722b49bb45865b2e93b824450fb4aef638b00d7acb493a9020434", size = 100946, upload-time = "2026-02-07T14:31:40.973Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/41/1cf02e3df279d2dd846a1bf235a928254eba9006dd22b4a14caa71aed0f7/mkdocstrings-1.0.3-py3-none-any.whl", hash = "sha256:0d66d18430c2201dc7fe85134277382baaa15e6b30979f3f3bdbabd6dbdb6046", size = 35523, upload-time = "2026-02-07T14:31:39.27Z" },
+]
+
+[package.optional-dependencies]
+python = [
+    { name = "mkdocstrings-python" },
+]
+
+[[package]]
+name = "mkdocstrings-python"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffelib" },
+    { name = "mkdocs-autorefs" },
+    { name = "mkdocstrings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/29/33/c225eaf898634bdda489a6766fc35d1683c640bffe0e0acd10646b13536d/mkdocstrings_python-2.0.3.tar.gz", hash = "sha256:c518632751cc869439b31c9d3177678ad2bfa5c21b79b863956ad68fc92c13b8", size = 199083, upload-time = "2026-02-20T10:38:36.368Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/28/79f0f8de97cce916d5ae88a7bee1ad724855e83e6019c0b4d5b3fabc80f3/mkdocstrings_python-2.0.3-py3-none-any.whl", hash = "sha256:0b83513478bdfd803ff05aa43e9b1fca9dd22bcd9471f09ca6257f009bc5ee12", size = 104779, upload-time = "2026-02-20T10:38:34.517Z" },
+]
+
+[[package]]
+name = "ml-dtypes"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/5e/712092cfe7e5eb667b8ad9ca7c54442f21ed7ca8979745f1000e24cf8737/ml_dtypes-0.5.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90", size = 679734, upload-time = "2025-11-17T22:31:39.223Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/cf/912146dfd4b5c0eea956836c01dcd2fce6c9c844b2691f5152aca196ce4f/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040", size = 5056165, upload-time = "2025-11-17T22:31:41.071Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/80/19189ea605017473660e43762dc853d2797984b3c7bf30ce656099add30c/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483", size = 5034975, upload-time = "2025-11-17T22:31:42.758Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/24/70bd59276883fdd91600ca20040b41efd4902a923283c4d6edcb1de128d2/ml_dtypes-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb", size = 210742, upload-time = "2025-11-17T22:31:44.068Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c9/64230ef14e40aa3f1cb254ef623bf812735e6bec7772848d19131111ac0d/ml_dtypes-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de", size = 160709, upload-time = "2025-11-17T22:31:46.557Z" },
+]
+
+[[package]]
+name = "namex"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0c/c0/ee95b28f029c73f8d49d8f52edaed02a1d4a9acb8b69355737fdb1faa191/namex-0.1.0.tar.gz", hash = "sha256:117f03ccd302cc48e3f5c58a296838f6b89c83455ab8683a1e85f2a430aa4306", size = 6649, upload-time = "2025-05-26T23:17:38.918Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/bc/465daf1de06409cdd4532082806770ee0d8d7df434da79c76564d0f69741/namex-0.1.0-py3-none-any.whl", hash = "sha256:e2012a474502f1e2251267062aae3114611f07df4224b6e06334c57b0f2ce87c", size = 5905, upload-time = "2025-05-26T23:17:37.695Z" },
+]
+
+[[package]]
+name = "neuropose"
+version = "0.1.0.dev0"
+source = { editable = "." }
+dependencies = [
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "opencv-python-headless" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "pyyaml" },
+    { name = "tensorflow" },
+    { name = "tensorflow-hub" },
+    { name = "typer" },
+]
+
+[package.optional-dependencies]
+analysis = [
+    { name = "fastdtw" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+    { name = "sktime" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "fastdtw" },
+    { name = "mkdocs-material" },
+    { name = "mkdocstrings", extra = ["python"] },
+    { name = "pre-commit" },
+    { name = "pyright" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
+    { name = "scipy" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastdtw", marker = "extra == 'analysis'", specifier = ">=0.3.4" },
+    { name = "matplotlib", specifier = ">=3.8" },
+    { name = "numpy", specifier = ">=1.26" },
+    { name = "opencv-python-headless", specifier = ">=4.9" },
+    { name = "pydantic", specifier = ">=2.6" },
+    { name = "pydantic-settings", specifier = ">=2.2" },
+    { name = "pyyaml", specifier = ">=6.0" },
+    { name = "scikit-learn", marker = "extra == 'analysis'", specifier = ">=1.4" },
+    { name = "scipy", marker = "extra == 'analysis'", specifier = ">=1.12" },
+    { name = "sktime", marker = "extra == 'analysis'", specifier = ">=0.28" },
+    { name = "tensorflow", specifier = ">=2.15,<3.0" },
+    { name = "tensorflow-hub", specifier = ">=0.16" },
+    { name = "typer", specifier = ">=0.12" },
+]
+provides-extras = ["analysis"]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fastdtw", specifier = ">=0.3.4" },
+    { name = "mkdocs-material", specifier = ">=9.5" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.26" },
+    { name = "pre-commit", specifier = ">=4.0" },
+    { name = "pyright", specifier = ">=1.1.390" },
+    { name = "pytest", specifier = ">=8.0" },
+    { name = "pytest-cov", specifier = ">=5.0" },
+    { name = "ruff", specifier = ">=0.8" },
+    { name = "scipy", specifier = ">=1.12" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.3.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload-time = "2025-11-16T22:52:42.067Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/77/84dd1d2e34d7e2792a236ba180b5e8fcc1e3e414e761ce0253f63d7f572e/numpy-2.3.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de5672f4a7b200c15a4127042170a694d4df43c992948f5e1af57f0174beed10", size = 17034641, upload-time = "2025-11-16T22:49:19.336Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ea/25e26fa5837106cde46ae7d0b667e20f69cbbc0efd64cba8221411ab26ae/numpy-2.3.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:acfd89508504a19ed06ef963ad544ec6664518c863436306153e13e94605c218", size = 12528324, upload-time = "2025-11-16T22:49:22.582Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/1a/e85f0eea4cf03d6a0228f5c0256b53f2df4bc794706e7df019fc622e47f1/numpy-2.3.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe22d2b05504f786c867c8395de703937f934272eb67586817b46188b4ded6d", size = 5356872, upload-time = "2025-11-16T22:49:25.408Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/bb/35ef04afd567f4c989c2060cde39211e4ac5357155c1833bcd1166055c61/numpy-2.3.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:872a5cf366aec6bb1147336480fef14c9164b154aeb6542327de4970282cd2f5", size = 6893148, upload-time = "2025-11-16T22:49:27.549Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/2b/05bbeb06e2dff5eab512dfc678b1cc5ee94d8ac5956a0885c64b6b26252b/numpy-2.3.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3095bdb8dd297e5920b010e96134ed91d852d81d490e787beca7e35ae1d89cf7", size = 14557282, upload-time = "2025-11-16T22:49:30.964Z" },
+    { url = "https://files.pythonhosted.org/packages/65/fb/2b23769462b34398d9326081fad5655198fcf18966fcb1f1e49db44fbf31/numpy-2.3.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cba086a43d54ca804ce711b2a940b16e452807acebe7852ff327f1ecd49b0d4", size = 16897903, upload-time = "2025-11-16T22:49:34.191Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/14/085f4cf05fc3f1e8aa95e85404e984ffca9b2275a5dc2b1aae18a67538b8/numpy-2.3.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6cf9b429b21df6b99f4dee7a1218b8b7ffbbe7df8764dc0bd60ce8a0708fed1e", size = 16341672, upload-time = "2025-11-16T22:49:37.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/3b/1f73994904142b2aa290449b3bb99772477b5fd94d787093e4f24f5af763/numpy-2.3.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:396084a36abdb603546b119d96528c2f6263921c50df3c8fd7cb28873a237748", size = 18838896, upload-time = "2025-11-16T22:49:39.727Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/b9/cf6649b2124f288309ffc353070792caf42ad69047dcc60da85ee85fea58/numpy-2.3.5-cp311-cp311-win32.whl", hash = "sha256:b0c7088a73aef3d687c4deef8452a3ac7c1be4e29ed8bf3b366c8111128ac60c", size = 6563608, upload-time = "2025-11-16T22:49:42.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/44/9fe81ae1dcc29c531843852e2874080dc441338574ccc4306b39e2ff6e59/numpy-2.3.5-cp311-cp311-win_amd64.whl", hash = "sha256:a414504bef8945eae5f2d7cb7be2d4af77c5d1cb5e20b296c2c25b61dff2900c", size = 13078442, upload-time = "2025-11-16T22:49:43.99Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/a7/f99a41553d2da82a20a2f22e93c94f928e4490bb447c9ff3c4ff230581d3/numpy-2.3.5-cp311-cp311-win_arm64.whl", hash = "sha256:0cd00b7b36e35398fa2d16af7b907b65304ef8bb4817a550e06e5012929830fa", size = 10458555, upload-time = "2025-11-16T22:49:47.092Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/65/f9dea8e109371ade9c782b4e4756a82edf9d3366bca495d84d79859a0b79/numpy-2.3.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0963b55cdd70fad460fa4c1341f12f976bb26cb66021a5580329bd498988310", size = 16910689, upload-time = "2025-11-16T22:52:23.247Z" },
+    { url = "https://files.pythonhosted.org/packages/00/4f/edb00032a8fb92ec0a679d3830368355da91a69cab6f3e9c21b64d0bb986/numpy-2.3.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f4255143f5160d0de972d28c8f9665d882b5f61309d8362fdd3e103cf7bf010c", size = 12457053, upload-time = "2025-11-16T22:52:26.367Z" },
+    { url = "https://files.pythonhosted.org/packages/16/a4/e8a53b5abd500a63836a29ebe145fc1ab1f2eefe1cfe59276020373ae0aa/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:a4b9159734b326535f4dd01d947f919c6eefd2d9827466a696c44ced82dfbc18", size = 5285635, upload-time = "2025-11-16T22:52:29.266Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/2f/37eeb9014d9c8b3e9c55bc599c68263ca44fdbc12a93e45a21d1d56df737/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2feae0d2c91d46e59fcd62784a3a83b3fb677fead592ce51b5a6fbb4f95965ff", size = 6801770, upload-time = "2025-11-16T22:52:31.421Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/e4/68d2f474df2cb671b2b6c2986a02e520671295647dad82484cde80ca427b/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffac52f28a7849ad7576293c0cb7b9f08304e8f7d738a8cb8a90ec4c55a998eb", size = 14391768, upload-time = "2025-11-16T22:52:33.593Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/50/94ccd8a2b141cb50651fddd4f6a48874acb3c91c8f0842b08a6afc4b0b21/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c0e9e7eea69588479ebf4a8a270d5ac22763cc5854e9a7eae952a3908103f7", size = 16729263, upload-time = "2025-11-16T22:52:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ee/346fa473e666fe14c52fcdd19ec2424157290a032d4c41f98127bfb31ac7/numpy-2.3.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f16417ec91f12f814b10bafe79ef77e70113a2f5f7018640e7425ff979253425", size = 12967213, upload-time = "2025-11-16T22:52:39.38Z" },
+]
+
+[[package]]
+name = "opencv-python-headless"
+version = "4.13.0.92"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/42/2310883be3b8826ac58c3f2787b9358a2d46923d61f88fedf930bc59c60c/opencv_python_headless-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:1a7d040ac656c11b8c38677cc8cccdc149f98535089dbe5b081e80a4e5903209", size = 46247192, upload-time = "2026-02-05T07:01:35.187Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/1e/6f9e38005a6f7f22af785df42a43139d0e20f169eb5787ce8be37ee7fcc9/opencv_python_headless-4.13.0.92-cp37-abi3-macosx_14_0_x86_64.whl", hash = "sha256:3e0a6f0a37994ec6ce5f59e936be21d5d6384a4556f2d2da9c2f9c5dc948394c", size = 32568914, upload-time = "2026-02-05T07:01:51.989Z" },
+    { url = "https://files.pythonhosted.org/packages/21/76/9417a6aef9def70e467a5bf560579f816148a4c658b7d525581b356eda9e/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c8cfc8e87ed452b5cecb9419473ee5560a989859fe1d10d1ce11ae87b09a2cb", size = 33703709, upload-time = "2026-02-05T10:24:46.469Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ce/bd17ff5772938267fd49716e94ca24f616ff4cb1ff4c6be13085108037be/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0525a3d2c0b46c611e2130b5fdebc94cf404845d8fa64d2f3a3b679572a5bd22", size = 56016764, upload-time = "2026-02-05T10:26:48.904Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b4/b7bcbf7c874665825a8c8e1097e93ea25d1f1d210a3e20d4451d01da30aa/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb60e36b237b1ebd40a912da5384b348df8ed534f6f644d8e0b4f103e272ba7d", size = 35010236, upload-time = "2026-02-05T10:28:11.031Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/33/b5db29a6c00eb8f50708110d8d453747ca125c8b805bc437b289dbdcc057/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0bd48544f77c68b2941392fcdf9bcd2b9cdf00e98cb8c29b2455d194763cf99e", size = 60391106, upload-time = "2026-02-05T10:30:14.236Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c3/52cfea47cd33e53e8c0fbd6e7c800b457245c1fda7d61660b4ffe9596a7f/opencv_python_headless-4.13.0.92-cp37-abi3-win32.whl", hash = "sha256:a7cf08e5b191f4ebb530791acc0825a7986e0d0dee2a3c491184bd8599848a4b", size = 30812232, upload-time = "2026-02-05T07:02:29.594Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/90/b338326131ccb2aaa3c2c85d00f41822c0050139a4bfe723cfd95455bd2d/opencv_python_headless-4.13.0.92-cp37-abi3-win_amd64.whl", hash = "sha256:77a82fe35ddcec0f62c15f2ba8a12ecc2ed4207c17b0902c7a3151ae29f37fb6", size = 40070414, upload-time = "2026-02-05T07:02:26.448Z" },
+]
+
+[[package]]
+name = "opt-einsum"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/b9/2ac072041e899a52f20cf9510850ff58295003aa75525e58343591b0cbfb/opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac", size = 63004, upload-time = "2024-09-26T14:33:24.483Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932, upload-time = "2024-09-26T14:33:23.039Z" },
+]
+
+[[package]]
+name = "optree"
+version = "0.19.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/63/7b078bc36d5a206c21b03565a818ede38ff0fbf014e92085ec467ef10adb/optree-0.19.0.tar.gz", hash = "sha256:bc1991a948590756409e76be4e29efd4a487a185056d35db6c67619c19ea27a1", size = 175199, upload-time = "2026-02-23T01:56:37.752Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5e/5967a15ed63d98717815a51265bd73fb5ec5a4ca9938c59be909ef12f66f/optree-0.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e245b03f4edc90971dcf01691775105084f433393e6ba19a6fd0f151d5f39b58", size = 408515, upload-time = "2026-02-23T01:54:50.888Z" },
+    { url = "https://files.pythonhosted.org/packages/43/5b/4e062008bfd2f836079afec06dd9cba76a01010aaffa8eae0d1915fa0ef6/optree-0.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:304ebd0449ace6ab0c18489baea1163a915b9aeb43a8635c6373ec09767fa1ba", size = 378935, upload-time = "2026-02-23T01:54:52.372Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/da/67424dad1834ba4bfe1ca16c1ca754e5fd32d7f8e7a488a70346c1bf1160/optree-0.19.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48366b810f0d37e2fa7bcb758d2a3198d62f0a4a60ac7e14287768345a4a95a9", size = 400165, upload-time = "2026-02-23T01:54:53.579Z" },
+    { url = "https://files.pythonhosted.org/packages/65/af/f49c516de0ca47ce6a7a8f74499e63ba0a07744eae78958a2e6de0902fd6/optree-0.19.0-cp311-cp311-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:b511556fdc5a558ccd65f841710e9103f120cb575735f87ddfa3728b4098e606", size = 460863, upload-time = "2026-02-23T01:54:55.718Z" },
+    { url = "https://files.pythonhosted.org/packages/92/cb/01e0a0551d6934f1158a7f90f690b4a68c1a08ba519ea4ab113e4064e499/optree-0.19.0-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba4925025a47b12237ff8acdcf8b9e972e7f36acafb291373d4de318a4b1b12c", size = 459863, upload-time = "2026-02-23T01:54:57.045Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/65/16b9c07e894a51e807404855e717e7e8221ce55f7fec3df46e9dc67c378c/optree-0.19.0-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a8d873ae944fb7d11797bb2ea2666379e78a4608e918d69a4c97fef4779f7da4", size = 459552, upload-time = "2026-02-23T01:54:58.159Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/34/3c9e11011c73457dc00e031713df6822eb0690cb849f479796073e070a56/optree-0.19.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6437d23f2708fe0fcdba9d3d75a1b82022caf2c15248059b8bf7e563422fb71", size = 441096, upload-time = "2026-02-23T01:54:59.536Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/39/0932e49b76fc3354a9c39c8bb57b04661e83b28fa6c74be09b520d98915b/optree-0.19.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:c2e01d07b2368f25932d5c6071d270a1d4db9e6cb2014eaafeded3d4c73ee406", size = 404747, upload-time = "2026-02-23T01:55:00.591Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d4/11ba9195b65bd77f8955bad5aca8c5fbfb0b273e52c4e7b29b3416c587f0/optree-0.19.0-cp311-cp311-win32.whl", hash = "sha256:846d07372ebc2ca959e9660b28d7c59ae34a02aac2fb73d0f3ec3de79af2fcb0", size = 306775, upload-time = "2026-02-23T01:55:01.659Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/ee6a65060edde25517151eff8a9e1468e6fd65054fabd14a441161eeafd6/optree-0.19.0-cp311-cp311-win_amd64.whl", hash = "sha256:29d757b394641703098e1f9a62203c46a5f5cfa260cb8546bd05c8a2cdaf8754", size = 331592, upload-time = "2026-02-23T01:55:03.089Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/5e/3a4a66d0ecee599b948d2ef17010fcb9c111c69753a3911e4301005169a8/optree-0.19.0-cp311-cp311-win_arm64.whl", hash = "sha256:fd425b501420b437d5e925708898fae927660fd433836ac282adb20d54561c63", size = 343392, upload-time = "2026-02-23T01:55:04.201Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/a31c2b7ee12f2c7a24a8d57aeecbbcd4c513152212aa1958fff736900033/optree-0.19.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:2806e7baafc3c2985b71a5202fe3bde75838c7f09c0df0aa43a2e7ae12e65587", size = 411712, upload-time = "2026-02-23T01:56:31.829Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/db/33b61930bf2a879d9b114e63723ccf3965404d4fb5caffad5bee1a5be61c/optree-0.19.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:c39df2d664e3d54faaabfeda3ccfc4a768fc1314578b9ef741055387e13ef3bb", size = 384082, upload-time = "2026-02-23T01:56:32.962Z" },
+    { url = "https://files.pythonhosted.org/packages/81/b1/64d04f0169feba3555434013ba2328019c2bde4d5d14600acfdcb91102a9/optree-0.19.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8bdb37b57863f18fad5601af4b94e8bc0ac145040b0ecbbc87f93d27fd6a676e", size = 403543, upload-time = "2026-02-23T01:56:33.983Z" },
+    { url = "https://files.pythonhosted.org/packages/39/5c/cc9683a8c9eb54ba48739b7c394503d7df7a22b9f4bd2463ace46bbec593/optree-0.19.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b279f6d5e1cfe681b8bc8678529048081fe5ddaf49333a8bb13f3fb978dfdea", size = 444272, upload-time = "2026-02-23T01:56:35.453Z" },
+    { url = "https://files.pythonhosted.org/packages/10/a7/9eb8b63ea378274517233ba0f2f0091a4cf38d92f91c9b1e6e646af31a8b/optree-0.19.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:7bcb4e3e0b2b6db57e0882f0ba6b03a07d1489887e7e75d75c42b0e2be9f0019", size = 335393, upload-time = "2026-02-23T01:56:36.659Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "paginate"
+version = "0.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "2.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" },
+    { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" },
+    { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" },
+    { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" },
+    { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.34.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/6b/a0e95cad1ad7cc3f2c6821fcab91671bd5b78bd42afb357bb4765f29bc41/protobuf-7.34.1.tar.gz", hash = "sha256:9ce42245e704cc5027be797c1db1eb93184d44d1cdd71811fb2d9b25ad541280", size = 454708, upload-time = "2026-03-20T17:34:47.036Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/11/3325d41e6ee15bf1125654301211247b042563bcc898784351252549a8ad/protobuf-7.34.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8b2cc79c4d8f62b293ad9b11ec3aebce9af481fa73e64556969f7345ebf9fc7", size = 429247, upload-time = "2026-03-20T17:34:37.024Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/9d/aa69df2724ff63efa6f72307b483ce0827f4347cc6d6df24b59e26659fef/protobuf-7.34.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:5185e0e948d07abe94bb76ec9b8416b604cfe5da6f871d67aad30cbf24c3110b", size = 325753, upload-time = "2026-03-20T17:34:38.751Z" },
+    { url = "https://files.pythonhosted.org/packages/92/e8/d174c91fd48e50101943f042b09af9029064810b734e4160bbe282fa1caa/protobuf-7.34.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:403b093a6e28a960372b44e5eb081775c9b056e816a8029c61231743d63f881a", size = 340198, upload-time = "2026-03-20T17:34:39.871Z" },
+    { url = "https://files.pythonhosted.org/packages/53/1b/3b431694a4dc6d37b9f653f0c64b0a0d9ec074ee810710c0c3da21d67ba7/protobuf-7.34.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:8ff40ce8cd688f7265326b38d5a1bed9bfdf5e6723d49961432f83e21d5713e4", size = 324267, upload-time = "2026-03-20T17:34:41.1Z" },
+    { url = "https://files.pythonhosted.org/packages/85/29/64de04a0ac142fb685fd09999bc3d337943fb386f3a0ec57f92fd8203f97/protobuf-7.34.1-cp310-abi3-win32.whl", hash = "sha256:34b84ce27680df7cca9f231043ada0daa55d0c44a2ddfaa58ec1d0d89d8bf60a", size = 426628, upload-time = "2026-03-20T17:34:42.536Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/87/cb5e585192a22b8bd457df5a2c16a75ea0db9674c3a0a39fc9347d84e075/protobuf-7.34.1-cp310-abi3-win_amd64.whl", hash = "sha256:e97b55646e6ce5cbb0954a8c28cd39a5869b59090dfaa7df4598a7fba869468c", size = 437901, upload-time = "2026-03-20T17:34:44.112Z" },
+    { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/6b/69fd5c7194b21ebde0f8637e2a4ddc766ada29d472bfa6a5ca533d79549a/pydantic-2.13.0.tar.gz", hash = "sha256:b89b575b6e670ebf6e7448c01b41b244f471edd276cd0b6fe02e7e7aca320070", size = 843468, upload-time = "2026-04-13T10:51:35.571Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/d7/c3a52c61f5b7be648e919005820fbac33028c6149994cd64453f49951c17/pydantic-2.13.0-py3-none-any.whl", hash = "sha256:ab0078b90da5f3e2fd2e71e3d9b457ddcb35d0350854fbda93b451e28d56baaf", size = 471872, upload-time = "2026-04-13T10:51:33.343Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/0a/9414cddf82eda3976b14048cc0fa8f5b5d1aecb0b22e1dcd2dbfe0e139b1/pydantic_core-2.46.0.tar.gz", hash = "sha256:82d2498c96be47b47e903e1378d1d0f770097ec56ea953322f39936a7cf34977", size = 471441, upload-time = "2026-04-13T09:06:33.813Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/43/9bc38d43a6a48794209e4eb6d61e9c68395f69b7949f66842854b0cd1344/pydantic_core-2.46.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0027da787ae711f7fbd5a76cb0bb8df526acba6c10c1e44581de1b838db10b7b", size = 2121004, upload-time = "2026-04-13T09:05:17.531Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/1d/f43342b7107939b305b5e4efeef7d54e267a5ef51515570a5c1d77726efb/pydantic_core-2.46.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:63e288fc18d7eaeef5f16c73e65c4fd0ad95b25e7e21d8a5da144977b35eb997", size = 1947505, upload-time = "2026-04-13T09:04:48.975Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/cd/ccf48cbbcaf0d99ba65969459ebfbf7037600b2cfdcca3062084dd83a008/pydantic_core-2.46.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:080a3bdc6807089a1fe1fbc076519cea287f1a964725731d80b49d8ecffaa217", size = 1973301, upload-time = "2026-04-13T09:05:42.149Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/ff/a7bb1e7a762fb1f40ad5ef4e6a92c012864a017b7b1fdfb71cf91faa8b73/pydantic_core-2.46.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c065f1c3e54c3e79d909927a8cb48ccbc17b68733552161eba3e0628c38e5d19", size = 2042208, upload-time = "2026-04-13T09:05:32.591Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/64/d3f11c6f6ace71526f3b03646df95eaab3f21edd13e00daae3f20f4e5a09/pydantic_core-2.46.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7e2db58ab46cfe602d4255381cce515585998c3b6699d5b1f909f519bc44a5aa", size = 2229046, upload-time = "2026-04-13T09:04:18.59Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/64/93db9a63cce71630c58b376d63de498aa93cb341c72cd5f189b5c08f5c28/pydantic_core-2.46.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c660974890ec1e4c65cff93f5670a5f451039f65463e9f9c03ad49746b49fc78", size = 2292138, upload-time = "2026-04-13T09:04:13.816Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/96/936fccce22f1f2ae8b2b694de651c2c929847be5f701c927a0bb3b1eb679/pydantic_core-2.46.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3be91482a8db77377c902cca87697388a4fb68addeb3e943ac74f425201a099", size = 2093333, upload-time = "2026-04-13T09:05:15.729Z" },
+    { url = "https://files.pythonhosted.org/packages/75/76/c325e7fda69d589e26e772272044fe704c7e525c47d0d32a74f8345ac657/pydantic_core-2.46.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:1c72de82115233112d70d07f26a48cf6996eb86f7e143423ec1a182148455a9d", size = 2138802, upload-time = "2026-04-13T09:03:51.142Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6f/ccaa2ff7d53a017b66841e2d38edd1f38d19ae1a2d0c5efee17f2d432229/pydantic_core-2.46.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7904e58768cd79304b992868d7710bfc85dc6c7ed6163f0f68dbc1dcd72dc231", size = 2181358, upload-time = "2026-04-13T09:04:30.737Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/71/0c4b6303e92d63edcb81f5301695cdf70bb351775b4733eea65acdac8384/pydantic_core-2.46.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1af8d88718005f57bb4768f92f4ff16bf31a747d39dfc919b22211b84e72c053", size = 2183985, upload-time = "2026-04-13T09:04:06.792Z" },
+    { url = "https://files.pythonhosted.org/packages/71/eb/f6bf255de38a4393aaa10bff224e882b630576bc26ebfb401e42bb965092/pydantic_core-2.46.0-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:a5b891301b02770a5852253f4b97f8bd192e5710067bc129e20d43db5403ede2", size = 2328559, upload-time = "2026-04-13T09:06:14.143Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/71/93895a1545f50823a24b21d7761c2bd1b1afea7a6ddc019787caec237361/pydantic_core-2.46.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:48b671fe59031fd9754c7384ac05b3ed47a0cccb7d4db0ec56121f0e6a541b90", size = 2367466, upload-time = "2026-04-13T09:05:59.613Z" },
+    { url = "https://files.pythonhosted.org/packages/78/39/62331b3e71f41fb13d486621e2aec49900ba56567fb3a0ae5999fded0005/pydantic_core-2.46.0-cp311-cp311-win32.whl", hash = "sha256:0a52b7262b6cc67033823e9549a41bb77580ac299dc964baae4e9c182b2e335c", size = 1981367, upload-time = "2026-04-13T09:07:37.563Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/51/caac70958420e2d6115962f550676df59647c11f96a44c2fcb61662fcd16/pydantic_core-2.46.0-cp311-cp311-win_amd64.whl", hash = "sha256:4103fea1beeef6b3a9fed8515f27d4fa30c929a1973655adf8f454dc49ee0662", size = 2065942, upload-time = "2026-04-13T09:06:37.873Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/cf/576b2a4eb5500a1a5da485613b1ea8bc0d7279b27e0426801574b284ae65/pydantic_core-2.46.0-cp311-cp311-win_arm64.whl", hash = "sha256:3137cd88938adb8e567c5e938e486adc7e518ffc96b4ae1ec268e6a4275704d7", size = 2052532, upload-time = "2026-04-13T09:06:03.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/f1/6731c2d6caf03efe822101edb4783eb3f212f34b7b005a34f039f67e76e1/pydantic_core-2.46.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:ce2e38e27de73ff6a0312a9e3304c398577c418d90bbde97f0ba1ee3ab7ac39f", size = 2121259, upload-time = "2026-04-13T09:07:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/72/fd/ac34d4c92e739e37a040be9e7ea84d116afec5f983a7db856c27135fba77/pydantic_core-2.46.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:f0d34ba062396de0be7421e6e69c9a6821bf6dc73a0ab9959a48a5a6a1e24754", size = 1945798, upload-time = "2026-04-13T09:04:24.729Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/a4/f413a522c4047c46b109be6805a3095d35e5a4882fd5b4fdc0909693dfc0/pydantic_core-2.46.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4c0a12147b4026dd68789fb9f22f1a8769e457f9562783c181880848bbd6412", size = 1986062, upload-time = "2026-04-13T09:05:57.177Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2e/9760025ea8b0f49903c0ceebdfc2d8ef839da872426f2b03cae9de036a7c/pydantic_core-2.46.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a99896d9db56df901ab4a63cd6a36348a569cff8e05f049db35f4016a817a3d9", size = 2145344, upload-time = "2026-04-13T09:03:56.924Z" },
+    { url = "https://files.pythonhosted.org/packages/09/ed/fbd8127e4a19c4fdbb2f4983cf72c7b3534086df640c813c5c0ec4218177/pydantic_core-2.46.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:be3e04979ba4d68183f247202c7f4f483f35df57690b3f875c06340a1579b47c", size = 2119951, upload-time = "2026-04-13T09:04:35.923Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/77/df8711ebb45910412f90d75198430fa1120f5618336b71fa00303601c5a4/pydantic_core-2.46.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b1eae8d7d9b8c2a90b34d3d9014804dca534f7f40180197062634499412ea14e", size = 1953812, upload-time = "2026-04-13T09:05:40.293Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fe/14b35df69112bd812d6818a395eeab22eeaa2befc6f85bc54ed648430186/pydantic_core-2.46.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a95a2773680dd4b6b999d4eccdd1b577fd71c31739fb4849f6ada47eabb9c56", size = 2139585, upload-time = "2026-04-13T09:06:46.94Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f0/4fea4c14ebbdeb87e5f6edd2620735fcbd384865f06707fe229c021ce041/pydantic_core-2.46.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:25988c3159bb097e06abfdf7b21b1fcaf90f187c74ca6c7bb842c1f72ce74fa8", size = 2179154, upload-time = "2026-04-13T09:04:15.639Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/36/6329aa79ba32b73560e6e453164fb29702b115fd3b2b650e796e1dc27862/pydantic_core-2.46.0-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:747d89bd691854c719a3381ba46b6124ef916ae85364c79e11db9c84995d8d03", size = 2182917, upload-time = "2026-04-13T09:07:24.483Z" },
+    { url = "https://files.pythonhosted.org/packages/92/61/edbf7aea71052d410347846a2ea43394f74651bf6822b8fad8703ca00575/pydantic_core-2.46.0-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:909a7327b83ca93b372f7d48df0ebc7a975a5191eb0b6e024f503f4902c24124", size = 2327716, upload-time = "2026-04-13T09:06:31.681Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/11/aa5089b941e85294b1d5d526840b18f0d4464f842d43d8999ce50ef881c1/pydantic_core-2.46.0-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:2f7e6a3752378a69fadf3f5ee8bc5fa082f623703eec0f4e854b12c548322de0", size = 2365925, upload-time = "2026-04-13T09:05:38.338Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/75/e187b0ea247f71f2009d156df88b7d8449c52a38810c9a1bd55dd4871206/pydantic_core-2.46.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:ef47ee0a3ac4c2bb25a083b3acafb171f65be4a0ac1e84edef79dd0016e25eaa", size = 2193856, upload-time = "2026-04-13T09:05:03.114Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pymdown-extensions"
+version = "10.21.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/08/f1c908c581fd11913da4711ea7ba32c0eee40b0190000996bb863b0c9349/pymdown_extensions-10.21.2.tar.gz", hash = "sha256:c3f55a5b8a1d0edf6699e35dcbea71d978d34ff3fa79f3d807b8a5b3fa90fbdc", size = 853922, upload-time = "2026-03-29T15:01:55.233Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/27/a2fc51a4a122dfd1015e921ae9d22fee3d20b0b8080d9a704578bf9deece/pymdown_extensions-10.21.2-py3-none-any.whl", hash = "sha256:5c0fd2a2bea14eb39af8ff284f1066d898ab2187d81b889b75d46d4348c01638", size = 268901, upload-time = "2026-03-29T15:01:53.244Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.408"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/b2/5db700e52554b8f025faa9c3c624c59f1f6c8841ba81ab97641b54322f16/pyright-1.1.408.tar.gz", hash = "sha256:f28f2321f96852fa50b5829ea492f6adb0e6954568d1caa3f3af3a5f555eb684", size = 4400578, upload-time = "2026-01-08T08:07:38.795Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/82/a2c93e32800940d9573fb28c346772a14778b84ba7524e691b324620ab89/pyright-1.1.408-py3-none-any.whl", hash = "sha256:090b32865f4fdb1e0e6cd82bf5618480d48eecd2eb2e70f960982a3d9a4c17c1", size = 6399144, upload-time = "2026-01-08T08:07:37.082Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-discovery"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/ef/3bae0e537cfe91e8431efcba4434463d2c5a65f5a89edd47c6cf2f03c55f/python_discovery-1.2.2.tar.gz", hash = "sha256:876e9c57139eb757cb5878cbdd9ae5379e5d96266c99ef731119e04fffe533bb", size = 58872, upload-time = "2026-04-07T17:28:49.249Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/db/795879cc3ddfe338599bddea6388cc5100b088db0a4caf6e6c1af1c27e04/python_discovery-1.2.2-py3-none-any.whl", hash = "sha256:e1ae95d9af875e78f15e19aed0c6137ab1bb49c200f21f5061786490c9585c7a", size = 31894, upload-time = "2026-04-07T17:28:48.09Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2026.1.post1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", hash = "sha256:3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1", size = 321088, upload-time = "2026-03-03T07:47:50.683Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a", size = 510489, upload-time = "2026-03-03T07:47:49.167Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+]
+
+[[package]]
+name = "pyyaml-env-tag"
+version = "1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.33.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/d9/aa3f7d59a10ef6b14fe3431706f854dbf03c5976be614a9796d36326810c/ruff-0.15.10.tar.gz", hash = "sha256:d1f86e67ebfdef88e00faefa1552b5e510e1d35f3be7d423dc7e84e63788c94e", size = 4631728, upload-time = "2026-04-09T14:06:09.884Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/00/a1c2fdc9939b2c03691edbda290afcd297f1f389196172826b03d6b6a595/ruff-0.15.10-py3-none-linux_armv6l.whl", hash = "sha256:0744e31482f8f7d0d10a11fcbf897af272fefdfcb10f5af907b18c2813ff4d5f", size = 10563362, upload-time = "2026-04-09T14:06:21.189Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/15/006990029aea0bebe9d33c73c3e28c80c391ebdba408d1b08496f00d422d/ruff-0.15.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b1e7c16ea0ff5a53b7c2df52d947e685973049be1cdfe2b59a9c43601897b22e", size = 10951122, upload-time = "2026-04-09T14:06:02.236Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/c0/4ac978fe874d0618c7da647862afe697b281c2806f13ce904ad652fa87e4/ruff-0.15.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:93cc06a19e5155b4441dd72808fdf84290d84ad8a39ca3b0f994363ade4cebb1", size = 10314005, upload-time = "2026-04-09T14:06:00.026Z" },
+    { url = "https://files.pythonhosted.org/packages/da/73/c209138a5c98c0d321266372fc4e33ad43d506d7e5dd817dd89b60a8548f/ruff-0.15.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83e1dd04312997c99ea6965df66a14fb4f03ba978564574ffc68b0d61fd3989e", size = 10643450, upload-time = "2026-04-09T14:05:42.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/76/0deec355d8ec10709653635b1f90856735302cb8e149acfdf6f82a5feb70/ruff-0.15.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8154d43684e4333360fedd11aaa40b1b08a4e37d8ffa9d95fee6fa5b37b6fab1", size = 10379597, upload-time = "2026-04-09T14:05:49.984Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/be/86bba8fc8798c081e28a4b3bb6d143ccad3fd5f6f024f02002b8f08a9fa3/ruff-0.15.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ab88715f3a6deb6bde6c227f3a123410bec7b855c3ae331b4c006189e895cef", size = 11146645, upload-time = "2026-04-09T14:06:12.246Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/89/140025e65911b281c57be1d385ba1d932c2366ca88ae6663685aed8d4881/ruff-0.15.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a768ff5969b4f44c349d48edf4ab4f91eddb27fd9d77799598e130fb628aa158", size = 12030289, upload-time = "2026-04-09T14:06:04.776Z" },
+    { url = "https://files.pythonhosted.org/packages/88/de/ddacca9545a5e01332567db01d44bd8cf725f2db3b3d61a80550b48308ea/ruff-0.15.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ee3ef42dab7078bda5ff6a1bcba8539e9857deb447132ad5566a038674540d0", size = 11496266, upload-time = "2026-04-09T14:05:55.485Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/bb/7ddb00a83760ff4a83c4e2fc231fd63937cc7317c10c82f583302e0f6586/ruff-0.15.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51cb8cc943e891ba99989dd92d61e29b1d231e14811db9be6440ecf25d5c1609", size = 11256418, upload-time = "2026-04-09T14:05:57.69Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/8d/55de0d35aacf6cd50b6ee91ee0f291672080021896543776f4170fc5c454/ruff-0.15.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:e59c9bdc056a320fb9ea1700a8d591718b8faf78af065484e801258d3a76bc3f", size = 11288416, upload-time = "2026-04-09T14:05:44.695Z" },
+    { url = "https://files.pythonhosted.org/packages/68/cf/9438b1a27426ec46a80e0a718093c7f958ef72f43eb3111862949ead3cc1/ruff-0.15.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:136c00ca2f47b0018b073f28cb5c1506642a830ea941a60354b0e8bc8076b151", size = 10621053, upload-time = "2026-04-09T14:05:52.782Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/50/e29be6e2c135e9cd4cb15fbade49d6a2717e009dff3766dd080fcb82e251/ruff-0.15.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8b80a2f3c9c8a950d6237f2ca12b206bccff626139be9fa005f14feb881a1ae8", size = 10378302, upload-time = "2026-04-09T14:06:14.361Z" },
+    { url = "https://files.pythonhosted.org/packages/18/2f/e0b36a6f99c51bb89f3a30239bc7bf97e87a37ae80aa2d6542d6e5150364/ruff-0.15.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:e3e53c588164dc025b671c9df2462429d60357ea91af7e92e9d56c565a9f1b07", size = 10850074, upload-time = "2026-04-09T14:06:16.581Z" },
+    { url = "https://files.pythonhosted.org/packages/11/08/874da392558ce087a0f9b709dc6ec0d60cbc694c1c772dab8d5f31efe8cb/ruff-0.15.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b0c52744cf9f143a393e284125d2576140b68264a93c6716464e129a3e9adb48", size = 11358051, upload-time = "2026-04-09T14:06:18.948Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/46/602938f030adfa043e67112b73821024dc79f3ab4df5474c25fa4c1d2d14/ruff-0.15.10-py3-none-win32.whl", hash = "sha256:d4272e87e801e9a27a2e8df7b21011c909d9ddd82f4f3281d269b6ba19789ca5", size = 10588964, upload-time = "2026-04-09T14:06:07.14Z" },
+    { url = "https://files.pythonhosted.org/packages/25/b6/261225b875d7a13b33a6d02508c39c28450b2041bb01d0f7f1a83d569512/ruff-0.15.10-py3-none-win_amd64.whl", hash = "sha256:28cb32d53203242d403d819fd6983152489b12e4a3ae44993543d6fe62ab42ed", size = 11745044, upload-time = "2026-04-09T14:05:39.473Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ed/dea90a65b7d9e69888890fb14c90d7f51bf0c1e82ad800aeb0160e4bacfd/ruff-0.15.10-py3-none-win_arm64.whl", hash = "sha256:601d1610a9e1f1c2165a4f561eeaa2e2ea1e97f3287c5aa258d3dab8b57c6188", size = 11035607, upload-time = "2026-04-09T14:05:47.593Z" },
+]
+
+[[package]]
+name = "scikit-base"
+version = "0.13.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/47/7954094adee334012d7182c2f78bb5f134f6ec93e28a0fdc6856de5ed4f6/scikit_base-0.13.2.tar.gz", hash = "sha256:c78245064754781b17062ab183a03bc12b36163b9e5f2cfcb6f29f749be4b266", size = 135452, upload-time = "2026-04-13T21:14:50.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/2e/1488716735c31bf82c6898759d12771b3e0ff5daeb0f01b73b82a4462ad9/scikit_base-0.13.2-py3-none-any.whl", hash = "sha256:0a67063c0323b9521ede91cfcc87ce097126de5f9d5367abed6e76ff97a0eda5", size = 160792, upload-time = "2026-04-13T21:14:48.243Z" },
+]
+
+[[package]]
+name = "scikit-learn"
+version = "1.7.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "joblib" },
+    { name = "numpy" },
+    { name = "scipy" },
+    { name = "threadpoolctl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/83/564e141eef908a5863a54da8ca342a137f45a0bfb71d1d79704c9894c9d1/scikit_learn-1.7.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e", size = 9331967, upload-time = "2025-09-09T08:20:32.421Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d6/ba863a4171ac9d7314c4d3fc251f015704a2caeee41ced89f321c049ed83/scikit_learn-1.7.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1", size = 8648645, upload-time = "2025-09-09T08:20:34.436Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/0e/97dbca66347b8cf0ea8b529e6bb9367e337ba2e8be0ef5c1a545232abfde/scikit_learn-1.7.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d", size = 9715424, upload-time = "2025-09-09T08:20:36.776Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/32/1f3b22e3207e1d2c883a7e09abb956362e7d1bd2f14458c7de258a26ac15/scikit_learn-1.7.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1", size = 9509234, upload-time = "2025-09-09T08:20:38.957Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/71/34ddbd21f1da67c7a768146968b4d0220ee6831e4bcbad3e03dd3eae88b6/scikit_learn-1.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1", size = 8894244, upload-time = "2025-09-09T08:20:41.166Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" },
+    { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" },
+    { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" },
+    { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "82.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sktime"
+version = "0.40.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "joblib" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "scikit-base" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/7a/22b99a00a7cabaa34c350f78f33ae89711cfc08deef06043daee3835dbb3/sktime-0.40.1.tar.gz", hash = "sha256:bbf3c2971c7ad388fbebc1d1fb573e20f730e6486c00935b336d8edf13bca04d", size = 35197759, upload-time = "2025-11-25T00:03:38.744Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/0d/3b2e5b51593009f72fb7fb6956e6c652da1450c8c5484c40a276113c2114/sktime-0.40.1-py3-none-any.whl", hash = "sha256:130bb0c39ca4377e491c4dfa64c8ac67c3de2660dd406dd7690db6a8ac349c4e", size = 36265753, upload-time = "2025-11-25T00:03:34.522Z" },
+]
+
+[[package]]
+name = "tensorflow"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "astunparse" },
+    { name = "flatbuffers" },
+    { name = "gast" },
+    { name = "google-pasta" },
+    { name = "grpcio" },
+    { name = "h5py" },
+    { name = "keras" },
+    { name = "libclang" },
+    { name = "ml-dtypes" },
+    { name = "numpy" },
+    { name = "opt-einsum" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "requests" },
+    { name = "setuptools" },
+    { name = "six" },
+    { name = "termcolor" },
+    { name = "typing-extensions" },
+    { name = "wrapt" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/76/b649b02a243c09f0348199dbd81408c1558cfbec2b6d77d820c428a95254/tensorflow-2.21.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:51f46f4806139d01fc7920cc72a4c75876f80649bf40ff083ab6212ceb43ca88", size = 223405849, upload-time = "2026-03-06T17:23:12.976Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/7c/57b7ee953b40d5d837136d20af6851b20ea6ca63753fc05699e8bcfab6d5/tensorflow-2.21.0-cp311-cp311-manylinux_2_27_aarch64.whl", hash = "sha256:4b24aca16d527a3cf1c37f720c04c484c3d20f4d0fdfa98632ac8b9f3be6eb5c", size = 281828020, upload-time = "2026-03-06T17:23:21.243Z" },
+    { url = "https://files.pythonhosted.org/packages/26/a1/23b9b39c046c723db63a1c2c93397703efa3400a36f98d9c717b473aafb8/tensorflow-2.21.0-cp311-cp311-manylinux_2_27_x86_64.whl", hash = "sha256:9056fbc9ba04235810b71ae6cbd958a196e8804fb53bbcffbf3e23b56155f124", size = 572440367, upload-time = "2026-03-06T17:23:35.279Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a2/6d7e6a738e302530586d484895de2cf3fc158ad9c73b4504a670b2956dd9/tensorflow-2.21.0-cp311-cp311-win_amd64.whl", hash = "sha256:0064a19bdc054a4b7c5e7e21cdf50ce38a114c2bada578b4f5267a37410f6784", size = 350834005, upload-time = "2026-03-06T17:23:53.021Z" },
+]
+
+[[package]]
+name = "tensorflow-hub"
+version = "0.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "protobuf" },
+    { name = "tf-keras" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/50/00dba77925bf2a0a1e45d7bcf8a69a1d2534fb4bb277d9010bd148d2235e/tensorflow_hub-0.16.1-py2.py3-none-any.whl", hash = "sha256:e10c184b3d08daeafada11ffea2dd46781725b6bef01fad1f74d6634ad05311f", size = 30771, upload-time = "2024-01-30T14:49:07.005Z" },
+]
+
+[[package]]
+name = "termcolor"
+version = "3.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/79/cf31d7a93a8fdc6aa0fbb665be84426a8c5a557d9240b6239e9e11e35fc5/termcolor-3.3.0.tar.gz", hash = "sha256:348871ca648ec6a9a983a13ab626c0acce02f515b9e1983332b17af7979521c5", size = 14434, upload-time = "2025-12-29T12:55:21.882Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/d1/8bb87d21e9aeb323cc03034f5eaf2c8f69841e40e4853c2627edf8111ed3/termcolor-3.3.0-py3-none-any.whl", hash = "sha256:cf642efadaf0a8ebbbf4bc7a31cec2f9b5f21a9f726f4ccbb08192c9c26f43a5", size = 7734, upload-time = "2025-12-29T12:55:20.718Z" },
+]
+
+[[package]]
+name = "tf-keras"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tensorflow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/80/b005b59f9ccdbabc1b6cd07ca1126cbd4d902288438f0c00072f91a43c6f/tf_keras-2.21.0.tar.gz", hash = "sha256:f9af0f2546cd5532de0fae7a481f34a1ca2253737d4cd1000f6b713dc733f770", size = 1255377, upload-time = "2026-03-18T22:12:02.103Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/d2/5220e3b93444f1c57c092ab5eb2c30cdc762a6e412234750f2d6a85b3769/tf_keras-2.21.0-py3-none-any.whl", hash = "sha256:f858bf3d97f892304e7fbcf5eb0942ed91674e27204f940a85de8c93cf07fe62", size = 1694939, upload-time = "2026-03-18T22:12:00.662Z" },
+]
+
+[[package]]
+name = "threadpoolctl"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2026.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/f5/cd531b2d15a671a40c0f66cf06bc3570a12cd56eef98960068ebbad1bf5a/tzdata-2026.1.tar.gz", hash = "sha256:67658a1903c75917309e753fdc349ac0efd8c27db7a0cb406a25be4840f87f98", size = 197639, upload-time = "2026-04-03T11:25:22.002Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b0/70/d460bd685a170790ec89317e9bd33047988e4bce507b831f5db771e142de/tzdata-2026.1-py2.py3-none-any.whl", hash = "sha256:4b1d2be7ac37ceafd7327b961aa3a54e467efbdb563a23655fbfe0d39cfc42a9", size = 348952, upload-time = "2026-04-03T11:25:20.313Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "21.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+    { name = "python-discovery" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/2595f5ab32a7c1ebe96ba23b70ed06477e8a6de08925b2c55ce22f2e5be5/virtualenv-21.2.2.tar.gz", hash = "sha256:cf780026a5696c86ef9982be3ca9b623c97ea4eb3d92043504f06729112048ce", size = 5844760, upload-time = "2026-04-13T23:34:04.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/68/f13bb8a2eba772c86fe2a272cafc5b0f3708718d008d035d2018e238d4b9/virtualenv-21.2.2-py3-none-any.whl", hash = "sha256:eab30caa0abcc5bd97d42dd780171f3a39e96881af50875536ef45b640650301", size = 5828328, upload-time = "2026-04-13T23:34:02.288Z" },
+]
+
+[[package]]
+name = "watchdog"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393, upload-time = "2024-11-01T14:06:31.756Z" },
+    { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392, upload-time = "2024-11-01T14:06:32.99Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019, upload-time = "2024-11-01T14:06:34.963Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
+]
+
+[[package]]
+name = "wheel"
+version = "0.46.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/89/24/a2eb353a6edac9a0303977c4cb048134959dd2a51b48a269dfc9dde00c8a/wheel-0.46.3.tar.gz", hash = "sha256:e3e79874b07d776c40bd6033f8ddf76a7dad46a7b8aa1b2787a83083519a1803", size = 60605, upload-time = "2026-01-22T12:39:49.136Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/22/b76d483683216dde3d67cba61fb2444be8d5be289bf628c13fc0fd90e5f9/wheel-0.46.3-py3-none-any.whl", hash = "sha256:4b399d56c9d9338230118d705d9737a2a468ccca63d5e813e2a4fc7815d8bc4d", size = 30557, upload-time = "2026-01-22T12:39:48.099Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/64/925f213fdcbb9baeb1530449ac71a4d57fc361c053d06bf78d0c5c7cd80c/wrapt-2.1.2.tar.gz", hash = "sha256:3996a67eecc2c68fd47b4e3c564405a5777367adfd9b8abb58387b63ee83b21e", size = 81678, upload-time = "2026-03-06T02:53:25.134Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/81/60c4471fce95afa5922ca09b88a25f03c93343f759aae0f31fb4412a85c7/wrapt-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:96159a0ee2b0277d44201c3b5be479a9979cf154e8c82fa5df49586a8e7679bb", size = 60666, upload-time = "2026-03-06T02:52:58.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/be/80e80e39e7cb90b006a0eaf11c73ac3a62bbfb3068469aec15cc0bc795de/wrapt-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:98ba61833a77b747901e9012072f038795de7fc77849f1faa965464f3f87ff2d", size = 61601, upload-time = "2026-03-06T02:53:00.487Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/be/d7c88cd9293c859fc74b232abdc65a229bb953997995d6912fc85af18323/wrapt-2.1.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:767c0dbbe76cae2a60dd2b235ac0c87c9cccf4898aef8062e57bead46b5f6894", size = 114057, upload-time = "2026-03-06T02:52:44.08Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/25/36c04602831a4d685d45a93b3abea61eca7fe35dab6c842d6f5d570ef94a/wrapt-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c691a6bc752c0cc4711cc0c00896fcd0f116abc253609ef64ef930032821842", size = 116099, upload-time = "2026-03-06T02:54:56.74Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/4e/98a6eb417ef551dc277bec1253d5246b25003cf36fdf3913b65cb7657a56/wrapt-2.1.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f3b7d73012ea75aee5844de58c88f44cf62d0d62711e39da5a82824a7c4626a8", size = 112457, upload-time = "2026-03-06T02:53:52.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/a6/a6f7186a5297cad8ec53fd7578533b28f795fdf5372368c74bd7e6e9841c/wrapt-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:577dff354e7acd9d411eaf4bfe76b724c89c89c8fc9b7e127ee28c5f7bcb25b6", size = 115351, upload-time = "2026-03-06T02:53:32.684Z" },
+    { url = "https://files.pythonhosted.org/packages/97/6f/06e66189e721dbebd5cf20e138acc4d1150288ce118462f2fcbff92d38db/wrapt-2.1.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3d7b6fd105f8b24e5bd23ccf41cb1d1099796524bcc6f7fbb8fe576c44befbc9", size = 111748, upload-time = "2026-03-06T02:53:08.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/43/4808b86f499a51370fbdbdfa6cb91e9b9169e762716456471b619fca7a70/wrapt-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:866abdbf4612e0b34764922ef8b1c5668867610a718d3053d59e24a5e5fcfc15", size = 113783, upload-time = "2026-03-06T02:53:02.02Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2c/a3f28b8fa7ac2cefa01cfcaca3471f9b0460608d012b693998cd61ef43df/wrapt-2.1.2-cp311-cp311-win32.whl", hash = "sha256:5a0a0a3a882393095573344075189eb2d566e0fd205a2b6414e9997b1b800a8b", size = 57977, upload-time = "2026-03-06T02:53:27.844Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/c3/2b1c7bd07a27b1db885a2fab469b707bdd35bddf30a113b4917a7e2139d2/wrapt-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:64a07a71d2730ba56f11d1a4b91f7817dc79bc134c11516b75d1921a7c6fcda1", size = 60336, upload-time = "2026-03-06T02:54:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/5c/76ece7b401b088daa6503d6264dd80f9a727df3e6042802de9a223084ea2/wrapt-2.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:b89f095fe98bc12107f82a9f7d570dc83a0870291aeb6b1d7a7d35575f55d98a", size = 58756, upload-time = "2026-03-06T02:53:16.319Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/c7/8528ac2dfa2c1e6708f647df7ae144ead13f0a31146f43c7264b4942bf12/wrapt-2.1.2-py3-none-any.whl", hash = "sha256:b8fd6fa2b2c4e7621808f8c62e8317f4aae56e59721ad933bac5239d913cf0e8", size = 43993, upload-time = "2026-03-06T02:53:12.905Z" },
+]