From 04596df3f8ad3d4f6bc5cda1f1b6f1b6f2866596 Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Mon, 27 Jul 2026 22:41:55 -0700 Subject: [PATCH 1/9] docs: document that Repo2RLEnv datasets run on OpenEnv unchanged MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit OpenEnv's harbor_env serves Harbor task directories directly, so a dataset built for `harbor run` is also a training environment — no export step and no Repo2RLEnv-specific code on either side. Adds docs/reference/OPENENV.md covering the file-by-file mapping, the generate → validate → serve → train recipe (including serving straight from a Hub dataset), how our reward files are read, and which execution mode each pipeline needs. The execution-mode table is the part worth reading: every pipeline puts the repository state inside the image the task carries, so all of them — including `pr_diff` with the default `emit_harbor_env=True` — need harbor_env's Docker backend. Only `pr_diff --pipeline-opt emit_harbor_env=False` is unrunnable, because it emits no environment/ or tests/ at all and is meant to be scored client-side with `repo2rlenv.reward`. Verified against Harbor 0.20: a task with our emitted shape (`version = "1.0"`, [metadata.repo2env], environment/Dockerfile with WORKDIR /workspace, a test.sh writing /logs/verifier/reward.txt) scores 0.0 for a no-op agent and 1.0 for its oracle under both `harbor run` and harbor_env's Docker mode. --- README.md | 4 +- docs/reference/OPENENV.md | 132 +++++++++++++++++++++++++++++++++ docs/reference/RELATED_WORK.md | 2 +- mkdocs.yml | 1 + 4 files changed, 137 insertions(+), 2 deletions(-) create mode 100644 docs/reference/OPENENV.md diff --git a/README.md b/README.md index 9d70eb87..b4b48825 100644 --- a/README.md +++ b/README.md @@ -155,6 +155,7 @@ A dataset that: - **Is verifiable** — every task carries an executable test (`test_execution`) or a stored oracle diff (`diff_similarity`); your trainer picks the reward type. - **Is content-addressed** — a `content_hash` over each task; identical artifacts ⇒ identical hash. - **Trains anywhere via Harbor** — TRL, SkyRL, Prime-RL, Tinker, Miles, Slime, harbor.rl. +- **Runs on OpenEnv unchanged** — [OpenEnv](https://github.com/huggingface/OpenEnv)'s `harbor_env` serves the emitted task dirs as Gymnasium-style environments, forwarding the verifier's reward. No export step. See [OpenEnv compatibility](./docs/reference/OPENENV.md). - **Evaluates with any agent harness** — Claude Code, OpenHands, Codex CLI, Gemini CLI, … - **Is language-agnostic by spec** — runtime pipelines emit a Dockerfile + shell verifier; `pr_diff` is pure text and works for any language. - **Publishes natively** to the Hub — `repo2rlenv push` writes a Harbor-compatible `registry.json` so consumers `harbor download` (or `repo2rlenv pull`) with zero glue. @@ -193,7 +194,8 @@ Fastest jumps: - [**RepoLaunch**](https://github.com/microsoft/RepoLaunch) (Microsoft) — LLM-agent env setup; our `bootstrap` is an independent reimplementation - [**OpenReward**](https://docs.openreward.ai) — ORS protocol + extra trainer integrations above Harbor - [**SWE-Gym**](https://github.com/SWE-Gym/SWE-Gym) — RL-environment framing for SWE-bench-style tasks -- [**verifiers**](https://github.com/willccbb/verifiers) (Prime Intellect), [**OpenEnv**](https://github.com/meta-pytorch/OpenEnv) (Meta + HF) — adjacent standardization efforts +- [**verifiers**](https://github.com/willccbb/verifiers) (Prime Intellect) — adjacent standardization effort +- [**OpenEnv**](https://github.com/huggingface/OpenEnv) (Meta + HF) — Gymnasium-style env standard that **runs our task dirs directly** via its `harbor_env` ([compatibility guide](./docs/reference/OPENENV.md)) Every pipeline that draws from external work carries an Acknowledgment block in its `.py` file. No code is copied — implementations are independent and Apache-2.0 licensed. See [`docs/reference/RELATED_WORK.md`](./docs/reference/RELATED_WORK.md) for the full per-pipeline provenance plus adjacent papers, datasets, and frameworks (incl. recent Microsoft and NVIDIA code-RL work). diff --git a/docs/reference/OPENENV.md b/docs/reference/OPENENV.md new file mode 100644 index 00000000..223c4c5e --- /dev/null +++ b/docs/reference/OPENENV.md @@ -0,0 +1,132 @@ +# Running Repo2RLEnv datasets on OpenEnv + +[OpenEnv](https://github.com/huggingface/OpenEnv) is a Gymnasium-style standard +for containerized agentic environments — `reset()` / `step()` / `state()` over a +WebSocket, deployable as a Docker image or a Hugging Face Space. + +Repo2RLEnv datasets run on it **unchanged**. OpenEnv's `harbor_env` serves Harbor +task directories directly, so a dataset built for `harbor run` is also a training +environment. There is no export step, no second copy of the data, and no +Repo2RLEnv-specific code in OpenEnv. + +## Why there is nothing to convert + +The two projects sit at different layers and agree on the one contract that +matters — **the reward is produced inside the environment and only forwarded**. + +| Layer | Repo2RLEnv | Harbor | OpenEnv | +|---|---|---|---| +| Makes the task | ✅ synthesis pipelines | — | — | +| Defines the task format | emits it | ✅ owns it | consumes it | +| Runs a batch evaluation | — | ✅ `harbor run` | — | +| Serves an episode loop for training | — | — | ✅ `reset` / `step` / `state` | + +What the runtime does with each file is identical on both sides: + +| Task file | Under `harbor run` | Under `harbor_env` | +|---|---|---| +| `instruction.md` | the agent's prompt | the observation returned by `reset()` | +| working directory | what the agent edits | `step(exec / read / write)` | +| `tests/test.sh` | the verifier phase | `step(evaluate)` | +| `/logs/verifier/reward.{json,txt}` | the trial's reward | `observation.reward`, forwarded verbatim | +| `solution/solve.sh` | the oracle agent | `step(solve)` | +| `environment/Dockerfile` | the sandbox image | the sandbox image | + +## Recipe + +```bash +# 1. Synthesize tasks from a repository +repo2rlenv generate \ + --repo pallets/click --pipeline pr_runtime \ + --pipeline-opt limit=10 --llm anthropic/claude-sonnet-4-6 \ + --out ./tasks + +# 2. Confirm every task is solvable by its own oracle before training on it +# (from an OpenEnv checkout) +PYTHONPATH=src:envs uv run python envs/harbor_env/examples/validate_taskset.py \ + --tasks ./tasks --mode docker + +# 3. Serve the task set +HARBOR_TASKS_DIR=./tasks HARBOR_MODE=docker uv run --project envs/harbor_env server +``` + +```python +# 4. Drive it like any OpenEnv environment +import asyncio +from harbor_env import HarborEnv + +async def main(): + env = HarborEnv(base_url="http://localhost:8000") + start = await env.reset(task_id="pallets__click-2951") + print(start.observation.instruction) # instruction.md + + await env.write_file("src/click/core.py", patched) # the agent's edit + result = await env.evaluate() # runs tests/test.sh + + print(result.reward) # the verifier's score + print(result.observation.info["reward_details"]) # F2P/P2P breakdown + await env.close() + +asyncio.run(main()) +``` + +Datasets published with `repo2rlenv push` keep their tasks under `tasks//`; +that layout is discovered automatically, so a Hub dataset can be served directly: + +```bash +HARBOR_TASKS_DIR=hf://datasets// HARBOR_MODE=docker \ + uv run --project envs/harbor_env server +``` + +## Which execution mode a task needs + +`harbor_env` has two backends. **Every Repo2RLEnv task needs the Docker one**, +because every pipeline puts the repository state inside the image the task +carries — that is the whole point of the `environment/Dockerfile` we emit. + +| Pipeline | Emits `environment/Dockerfile` | `harbor_env` mode | +|---|:-:|---| +| `pr_runtime`, `commit_runtime`, `cve_patches` | ✅ | `docker` | +| `code_instruct`, `equivalence_tests` | ✅ | `docker` | +| `pr_diff` (default `emit_harbor_env=True`) | ✅ | `docker` | +| `pr_diff` with `emit_harbor_env=False` | ❌ (no `tests/` either) | not runnable — score the stored diff client-side with `repo2rlenv.reward.calculate_diff_similarity_reward` | + +The local (Docker-free) backend exists for *self-contained* tasks that ship their +starting files in `environment/` instead of an image; it refuses image-backed +tasks with an explicit message rather than grading an empty directory. Hugging +Face Spaces cannot run Docker-in-Docker, so a Space serves only that mode — run +Repo2RLEnv task sets on a Docker-capable host. + +## Rewards + +Our verifiers write the files Harbor specifies, and `harbor_env` reads them in +Harbor's order — `reward.json` first, then `reward.txt`: + +| Pipeline | `reward.txt` | Also written | +|---|---|---| +| `pr_runtime`, `commit_runtime`, `cve_patches` | `f2p_rate × p2p_rate` | `reward-details.json` — `resolved`, F2P/P2P counts, regressions, `parse_status` | +| `pr_diff` | 6-component `diff_similarity` | `reward-details.json` — per-component scores, weights, judge status | + +`harbor_env` surfaces the sidecar as `observation.info["reward_details"]` and any +flat metrics from `reward.json` as `observation.info["reward_metrics"]`, so the +training signal and the diagnostic breakdown both survive the trip. + +A verifier that writes no reward file produces **no reward** on the OpenEnv side +(`reward=None` plus an explicit error), not a `0.0` — the same rule that makes +our `reward.txt` contract trustworthy in the first place. + +See [SPEC](./SPEC.md) and [REWARD_SCHEMA](./REWARD_SCHEMA.md) for the full +emitted contract. + +## Verified + +The task-directory shape we emit — `version = "1.0"`, `[metadata.repo2env]`, +`environment/Dockerfile` with `WORKDIR /workspace`, a `tests/test.sh` writing +`/logs/verifier/reward.txt` — was run through both runtimes and scored the same: + +| Runtime | No-op agent | Oracle (`solution/solve.sh`) | +|---|---|---| +| `harbor run` (Harbor 0.20) | 0.0 | 1.0 | +| OpenEnv `harbor_env`, `docker` mode | 0.0 | 1.0 | + +See also [Related work](./RELATED_WORK.md). diff --git a/docs/reference/RELATED_WORK.md b/docs/reference/RELATED_WORK.md index 2eeb71e2..76474c82 100644 --- a/docs/reference/RELATED_WORK.md +++ b/docs/reference/RELATED_WORK.md @@ -49,7 +49,7 @@ our datasets into a trainer. - **NeMo Gym** (NVIDIA) — [NVIDIA-NeMo/Gym](https://github.com/NVIDIA-NeMo/Gym) (Apache-2.0). 100+ RLVR environments for LLMs incl. Mini-SWE-Agent / OpenHands SWE agents and a Harbor harness; the closest analogue to Repo2RLEnv's goal, sharing the Harbor ecosystem. - **SkyRL** (UC Berkeley NovaSky) — [NovaSky-AI/SkyRL](https://github.com/NovaSky-AI/SkyRL) (Apache-2.0) · *SkyRL-Agent* [arXiv:2511.16108](https://arxiv.org/abs/2511.16108). Full-stack RL training framework targeting long-horizon SWE-bench-style agentic tasks; references Harbor. - **verifiers** (Prime Intellect) — [PrimeIntellect-ai/verifiers](https://github.com/PrimeIntellect-ai/verifiers). Defines "environment = dataset + harness + rubric/reward", the closest competing spec to our task+verifier emission. -- **OpenEnv** (Meta PyTorch + Hugging Face) — [meta-pytorch/OpenEnv](https://github.com/meta-pytorch/OpenEnv). Gymnasium-style `step()/reset()/state()` standard for containerized agentic environments with a shared Hub; adjacent standardization effort to our Harbor emission + HF Hub bridge. +- **OpenEnv** (Meta PyTorch + Hugging Face) — [huggingface/OpenEnv](https://github.com/huggingface/OpenEnv) (pip `openenv`; also mirrored at [meta-pytorch/OpenEnv](https://github.com/meta-pytorch/OpenEnv)). Gymnasium-style `step()/reset()/state()` standard for containerized agentic environments with a shared Hub. **Repo2RLEnv datasets run on it unchanged**: its `harbor_env` serves our Harbor task dirs directly — `instruction.md` becomes the first observation, `tests/test.sh` becomes `step(evaluate)`, and the reward is forwarded from `/logs/verifier/reward.{json,txt}` rather than recomputed. See [OpenEnv compatibility](./OPENENV.md). - **rLLM** (Agentica) — [rllm-org/rllm](https://github.com/rllm-org/rllm). "Run agent → collect traces → reward → update" post-training stack; used to train DeepSWE on R2E-Gym environments. ### Automated environment setup / dockerization (the `bootstrap/` problem) diff --git a/mkdocs.yml b/mkdocs.yml index 75a5de75..58a557b3 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -175,6 +175,7 @@ nav: - Environment variables: reference/ENV.md - Registry auth: reference/REGISTRY_AUTH.md - Related work: reference/RELATED_WORK.md + - OpenEnv compatibility: reference/OPENENV.md - Contributing: - Adding a pipeline: contributing/ADDING_A_PIPELINE.md - Release notes: From 05d8d653c858bfd1743ed922f55b4b07173fb317 Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Tue, 28 Jul 2026 06:07:29 -0700 Subject: [PATCH 2/9] docs: record how the OpenEnv interop claim was verified - Note the exact Harbor version the cross-runtime check ran against (0.20.0). - Spell out what the OpenEnv side actually observed: workdir resolved to /workspace from the image, the scalar read from reward.txt, and reward-details.json arriving intact as observation.info["reward_details"]. - The documented --mode docker invocation needs the docker package, which an OpenEnv repo-root venv does not carry; pass --with docker so the command works as written. --- docs/reference/OPENENV.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/docs/reference/OPENENV.md b/docs/reference/OPENENV.md index 223c4c5e..8f45fa7d 100644 --- a/docs/reference/OPENENV.md +++ b/docs/reference/OPENENV.md @@ -42,8 +42,8 @@ repo2rlenv generate \ --out ./tasks # 2. Confirm every task is solvable by its own oracle before training on it -# (from an OpenEnv checkout) -PYTHONPATH=src:envs uv run python envs/harbor_env/examples/validate_taskset.py \ +# (from an OpenEnv checkout; `--with docker` supplies the Docker SDK) +PYTHONPATH=src:envs uv run --with docker python envs/harbor_env/examples/validate_taskset.py \ --tasks ./tasks --mode docker # 3. Serve the task set @@ -126,7 +126,12 @@ The task-directory shape we emit — `version = "1.0"`, `[metadata.repo2env]`, | Runtime | No-op agent | Oracle (`solution/solve.sh`) | |---|---|---| -| `harbor run` (Harbor 0.20) | 0.0 | 1.0 | +| `harbor run` (Harbor 0.20.0) | 0.0 | 1.0 | | OpenEnv `harbor_env`, `docker` mode | 0.0 | 1.0 | +On the OpenEnv side the working directory resolves to `/workspace` from the +image, the scalar is read from `reward.txt`, and `reward-details.json` arrives +intact as `observation.info["reward_details"]` (F2P/P2P counts, `resolved`, +`parse_status`). + See also [Related work](./RELATED_WORK.md). From b8956937b49b71c2f0b8eb4482f59fb18b7b12a7 Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Tue, 28 Jul 2026 06:36:26 -0700 Subject: [PATCH 3/9] feat(openenv): emit OpenEnv environments as a second target alongside Harbor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Repo2RLEnv could already produce Harbor task directories; it can now produce the environment that serves them. `repo2rlenv export --format openenv ` writes a deployable OpenEnv environment — Dockerfile, openenv.yaml, Hugging Face Space card, server shim — around a dataset, so "turn any repository into an RL environment" ends at a running environment rather than a directory of files. What lands ---------- - `repo2rlenv.openenv`: the runtime. dataset.py reads an emitted task back off disk + discovery reward.py the /logs/verifier reward-file contract sandbox.py Docker sandbox implementing our filesystem contract environment.py Gymnasium reset/step/state over the three above client.py trainer-facing client app.py FastAPI factory - `repo2rlenv.emitter.openenv`: writes the deployable package. - `repo2rlenv export` CLI subcommand. - `openenv` extra (`pip install 'repo2rlenv[openenv]'`). Design notes ------------ The tasks are copied verbatim — this adds a serving layer, it does not convert the data, so the same dataset still runs under `harbor run` and under OpenEnv's own generic `harbor_env`. The emitted package is deliberately thin: `server/app.py` is two lines over `repo2rlenv.openenv.build_app`, so the runtime is versioned and tested in this library rather than generated into someone's output directory. The runtime reads `[metadata.repo2env.reproducibility]`, which a generic Harbor runtime cannot: when `mode = "registry"` the image was actually pushed somewhere pullable, so we pull it instead of rebuilding the Dockerfile. `local_only` and `inline_dockerfile` refs may exist on no machine but the generating one, so those still build. Rewards are forwarded, never recomputed. A verifier that writes no reward file yields `reward=None` and an explicit error rather than a fabricated 0.0, which would be indistinguishable from a genuine failure. `exec`/`read`/`write` are the agent's action space; `evaluate` and `solve` are orchestration-only, and agent paths are confined to the working directory so a policy cannot reach /tests or /solution. `openenv` stays optional: `repo2rlenv.openenv` resolves its serving names lazily (PEP 562), so reading a dataset and running `export` work on a plain `pip install repo2rlenv`. A test asserts `openenv` is absent from `sys.modules` after importing the package and the emitter. Verification ------------ A task built with our own Harbor emitter (`version = "1.0"`, `[metadata.repo2env]`, `WORKDIR /workspace`, `test.sh` writing `/logs/verifier/reward.txt`) scores identically across all three runtimes — 0.0 for a no-op agent, 1.0 for the oracle: harbor run (Harbor 0.20.0) 0.0 / 1.0 repo2rlenv export --format openenv 0.0 / 1.0 OpenEnv harbor_env, docker mode 0.0 / 1.0 The exported environment was also driven end to end over the WebSocket API (reset -> write_file -> evaluate), taking the task from 0.0 to 1.0 through an agent edit rather than the oracle, with reward-details.json arriving intact as observation.info["reward_details"]. Tests: 33 in tests/test_openenv_export.py; full suite 739 passed, 15 skipped. A dedicated CI job installs the extra with `uv run --with` so the runtime invariants actually run instead of skipping, without adding openenv to the lock or to the 3.13/3.14 matrix legs. --- .github/workflows/ci.yml | 23 + README.md | 4 +- docs/reference/OPENENV.md | 157 ++- docs/reference/RELATED_WORK.md | 2 +- pyproject.toml | 10 + src/repo2rlenv/cli.py | 95 ++ src/repo2rlenv/emitter/__init__.py | 15 +- src/repo2rlenv/emitter/openenv.py | 338 ++++++ src/repo2rlenv/openenv/__init__.py | 96 ++ src/repo2rlenv/openenv/app.py | 65 ++ src/repo2rlenv/openenv/client.py | 93 ++ src/repo2rlenv/openenv/dataset.py | 288 +++++ src/repo2rlenv/openenv/environment.py | 309 +++++ src/repo2rlenv/openenv/models.py | 113 ++ src/repo2rlenv/openenv/reward.py | 153 +++ src/repo2rlenv/openenv/sandbox.py | 338 ++++++ tests/test_openenv_export.py | 405 +++++++ uv.lock | 1529 +++++++++++++++++++++++++ 18 files changed, 3992 insertions(+), 41 deletions(-) create mode 100644 src/repo2rlenv/emitter/openenv.py create mode 100644 src/repo2rlenv/openenv/__init__.py create mode 100644 src/repo2rlenv/openenv/app.py create mode 100644 src/repo2rlenv/openenv/client.py create mode 100644 src/repo2rlenv/openenv/dataset.py create mode 100644 src/repo2rlenv/openenv/environment.py create mode 100644 src/repo2rlenv/openenv/models.py create mode 100644 src/repo2rlenv/openenv/reward.py create mode 100644 src/repo2rlenv/openenv/sandbox.py create mode 100644 tests/test_openenv_export.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 59677ac3..8b9d7154 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -69,6 +69,29 @@ jobs: - name: Run pytest run: uv run pytest -q + openenv: + name: OpenEnv runtime tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7.0.0 + + - name: Set up uv + uses: astral-sh/setup-uv@v8.3.0 + with: + enable-cache: true + python-version: "3.12" + + - name: Install project + dev dependencies + run: uv sync --group dev --frozen + + # The `openenv` extra stays out of the lock so the default install and the + # 3.13/3.14 matrix legs stay lean; --with pulls it just for this job, which + # is what makes the runtime invariants (agent path confinement, the + # agent/orchestration split, the client wire contract) actually run in CI + # instead of skipping. + - name: Run OpenEnv export + runtime tests + run: uv run --with openenv --with docker pytest tests/test_openenv_export.py -q + build: name: Build sdist + wheel runs-on: ubuntu-latest diff --git a/README.md b/README.md index b4b48825..42f33a47 100644 --- a/README.md +++ b/README.md @@ -155,7 +155,7 @@ A dataset that: - **Is verifiable** — every task carries an executable test (`test_execution`) or a stored oracle diff (`diff_similarity`); your trainer picks the reward type. - **Is content-addressed** — a `content_hash` over each task; identical artifacts ⇒ identical hash. - **Trains anywhere via Harbor** — TRL, SkyRL, Prime-RL, Tinker, Miles, Slime, harbor.rl. -- **Runs on OpenEnv unchanged** — [OpenEnv](https://github.com/huggingface/OpenEnv)'s `harbor_env` serves the emitted task dirs as Gymnasium-style environments, forwarding the verifier's reward. No export step. See [OpenEnv compatibility](./docs/reference/OPENENV.md). +- **Runs on OpenEnv unchanged** — `repo2rlenv export --format openenv` wraps a dataset in a deployable [OpenEnv](https://github.com/huggingface/OpenEnv) environment (Docker image or HF Space), and OpenEnv's own `harbor_env` serves the task dirs directly. Either way the verifier's reward is forwarded, not recomputed. See [OpenEnv compatibility](./docs/reference/OPENENV.md). - **Evaluates with any agent harness** — Claude Code, OpenHands, Codex CLI, Gemini CLI, … - **Is language-agnostic by spec** — runtime pipelines emit a Dockerfile + shell verifier; `pr_diff` is pure text and works for any language. - **Publishes natively** to the Hub — `repo2rlenv push` writes a Harbor-compatible `registry.json` so consumers `harbor download` (or `repo2rlenv pull`) with zero glue. @@ -195,7 +195,7 @@ Fastest jumps: - [**OpenReward**](https://docs.openreward.ai) — ORS protocol + extra trainer integrations above Harbor - [**SWE-Gym**](https://github.com/SWE-Gym/SWE-Gym) — RL-environment framing for SWE-bench-style tasks - [**verifiers**](https://github.com/willccbb/verifiers) (Prime Intellect) — adjacent standardization effort -- [**OpenEnv**](https://github.com/huggingface/OpenEnv) (Meta + HF) — Gymnasium-style env standard that **runs our task dirs directly** via its `harbor_env` ([compatibility guide](./docs/reference/OPENENV.md)) +- [**OpenEnv**](https://github.com/huggingface/OpenEnv) (Meta + HF) — Gymnasium-style env standard; we **emit it as a second target** (`repo2rlenv export --format openenv`) and its `harbor_env` also **runs our task dirs directly** ([compatibility guide](./docs/reference/OPENENV.md)) Every pipeline that draws from external work carries an Acknowledgment block in its `.py` file. No code is copied — implementations are independent and Apache-2.0 licensed. See [`docs/reference/RELATED_WORK.md`](./docs/reference/RELATED_WORK.md) for the full per-pipeline provenance plus adjacent papers, datasets, and frameworks (incl. recent Microsoft and NVIDIA code-RL work). diff --git a/docs/reference/OPENENV.md b/docs/reference/OPENENV.md index 8f45fa7d..a768d476 100644 --- a/docs/reference/OPENENV.md +++ b/docs/reference/OPENENV.md @@ -4,14 +4,73 @@ for containerized agentic environments — `reset()` / `step()` / `state()` over a WebSocket, deployable as a Docker image or a Hugging Face Space. -Repo2RLEnv datasets run on it **unchanged**. OpenEnv's `harbor_env` serves Harbor -task directories directly, so a dataset built for `harbor run` is also a training -environment. There is no export step, no second copy of the data, and no -Repo2RLEnv-specific code in OpenEnv. +Repo2RLEnv datasets run on it with **no change to the task data**. There are two +ways to get there, and both serve the exact directories `generate` emitted: + +| | What it is | Use it when | +|---|---|---| +| **`repo2rlenv export --format openenv`** | We emit a deployable environment package around your dataset — `Dockerfile`, `openenv.yaml`, Space card, server. Runs on the `repo2rlenv[openenv]` runtime. | You want a standalone image or a Hugging Face Space, with no OpenEnv checkout involved. | +| **OpenEnv's `harbor_env`** | OpenEnv's own generic runtime for Harbor task directories. Point it at your dataset. | You already work inside an OpenEnv checkout, or you mix our tasks with other Harbor producers. | + +Either way the reward comes from your task's own `tests/test.sh` and is only +forwarded. Neither path rewrites, re-authors, or copies the task format. + +## Quick start — export a deployable environment + +```bash +# 1. Synthesize tasks from a repository +repo2rlenv generate --repo pallets/click --pipeline pr_runtime \ + --pipeline-opt limit=10 --llm anthropic/claude-sonnet-4-6 --out ./tasks + +# 2. Wrap them in an OpenEnv environment +pip install 'repo2rlenv[openenv]' +repo2rlenv export --format openenv ./tasks --out ./click-env + +# 3. Run it. Task containers start on the host daemon, so mount the socket. +docker build -t click-env ./click-env +docker run --rm -p 8000:8000 -v /var/run/docker.sock:/var/run/docker.sock click-env +``` + +```python +import asyncio +from repo2rlenv.openenv import Repo2RLEnvClient + +async def main(): + env = Repo2RLEnvClient(base_url="http://localhost:8000") + start = await env.reset(task_id="pallets__click-2951") + print(start.observation.instruction) # instruction.md + + await env.write_file("src/click/core.py", patched) # the agent's edit + result = await env.evaluate() # runs tests/test.sh + + print(result.reward) # the verifier's score + print(result.observation.info["reward_details"]) # F2P/P2P breakdown + await env.close() + +asyncio.run(main()) +``` + +The emitted package is thin — `server/app.py` is two lines over +`repo2rlenv.openenv.build_app`, and `tasks/` holds your task directories byte for +byte. The runtime lives in `repo2rlenv.openenv`, so it is versioned, tested and +upgraded like the rest of the library rather than generated into your output. + +`export` writes `README.md` with Hugging Face Space front-matter (`sdk: docker`), +so the emitted directory can be pushed straight to a Space. + +### Options + +| Flag | Default | Meaning | +|---|---|---| +| `--out` | `-openenv` | Where to write the package | +| `--name` | dataset directory name | Environment name in `openenv.yaml` and the Space card | +| `--requirement` | `repo2rlenv[openenv]>=` | The requirement the image installs — pin a release, a git ref, or a local wheel | +| `--base-image` | `python:3.12-slim` | Base image for the server | +| `--port` | `8000` | Port the server listens on | ## Why there is nothing to convert -The two projects sit at different layers and agree on the one contract that +The projects sit at different layers and agree on the one contract that matters — **the reward is produced inside the environment and only forwarded**. | Layer | Repo2RLEnv | Harbor | OpenEnv | @@ -19,11 +78,11 @@ matters — **the reward is produced inside the environment and only forwarded** | Makes the task | ✅ synthesis pipelines | — | — | | Defines the task format | emits it | ✅ owns it | consumes it | | Runs a batch evaluation | — | ✅ `harbor run` | — | -| Serves an episode loop for training | — | — | ✅ `reset` / `step` / `state` | +| Serves an episode loop for training | ✅ `export --format openenv` | — | ✅ `reset` / `step` / `state` | What the runtime does with each file is identical on both sides: -| Task file | Under `harbor run` | Under `harbor_env` | +| Task file | Under `harbor run` | Under an OpenEnv runtime | |---|---|---| | `instruction.md` | the agent's prompt | the observation returned by `reset()` | | working directory | what the agent edits | `step(exec / read / write)` | @@ -32,26 +91,23 @@ What the runtime does with each file is identical on both sides: | `solution/solve.sh` | the oracle agent | `step(solve)` | | `environment/Dockerfile` | the sandbox image | the sandbox image | -## Recipe +## Serving with OpenEnv's `harbor_env` instead -```bash -# 1. Synthesize tasks from a repository -repo2rlenv generate \ - --repo pallets/click --pipeline pr_runtime \ - --pipeline-opt limit=10 --llm anthropic/claude-sonnet-4-6 \ - --out ./tasks +OpenEnv ships `harbor_env`, a generic runtime for any Harbor task directory. It +needs no export step at all — point it at the dataset: -# 2. Confirm every task is solvable by its own oracle before training on it +```bash +# 1. Confirm every task is solvable by its own oracle before training on it # (from an OpenEnv checkout; `--with docker` supplies the Docker SDK) PYTHONPATH=src:envs uv run --with docker python envs/harbor_env/examples/validate_taskset.py \ --tasks ./tasks --mode docker -# 3. Serve the task set +# 2. Serve the task set HARBOR_TASKS_DIR=./tasks HARBOR_MODE=docker uv run --project envs/harbor_env server ``` ```python -# 4. Drive it like any OpenEnv environment +# 3. Drive it like any OpenEnv environment import asyncio from harbor_env import HarborEnv @@ -78,28 +134,37 @@ HARBOR_TASKS_DIR=hf://datasets// HARBOR_MODE=docker \ uv run --project envs/harbor_env server ``` -## Which execution mode a task needs +## Which tasks can actually run -`harbor_env` has two backends. **Every Repo2RLEnv task needs the Docker one**, -because every pipeline puts the repository state inside the image the task -carries — that is the whole point of the `environment/Dockerfile` we emit. +**Every runtime task needs Docker**, because every pipeline puts the repository +state inside the image the task carries — that is the whole point of the +`environment/Dockerfile` we emit. -| Pipeline | Emits `environment/Dockerfile` | `harbor_env` mode | +| Pipeline | Emits `environment/Dockerfile` | Runnable | |---|:-:|---| -| `pr_runtime`, `commit_runtime`, `cve_patches` | ✅ | `docker` | -| `code_instruct`, `equivalence_tests` | ✅ | `docker` | -| `pr_diff` (default `emit_harbor_env=True`) | ✅ | `docker` | -| `pr_diff` with `emit_harbor_env=False` | ❌ (no `tests/` either) | not runnable — score the stored diff client-side with `repo2rlenv.reward.calculate_diff_similarity_reward` | - -The local (Docker-free) backend exists for *self-contained* tasks that ship their -starting files in `environment/` instead of an image; it refuses image-backed -tasks with an explicit message rather than grading an empty directory. Hugging -Face Spaces cannot run Docker-in-Docker, so a Space serves only that mode — run -Repo2RLEnv task sets on a Docker-capable host. +| `pr_runtime`, `commit_runtime`, `cve_patches` | ✅ | yes, Docker | +| `code_instruct`, `equivalence_tests` | ✅ | yes, Docker | +| `pr_diff` (default `emit_harbor_env=True`) | ✅ | yes, Docker | +| `pr_diff` with `emit_harbor_env=False` | ❌ (no `tests/` either) | no — score the stored diff client-side with `repo2rlenv.reward.calculate_diff_similarity_reward` | + +`repo2rlenv export` reports how many of the bundled tasks are runnable and says +so in the emitted Space card; the runtime refuses a task with no image and no +verifier rather than grading an empty directory. `harbor_env`'s Docker-free +`local` backend is for *self-contained* tasks that ship their starting files in +`environment/`, which is not the shape any of our pipelines emit. + +Because a Hugging Face Space cannot run Docker-in-Docker, a Space built from +`export` serves the API but cannot start task containers — run Repo2RLEnv task +sets on a Docker-capable host, or use a Space only as a front end. + +When a dataset has been published with `repo2rlenv push`, +`[metadata.repo2env.reproducibility]` records `mode = "registry"` and a pullable +`image_ref`. Our runtime pulls that image instead of rebuilding the Dockerfile, +so a pushed dataset starts episodes without a build step. ## Rewards -Our verifiers write the files Harbor specifies, and `harbor_env` reads them in +Our verifiers write the files Harbor specifies, and both runtimes read them in Harbor's order — `reward.json` first, then `reward.txt`: | Pipeline | `reward.txt` | Also written | @@ -107,7 +172,7 @@ Harbor's order — `reward.json` first, then `reward.txt`: | `pr_runtime`, `commit_runtime`, `cve_patches` | `f2p_rate × p2p_rate` | `reward-details.json` — `resolved`, F2P/P2P counts, regressions, `parse_status` | | `pr_diff` | 6-component `diff_similarity` | `reward-details.json` — per-component scores, weights, judge status | -`harbor_env` surfaces the sidecar as `observation.info["reward_details"]` and any +Both runtimes surface the sidecar as `observation.info["reward_details"]` and any flat metrics from `reward.json` as `observation.info["reward_metrics"]`, so the training signal and the diagnostic breakdown both survive the trip. @@ -122,16 +187,36 @@ emitted contract. The task-directory shape we emit — `version = "1.0"`, `[metadata.repo2env]`, `environment/Dockerfile` with `WORKDIR /workspace`, a `tests/test.sh` writing -`/logs/verifier/reward.txt` — was run through both runtimes and scored the same: +`/logs/verifier/reward.txt` — was built with our own emitter and run through all +three runtimes. They agree: | Runtime | No-op agent | Oracle (`solution/solve.sh`) | |---|---|---| | `harbor run` (Harbor 0.20.0) | 0.0 | 1.0 | +| `repo2rlenv export --format openenv` | 0.0 | 1.0 | | OpenEnv `harbor_env`, `docker` mode | 0.0 | 1.0 | On the OpenEnv side the working directory resolves to `/workspace` from the image, the scalar is read from `reward.txt`, and `reward-details.json` arrives intact as `observation.info["reward_details"]` (F2P/P2P counts, `resolved`, -`parse_status`). +`parse_status`). The exported environment was additionally driven end to end +over the WebSocket API — `reset` → `write_file` → `evaluate` — taking the same +task from 0.0 to 1.0 through an agent edit rather than the oracle. + +## Where the code lives + +| Piece | Module | +|---|---| +| Task emission (Harbor format) | `repo2rlenv.emitter.harbor` | +| Environment emission (OpenEnv package) | `repo2rlenv.emitter.openenv` | +| Reading an emitted dataset | `repo2rlenv.openenv.dataset` | +| Reward-file contract | `repo2rlenv.openenv.reward` | +| Docker sandbox | `repo2rlenv.openenv.sandbox` | +| Gymnasium environment | `repo2rlenv.openenv.environment` | +| Trainer-facing client | `repo2rlenv.openenv.Repo2RLEnvClient` | + +Only the serving modules need the extra; `repo2rlenv.openenv.dataset` and +`repo2rlenv.emitter.openenv` work with a plain `pip install repo2rlenv`, so +`export` runs without pulling in the OpenEnv stack. See also [Related work](./RELATED_WORK.md). diff --git a/docs/reference/RELATED_WORK.md b/docs/reference/RELATED_WORK.md index 76474c82..f082ffbc 100644 --- a/docs/reference/RELATED_WORK.md +++ b/docs/reference/RELATED_WORK.md @@ -49,7 +49,7 @@ our datasets into a trainer. - **NeMo Gym** (NVIDIA) — [NVIDIA-NeMo/Gym](https://github.com/NVIDIA-NeMo/Gym) (Apache-2.0). 100+ RLVR environments for LLMs incl. Mini-SWE-Agent / OpenHands SWE agents and a Harbor harness; the closest analogue to Repo2RLEnv's goal, sharing the Harbor ecosystem. - **SkyRL** (UC Berkeley NovaSky) — [NovaSky-AI/SkyRL](https://github.com/NovaSky-AI/SkyRL) (Apache-2.0) · *SkyRL-Agent* [arXiv:2511.16108](https://arxiv.org/abs/2511.16108). Full-stack RL training framework targeting long-horizon SWE-bench-style agentic tasks; references Harbor. - **verifiers** (Prime Intellect) — [PrimeIntellect-ai/verifiers](https://github.com/PrimeIntellect-ai/verifiers). Defines "environment = dataset + harness + rubric/reward", the closest competing spec to our task+verifier emission. -- **OpenEnv** (Meta PyTorch + Hugging Face) — [huggingface/OpenEnv](https://github.com/huggingface/OpenEnv) (pip `openenv`; also mirrored at [meta-pytorch/OpenEnv](https://github.com/meta-pytorch/OpenEnv)). Gymnasium-style `step()/reset()/state()` standard for containerized agentic environments with a shared Hub. **Repo2RLEnv datasets run on it unchanged**: its `harbor_env` serves our Harbor task dirs directly — `instruction.md` becomes the first observation, `tests/test.sh` becomes `step(evaluate)`, and the reward is forwarded from `/logs/verifier/reward.{json,txt}` rather than recomputed. See [OpenEnv compatibility](./OPENENV.md). +- **OpenEnv** (Meta PyTorch + Hugging Face) — [huggingface/OpenEnv](https://github.com/huggingface/OpenEnv) (pip `openenv`; also mirrored at [meta-pytorch/OpenEnv](https://github.com/meta-pytorch/OpenEnv)). Gymnasium-style `step()/reset()/state()` standard for containerized agentic environments with a shared Hub. **We target it as a first-class emission format**: `repo2rlenv export --format openenv` wraps a dataset in a deployable environment (`repo2rlenv.openenv` runtime), and OpenEnv's own `harbor_env` serves our Harbor task dirs directly — `instruction.md` becomes the first observation, `tests/test.sh` becomes `step(evaluate)`, and the reward is forwarded from `/logs/verifier/reward.{json,txt}` rather than recomputed. See [OpenEnv compatibility](./OPENENV.md). - **rLLM** (Agentica) — [rllm-org/rllm](https://github.com/rllm-org/rllm). "Run agent → collect traces → reward → update" post-training stack; used to train DeepSWE on R2E-Gym environments. ### Automated environment setup / dockerization (the `bootstrap/` problem) diff --git a/pyproject.toml b/pyproject.toml index e6f77e91..63824b46 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,6 +39,16 @@ dependencies = [ "tomli-w>=1.2.0", ] +[project.optional-dependencies] +# Serve emitted datasets as OpenEnv environments (`repo2rlenv export --format +# openenv`, `repo2rlenv.openenv`). Kept optional so the default install stays +# lean — reading a dataset needs neither of these. +openenv = [ + "openenv>=0.4.1", + "docker>=7.1.0", + "uvicorn[standard]>=0.30.0", +] + [project.scripts] repo2rlenv = "repo2rlenv.cli:main" diff --git a/src/repo2rlenv/cli.py b/src/repo2rlenv/cli.py index 4c8bc92a..22a3a84f 100644 --- a/src/repo2rlenv/cli.py +++ b/src/repo2rlenv/cli.py @@ -3,6 +3,7 @@ Subcommands: generate Run a synthesis pipeline against a repo (emits to local dir) validate Validate a generated dataset directory (fast structural check) + export Wrap a dataset in a deployable environment package (OpenEnv) bootstrap Build a working Docker image via an LLM agent loop push Push a local dataset directory to HF Hub pull Pull a Repo2RLEnv dataset from HF Hub to a local directory @@ -19,6 +20,7 @@ from typing import Any from repo2rlenv import __version__ +from repo2rlenv.emitter.openenv import DEFAULT_BASE_IMAGE, DEFAULT_PORT from repo2rlenv.ui import console, install_logging logger = logging.getLogger("repo2rlenv") @@ -312,6 +314,59 @@ def cmd_generate(args: argparse.Namespace) -> int: return 0 if result.emitted > 0 else 1 +def cmd_export(args: argparse.Namespace) -> int: + """Wrap an emitted dataset in a deployable environment package.""" + from repo2rlenv.emitter.openenv import EmitError, write_openenv_env + + dataset_dir = Path(args.dataset).expanduser().resolve() + if not dataset_dir.is_dir(): + console.error(f"no such dataset directory: {dataset_dir}") + return 1 + + out_dir = ( + Path(args.out).expanduser().resolve() + if args.out + else dataset_dir.parent / f"{dataset_dir.name}-openenv" + ) + + with console.section(f"Exporting {dataset_dir} as {args.format}"): + try: + package = write_openenv_env( + dataset_dir, + out_dir, + name=args.name, + description=args.description, + requirement=args.requirement, + base_image=args.base_image, + port=args.port, + ) + except EmitError as exc: + console.error(str(exc)) + return 1 + + console.kv( + { + "env_name": package.name, + "out_dir": str(package.path), + "tasks": package.task_count, + "runnable": package.runnable_task_count, + }, + title="OpenEnv environment", + ) + if package.runnable_task_count < package.task_count: + console.warn( + f"{package.task_count - package.runnable_task_count} task(s) carry no image or " + "verifier — text-only tasks are scored against solution/patch.diff, not executed" + ) + console.dim(f" docker build -t {package.name} {package.path}") + console.dim( + f" docker run --rm -p {args.port}:{args.port} " + f"-v /var/run/docker.sock:/var/run/docker.sock {package.name}" + ) + console.success(f"exported {package.task_count} task(s) to {package.path}") + return 0 + + def cmd_validate(args: argparse.Namespace) -> int: import tomllib @@ -914,6 +969,46 @@ def main(argv: list[str] | None = None) -> int: v.add_argument("path", help="dataset or task directory") v.set_defaults(func=cmd_validate) + # export + e = sub.add_parser( + "export", + help="Wrap a generated dataset in a deployable environment package", + description=( + "Emit a runnable environment around an existing dataset. The tasks are copied " + "unchanged — this adds a serving layer, it does not convert the data." + ), + ) + e.add_argument("dataset", help="dataset directory (output of `generate`)") + e.add_argument( + "--format", + choices=["openenv"], + default="openenv", + help="environment format to emit (default: openenv)", + ) + e.add_argument( + "--out", + help="output directory (default: -openenv next to the dataset)", + ) + e.add_argument("--name", help="environment name (default: the dataset directory name)") + e.add_argument("--description", help="one-line description for the manifest and Space card") + e.add_argument( + "--requirement", + help=( + "repo2rlenv requirement the image installs " + "(default: repo2rlenv[openenv]>=). Use this to pin a release, " + "a git ref, or a local wheel." + ), + ) + e.add_argument( + "--base-image", + default=DEFAULT_BASE_IMAGE, + help=f"base image for the server (default: {DEFAULT_BASE_IMAGE})", + ) + e.add_argument( + "--port", type=int, default=DEFAULT_PORT, help=f"server port (default: {DEFAULT_PORT})" + ) + e.set_defaults(func=cmd_export) + # push p = sub.add_parser("push", help="Push a local dataset directory to HF Hub") p.add_argument( diff --git a/src/repo2rlenv/emitter/__init__.py b/src/repo2rlenv/emitter/__init__.py index 666773e1..ce245498 100644 --- a/src/repo2rlenv/emitter/__init__.py +++ b/src/repo2rlenv/emitter/__init__.py @@ -1,5 +1,16 @@ -"""Task emitters — currently only Harbor.""" +"""Task and environment emitters. + +`harbor` writes the task directories; `openenv` wraps a directory of them in a +deployable OpenEnv environment. +""" from repo2rlenv.emitter.harbor import HarborTask, write_harbor_task +from repo2rlenv.emitter.openenv import EmitError, OpenEnvPackage, write_openenv_env -__all__ = ["HarborTask", "write_harbor_task"] +__all__ = [ + "EmitError", + "HarborTask", + "OpenEnvPackage", + "write_harbor_task", + "write_openenv_env", +] diff --git a/src/repo2rlenv/emitter/openenv.py b/src/repo2rlenv/emitter/openenv.py new file mode 100644 index 00000000..d392d472 --- /dev/null +++ b/src/repo2rlenv/emitter/openenv.py @@ -0,0 +1,338 @@ +"""Write a deployable OpenEnv environment around an emitted dataset. + +Where `harbor.py` emits the *tasks*, this emits the *environment that serves +them*: a directory you can `docker build`, `docker run`, or push to a Hugging +Face Space, which then speaks OpenEnv's `reset()` / `step()` / `state` API. + + / + openenv.yaml OpenEnv manifest + Dockerfile builds the server image + README.md Space card (front-matter + usage) + pyproject.toml declares the repo2rlenv[openenv] dependency + server/app.py two lines over repo2rlenv.openenv.build_app + tasks//... the emitted task directories, copied verbatim + +The tasks are copied *unchanged* — this adds a serving layer, it does not +convert the data. The runtime lives in `repo2rlenv.openenv`, so the emitted +package stays thin config rather than generated logic. + +---------------------------------------------------------------------------- +Acknowledgment +---------------------------------------------------------------------------- +The environment layout and manifest schema (`openenv.yaml`, the FastAPI + +WebSocket server contract, the Space packaging) are defined by: + + OpenEnv (Meta PyTorch + Hugging Face) + https://github.com/huggingface/OpenEnv (BSD-3-Clause) + +We target that format directly so our datasets are servable by any +OpenEnv-compatible trainer. No OpenEnv code is copied; the emitted package +depends on the published `openenv` distribution. + +Released under Apache-2.0. +---------------------------------------------------------------------------- +""" + +from __future__ import annotations + +import shutil +from dataclasses import dataclass +from pathlib import Path + +import yaml + +from repo2rlenv import __version__ +from repo2rlenv.openenv.dataset import TaskSet + +#: Port the emitted server listens on. Hugging Face Spaces routes to this. +DEFAULT_PORT = 8000 + +#: Base image for the emitted server. Slim + Docker CLI is all it needs; the +#: task containers run on the host daemon, not inside this image. +DEFAULT_BASE_IMAGE = "python:3.12-slim" + + +class EmitError(ValueError): + """Raised when a dataset cannot be turned into an environment.""" + + +@dataclass(frozen=True) +class OpenEnvPackage: + """What `write_openenv_env` produced. + + Attributes: + path: the emitted environment directory. + name: the environment name written into `openenv.yaml`. + task_count: how many task directories were bundled. + runnable_task_count: how many of those can actually be executed. + """ + + path: Path + name: str + task_count: int + runnable_task_count: int + + +def write_openenv_env( + dataset_dir: str | Path, + dest_dir: str | Path, + *, + name: str | None = None, + description: str | None = None, + requirement: str | None = None, + base_image: str = DEFAULT_BASE_IMAGE, + port: int = DEFAULT_PORT, +) -> OpenEnvPackage: + """Emit an OpenEnv environment serving the tasks in `dataset_dir`. + + Args: + dataset_dir: a directory of emitted tasks (the output of `generate`). + dest_dir: where to write the environment package. + name: environment name; defaults to the dataset directory name. + description: one-line description for the manifest and Space card. + requirement: the repo2rlenv requirement the image installs. Defaults to + `repo2rlenv[openenv]>=`; override to pin a + release, a git ref, or a local wheel. + base_image: base image for the server. + port: port the server listens on. + + Returns: + OpenEnvPackage describing what was written. + + Raises: + EmitError: if `dataset_dir` holds no tasks. + """ + source = Path(dataset_dir).expanduser().resolve() + dest = Path(dest_dir).expanduser().resolve() + + task_set = TaskSet(source) + task_ids = task_set.task_ids() + if not task_ids: + raise EmitError(f"no task.toml files found under {source}; is this a generated dataset?") + + tasks = [task_set.get(tid) for tid in task_ids] + runnable = [t for t in tasks if t.runnable] + env_name = _slug(name or source.name) + summary = description or _describe(tasks) + requirement = requirement or f"repo2rlenv[openenv]>={__version__}" + + dest.mkdir(parents=True, exist_ok=True) + (dest / "server").mkdir(exist_ok=True) + + _copy_tasks(tasks, dest / "tasks") + (dest / "openenv.yaml").write_text(_manifest(env_name, summary, port), encoding="utf-8") + (dest / "Dockerfile").write_text( + _dockerfile(env_name, base_image, requirement, port), encoding="utf-8" + ) + (dest / "pyproject.toml").write_text( + _pyproject(env_name, summary, requirement), encoding="utf-8" + ) + (dest / "README.md").write_text( + _readme(env_name, summary, tasks, runnable, port), encoding="utf-8" + ) + (dest / "server" / "__init__.py").write_text( + '"""Server package for the emitted OpenEnv environment."""\n', encoding="utf-8" + ) + (dest / "server" / "app.py").write_text(_app_module(), encoding="utf-8") + (dest / ".dockerignore").write_text("__pycache__/\n*.pyc\n.venv/\n", encoding="utf-8") + + return OpenEnvPackage( + path=dest, + name=env_name, + task_count=len(tasks), + runnable_task_count=len(runnable), + ) + + +def _copy_tasks(tasks, tasks_root: Path) -> None: + """Copy each task directory under `tasks//`, replacing any old copy.""" + if tasks_root.exists(): + shutil.rmtree(tasks_root) + tasks_root.mkdir(parents=True) + for task in tasks: + shutil.copytree(task.path, tasks_root / task.task_id, dirs_exist_ok=True) + + +def _manifest(name: str, description: str, port: int) -> str: + """The `openenv.yaml` manifest OpenEnv tooling reads.""" + payload = { + "spec_version": 1, + "name": name, + "version": "0.1.0", + "description": description, + "type": "space", + "runtime": "fastapi", + "app": "server.app:app", + "port": port, + "action": "Repo2RLEnvAction", + "observation": "Repo2RLEnvObservation", + } + return yaml.safe_dump(payload, sort_keys=False) + + +def _app_module() -> str: + return '''"""FastAPI entry point for this environment. + +The runtime lives in `repo2rlenv.openenv`; this module only names it so the +image has a stable import path (`server.app:app`). +""" + +from repo2rlenv.openenv import build_app + +app = build_app() +''' + + +def _dockerfile(name: str, base_image: str, requirement: str, port: int) -> str: + return f"""# Serves this dataset over OpenEnv's WebSocket API. +# +# Task containers run on the HOST Docker daemon, so the socket must be mounted: +# +# docker build -t {name} . +# docker run --rm -p {port}:{port} -v /var/run/docker.sock:/var/run/docker.sock {name} +# +FROM {base_image} + +# git backs `git apply` in the oracle path; the docker CLI is handy for +# debugging the task containers this server starts. +RUN apt-get update \\ + && apt-get install -y --no-install-recommends ca-certificates curl git \\ + && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +RUN pip install --no-cache-dir "{requirement}" "uvicorn[standard]" + +COPY server/ /app/server/ +COPY tasks/ /app/tasks/ + +ENV REPO2RLENV_TASKS_DIR=/app/tasks +ENV PYTHONUNBUFFERED=1 + +EXPOSE {port} +HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \\ + CMD curl -f http://localhost:{port}/health || exit 1 + +CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "{port}"] +""" + + +def _pyproject(name: str, description: str, requirement: str) -> str: + return f"""[build-system] +requires = ["setuptools>=61", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "{name}" +version = "0.1.0" +description = "{description}" +requires-python = ">=3.10" +dependencies = [ + "{requirement}", + "uvicorn[standard]>=0.30.0", +] + +[tool.setuptools] +packages = ["server"] +""" + + +def _readme(name: str, description: str, tasks, runnable, port: int) -> str: + """Hugging Face Space card: YAML front-matter plus usage.""" + pipelines = sorted({t.pipeline for t in tasks if t.pipeline}) + unrunnable = len(tasks) - len(runnable) + lines = [ + "---", + f"title: {name}", + 'emoji: "🧪"', + "colorFrom: indigo", + "colorTo: purple", + "sdk: docker", + f"app_port: {port}", + "pinned: false", + "tags:", + " - openenv", + " - repo2rlenv", + " - rl", + "---", + "", + f"# {name}", + "", + description, + "", + "Generated by [Repo2RLEnv](https://github.com/huggingface/Repo2RLEnv) with", + "`repo2rlenv export --format openenv`. The tasks under `tasks/` are the", + "unmodified [Harbor](https://www.harborframework.com/docs/tasks) task", + "directories `repo2rlenv generate` emitted, so the same dataset also runs", + "under `harbor run`.", + "", + "## Contents", + "", + f"- **{len(tasks)}** task(s)" + (f", **{len(runnable)}** runnable" if unrunnable else ""), + ] + if pipelines: + lines.append(f"- Pipeline(s): {', '.join(pipelines)}") + if unrunnable: + lines.append( + f"- {unrunnable} text-only task(s) carry no image or verifier and are scored " + "against `solution/patch.diff` client-side rather than executed." + ) + lines += [ + "", + "## Run it", + "", + "```bash", + f"docker build -t {name} .", + "# task containers run on the host daemon, so mount the socket", + f"docker run --rm -p {port}:{port} \\", + " -v /var/run/docker.sock:/var/run/docker.sock \\", + f" {name}", + "```", + "", + "```python", + "import asyncio", + "from repo2rlenv.openenv import Repo2RLEnvClient", + "", + "async def main():", + f' env = Repo2RLEnvClient(base_url="http://localhost:{port}")', + f' start = await env.reset(task_id="{tasks[0].task_id}")', + " print(start.observation.instruction)", + "", + ' await env.run("pytest -q") # the agent works', + " result = await env.evaluate() # the task's own verifier grades it", + " print(result.reward)", + " await env.close()", + "", + "asyncio.run(main())", + "```", + "", + "## Rewards", + "", + "The reward is produced by each task's own `tests/test.sh` and only", + "forwarded — never recomputed here. A verifier that writes no reward file", + "yields `reward=None` and an explicit error rather than a fabricated `0.0`.", + "The diagnostic breakdown (F2P/P2P counts, `resolved`, `parse_status`)", + 'arrives as `observation.info["reward_details"]`.', + "", + "## Configuration", + "", + "| Variable | Default | Meaning |", + "|---|---|---|", + "| `REPO2RLENV_TASKS_DIR` | `/app/tasks` | Where the tasks live |", + "| `REPO2RLENV_DEFAULT_TASK_ID` | — | Task used when `reset()` names none |", + "| `REPO2RLENV_COMMAND_TIMEOUT_S` | `120` | Timeout for agent `exec` actions |", + "| `MAX_CONCURRENT_ENVS` | `8` | Concurrent WebSocket sessions |", + "", + ] + return "\n".join(lines) + + +def _describe(tasks) -> str: + pipelines = sorted({t.pipeline for t in tasks if t.pipeline}) + suffix = f" ({', '.join(pipelines)})" if pipelines else "" + return f"{len(tasks)} verifiable Repo2RLEnv task(s) served as an OpenEnv environment{suffix}" + + +def _slug(value: str) -> str: + cleaned = "".join(ch if (ch.isalnum() or ch in "-_") else "-" for ch in value.lower()) + return cleaned.strip("-") or "repo2rlenv-env" diff --git a/src/repo2rlenv/openenv/__init__.py b/src/repo2rlenv/openenv/__init__.py new file mode 100644 index 00000000..b116dc75 --- /dev/null +++ b/src/repo2rlenv/openenv/__init__.py @@ -0,0 +1,96 @@ +"""Serve Repo2RLEnv datasets as OpenEnv environments. + +[OpenEnv](https://github.com/huggingface/OpenEnv) is a Gymnasium-style standard +for containerized agentic environments — `reset()` / `step()` / `state` over a +WebSocket, deployable as a Docker image or a Hugging Face Space. + +This subpackage is the second serving target alongside Harbor: the tasks are the +same directories `repo2rlenv generate` already writes, and this runtime serves +them as an episode loop a trainer can drive. + + repo2rlenv generate --repo pallets/click --pipeline pr_runtime --out ./tasks + repo2rlenv export --format openenv ./tasks --out ./click-env + docker build -t click-env ./click-env + docker run --rm -p 8000:8000 -v /var/run/docker.sock:/var/run/docker.sock click-env + +The serving pieces need the optional extra: + + pip install 'repo2rlenv[openenv]' + +Because a task's starting state lives inside the image it carries, the runtime +is Docker-backed. When a dataset has been published with `repo2rlenv push`, +`[metadata.repo2env.reproducibility]` names an already-pushed image and the +runtime pulls it instead of rebuilding. + +Serving names resolve lazily, so reading a dataset (`TaskSet`, +`Repo2RLEnvTask`) works with a plain `pip install repo2rlenv`; only the names +that actually serve traffic pull in `openenv`. +""" + +from __future__ import annotations + +from typing import Any + +from repo2rlenv.openenv.dataset import Repo2RLEnvTask, TaskFormatError, TaskSet +from repo2rlenv.openenv.reward import RewardReport, read_reward + +#: Attribute name -> submodule providing it. Everything listed here imports +#: `openenv`, so it is resolved on first access rather than at import time. +_LAZY: dict[str, str] = { + "AGENT_ACTIONS": "models", + "CONTROL_ACTIONS": "models", + "DockerSandbox": "sandbox", + "Repo2RLEnvAction": "models", + "Repo2RLEnvClient": "client", + "Repo2RLEnvEnvironment": "environment", + "Repo2RLEnvObservation": "models", + "Repo2RLEnvState": "models", + "SandboxError": "sandbox", + "build_app": "app", +} + +__all__ = [ + "AGENT_ACTIONS", + "CONTROL_ACTIONS", + "DockerSandbox", + "Repo2RLEnvAction", + "Repo2RLEnvClient", + "Repo2RLEnvEnvironment", + "Repo2RLEnvObservation", + "Repo2RLEnvState", + "Repo2RLEnvTask", + "RewardReport", + "SandboxError", + "TaskFormatError", + "TaskSet", + "build_app", + "read_reward", +] + + +def __getattr__(name: str) -> Any: + """Import the serving names on demand (PEP 562). + + Keeps `repo2rlenv.openenv.dataset` usable without the `openenv` extra + installed, while `from repo2rlenv.openenv import Repo2RLEnvClient` still + works for anyone who has it. + """ + module_name = _LAZY.get(name) + if module_name is None: + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") + + from importlib import import_module + + try: + module = import_module(f"{__name__}.{module_name}") + except ImportError as exc: # pragma: no cover - depends on install extras + raise ImportError( + f"{name} needs the OpenEnv runtime: pip install 'repo2rlenv[openenv]' ({exc})" + ) from exc + value = getattr(module, name) + globals()[name] = value # cache so __getattr__ runs once per name + return value + + +def __dir__() -> list[str]: + return sorted(__all__) diff --git a/src/repo2rlenv/openenv/app.py b/src/repo2rlenv/openenv/app.py new file mode 100644 index 00000000..1b49d3fa --- /dev/null +++ b/src/repo2rlenv/openenv/app.py @@ -0,0 +1,65 @@ +"""FastAPI application factory for a Repo2RLEnv OpenEnv environment. + +An emitted environment package's `server/app.py` is a two-liner over this: + + from repo2rlenv.openenv import build_app + app = build_app() + +Configuration is entirely by environment variable, so the same image serves any +dataset: + + REPO2RLENV_TASKS_DIR directory of emitted tasks (default: ./tasks) + REPO2RLENV_DEFAULT_TASK_ID task used when reset() names none + REPO2RLENV_COMMAND_TIMEOUT_S timeout for agent exec actions (default: 120) + MAX_CONCURRENT_ENVS concurrent WebSocket sessions (default: 8) +""" + +from __future__ import annotations + +import os +from typing import Any + +from openenv.core.env_server.http_server import create_app + +from repo2rlenv.openenv.environment import DEFAULT_COMMAND_TIMEOUT_S, Repo2RLEnvEnvironment +from repo2rlenv.openenv.models import Repo2RLEnvAction, Repo2RLEnvObservation + + +def build_app(**kwargs: Any): + """Build the FastAPI app serving the configured dataset. + + Args: + **kwargs: forwarded to `openenv.core.env_server.http_server.create_app`. + + Returns: + The FastAPI application. + """ + + def _factory() -> Repo2RLEnvEnvironment: + """Called once per session by the server.""" + return Repo2RLEnvEnvironment( + command_timeout_s=float( + os.getenv("REPO2RLENV_COMMAND_TIMEOUT_S", DEFAULT_COMMAND_TIMEOUT_S) + ), + ) + + kwargs.setdefault("env_name", "repo2rlenv") + kwargs.setdefault("max_concurrent_envs", int(os.getenv("MAX_CONCURRENT_ENVS", "8"))) + return create_app(_factory, Repo2RLEnvAction, Repo2RLEnvObservation, **kwargs) + + +def main(host: str = "0.0.0.0", port: int = 8000) -> None: + """Run the server directly: `python -m repo2rlenv.openenv.app`.""" + import uvicorn + + uvicorn.run(build_app(), host=host, port=port) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Serve a Repo2RLEnv dataset over OpenEnv") + parser.add_argument("--host", default="0.0.0.0") + parser.add_argument("--port", type=int, default=8000) + args = parser.parse_args() + main(host=args.host, port=args.port) diff --git a/src/repo2rlenv/openenv/client.py b/src/repo2rlenv/openenv/client.py new file mode 100644 index 00000000..999eb6be --- /dev/null +++ b/src/repo2rlenv/openenv/client.py @@ -0,0 +1,93 @@ +"""Client for a Repo2RLEnv OpenEnv environment. + +This is what a trainer imports. It never imports anything from the server side. +""" + +from __future__ import annotations + +from typing import Any + +from openenv.core.client_types import StepResult +from openenv.core.env_client import EnvClient + +from repo2rlenv.openenv.models import ( + Repo2RLEnvAction, + Repo2RLEnvObservation, + Repo2RLEnvState, +) + + +class Repo2RLEnvClient(EnvClient[Repo2RLEnvAction, Repo2RLEnvObservation, Repo2RLEnvState]): + """Drives a Repo2RLEnv task server over OpenEnv's WebSocket API. + + `run` / `read_file` / `write_file` are what an agent does; `evaluate` grades + the episode and ends it, and `solve` applies the task's oracle patch. + + Example: + + import asyncio + from repo2rlenv.openenv import Repo2RLEnvClient + + async def main(): + env = Repo2RLEnvClient(base_url="http://localhost:8000") + start = await env.reset(task_id="pallets__click-2951") + print(start.observation.instruction) + + await env.write_file("src/click/core.py", patched) + result = await env.evaluate() + print(result.reward, result.observation.info["reward_details"]) + await env.close() + + asyncio.run(main()) + """ + + async def run( + self, command: str, timeout_s: float | None = None + ) -> StepResult[Repo2RLEnvObservation]: + """Run a shell command in the task's working directory.""" + return await self.step( + Repo2RLEnvAction(action_type="exec", command=command, timeout_s=timeout_s) + ) + + async def read_file(self, path: str) -> StepResult[Repo2RLEnvObservation]: + """Read a file, relative to the task's working directory.""" + return await self.step(Repo2RLEnvAction(action_type="read", path=path)) + + async def write_file(self, path: str, content: str) -> StepResult[Repo2RLEnvObservation]: + """Write a file, relative to the task's working directory.""" + return await self.step(Repo2RLEnvAction(action_type="write", path=path, content=content)) + + async def evaluate(self) -> StepResult[Repo2RLEnvObservation]: + """Run the task's verifier and end the episode. + + The reward is whatever `tests/test.sh` wrote; the per-metric breakdown + is in `observation.info`. + """ + return await self.step(Repo2RLEnvAction(action_type="evaluate")) + + async def solve(self) -> StepResult[Repo2RLEnvObservation]: + """Apply the task's oracle patch. + + Orchestration tooling for validating a dataset, not part of an agent's + action space. Follow with `evaluate` to confirm full reward. + """ + return await self.step(Repo2RLEnvAction(action_type="solve")) + + # --- wire protocol ------------------------------------------------------ + + def _step_payload(self, action: Repo2RLEnvAction) -> dict[str, Any]: + return action.model_dump() + + def _parse_result(self, payload: dict[str, Any]) -> StepResult[Repo2RLEnvObservation]: + data = dict(payload.get("observation", {})) + data["reward"] = payload.get("reward") + data["done"] = payload.get("done", False) + observation = Repo2RLEnvObservation.model_validate(data) + return StepResult( + observation=observation, + reward=observation.reward, + done=observation.done, + ) + + def _parse_state(self, payload: dict[str, Any]) -> Repo2RLEnvState: + return Repo2RLEnvState.model_validate(payload) diff --git a/src/repo2rlenv/openenv/dataset.py b/src/repo2rlenv/openenv/dataset.py new file mode 100644 index 00000000..f28b690f --- /dev/null +++ b/src/repo2rlenv/openenv/dataset.py @@ -0,0 +1,288 @@ +"""Read an emitted Repo2RLEnv dataset back off disk. + +`repo2rlenv generate` writes Harbor task directories; this module turns one of +those directories back into a value object the OpenEnv runtime can serve, and +discovers many of them under a dataset root. + +Nothing here executes anything — see `sandbox.py` for that. + +A Repo2RLEnv task is a Harbor task plus the `[metadata.repo2env]` table, which +is what lets us do better than a generic Harbor runtime: when a dataset has been +pushed with `repo2rlenv push`, `[metadata.repo2env.reproducibility]` names a +pullable image and we skip the build entirely. +""" + +from __future__ import annotations + +import tomllib +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +TASK_CONFIG_FILE = "task.toml" +INSTRUCTION_FILE = "instruction.md" + +DEFAULT_AGENT_TIMEOUT_S = 1800.0 +DEFAULT_VERIFIER_TIMEOUT_S = 300.0 + +#: How deep `TaskSet` descends looking for task directories. Enough for a flat +#: `generate --out` directory, the `tasks//` layout `push` stages to the +#: Hub, and one level of grouping above either. +_MAX_DISCOVERY_DEPTH = 4 + +#: `[metadata.repo2env.reproducibility].mode` values written by `push`. +#: Only `registry` guarantees `image_ref` is pullable. +REPRO_MODE_REGISTRY = "registry" + + +class TaskFormatError(ValueError): + """Raised when a directory is not a well-formed Repo2RLEnv task.""" + + +@dataclass(frozen=True) +class Repo2RLEnvTask: + """One emitted task directory, parsed. + + Attributes: + task_id: Directory path relative to the dataset root; what `reset()` selects on. + path: Absolute path to the task directory. + name: `[task].name`, the qualified `/` form. + description: `[task].description`. + instruction: `instruction.md` — the prompt handed to the agent. + schema_version: Top-level `version` (Harbor spells this `schema_version`). + pipeline: Which synthesis pipeline produced the task. + reward_kinds: Reward kinds the pipeline declared it emits. + content_hash: Content address of the task, for provenance. + repro_mode: `reproducibility.mode` — registry / inline_dockerfile / local_only. + image_ref: Image named by `reproducibility.image_ref`, if any. + metadata: The full `[metadata.repo2env]` table, verbatim. + agent_timeout_s: `[agent].timeout_sec`. + verifier_timeout_s: `[verifier].timeout_sec`. + """ + + task_id: str + path: Path + name: str + description: str + instruction: str + schema_version: str + pipeline: str = "" + reward_kinds: tuple[str, ...] = () + content_hash: str = "" + repro_mode: str = "" + image_ref: str | None = None + metadata: dict[str, Any] = field(default_factory=dict) + agent_timeout_s: float = DEFAULT_AGENT_TIMEOUT_S + verifier_timeout_s: float = DEFAULT_VERIFIER_TIMEOUT_S + + # --- layout ------------------------------------------------------------- + + @property + def environment_dir(self) -> Path: + return self.path / "environment" + + @property + def tests_dir(self) -> Path: + return self.path / "tests" + + @property + def solution_dir(self) -> Path: + return self.path / "solution" + + @property + def dockerfile(self) -> Path | None: + """`environment/Dockerfile`, or None for a text-only (lite) task.""" + candidate = self.environment_dir / "Dockerfile" + return candidate if candidate.is_file() else None + + @property + def test_script(self) -> Path | None: + """`tests/test.sh` — the verifier, absent on lite tasks.""" + candidate = self.tests_dir / "test.sh" + return candidate if candidate.is_file() else None + + @property + def solve_script(self) -> Path | None: + """`solution/solve.sh` — the oracle shim that applies patch.diff.""" + candidate = self.solution_dir / "solve.sh" + return candidate if candidate.is_file() else None + + @property + def oracle_diff(self) -> Path | None: + """`solution/patch.diff` — the canonical oracle artifact.""" + candidate = self.solution_dir / "patch.diff" + return candidate if candidate.is_file() else None + + @property + def pullable_image(self) -> str | None: + """The image to pull instead of building, when one is guaranteed to exist. + + Only `mode = "registry"` means `repo2rlenv push` actually pushed the + image somewhere pullable. `local_only` and `inline_dockerfile` both + carry an `image_ref` that may exist on no machine but the one that + generated the task, so those build from `environment/Dockerfile`. + """ + if self.repro_mode == REPRO_MODE_REGISTRY and self.image_ref: + return self.image_ref + return None + + @property + def runnable(self) -> bool: + """Whether the task can be executed and graded. + + `pr_diff` with `emit_harbor_env=False` emits neither a Dockerfile nor a + verifier: it is a stored-diff task, scored client-side against + `solution/patch.diff` rather than by running anything. + """ + return self.dockerfile is not None or self.pullable_image is not None + + def summary(self) -> dict[str, Any]: + """A JSON-serializable digest, surfaced in observations and state.""" + return { + "task_id": self.task_id, + "name": self.name, + "description": self.description, + "pipeline": self.pipeline, + "reward_kinds": list(self.reward_kinds), + "content_hash": self.content_hash, + "repro_mode": self.repro_mode, + "image_ref": self.image_ref, + "runnable": self.runnable, + "has_verifier": self.test_script is not None, + "has_oracle": self.solve_script is not None, + } + + # --- loading ------------------------------------------------------------ + + @classmethod + def load(cls, path: str | Path, task_id: str | None = None) -> Repo2RLEnvTask: + """Parse the task directory at `path`. + + Raises: + TaskFormatError: if `task.toml` is missing or unparsable. + """ + task_dir = Path(path).expanduser().resolve() + config_path = task_dir / TASK_CONFIG_FILE + if not config_path.is_file(): + raise TaskFormatError(f"{task_dir} is not a task directory: no {TASK_CONFIG_FILE}") + + try: + config = tomllib.loads(config_path.read_text(encoding="utf-8")) + except Exception as exc: + raise TaskFormatError(f"could not parse {config_path}: {exc}") from exc + + task_table = _table(config, "task") + metadata = _table(config, "metadata") + repo2env = _table(metadata, "repo2env") + repro = _table(repo2env, "reproducibility") + + instruction_path = task_dir / INSTRUCTION_FILE + instruction = ( + instruction_path.read_text(encoding="utf-8") + if instruction_path.is_file() + else str(task_table.get("description", "")) + ) + + reward_kinds = repo2env.get("reward_kinds") + return cls( + task_id=task_id or task_dir.name, + path=task_dir, + name=str(task_table.get("name", task_dir.name)), + description=str(task_table.get("description", "")), + instruction=instruction, + # We write `version`; Harbor's own tasks spell it `schema_version`. + schema_version=str(config.get("version") or config.get("schema_version") or "unknown"), + pipeline=str(repo2env.get("pipeline", "")), + reward_kinds=tuple(str(k) for k in reward_kinds) + if isinstance(reward_kinds, list) + else (), + content_hash=str(repo2env.get("content_hash", "")), + repro_mode=str(repro.get("mode", "")), + image_ref=(str(repro["image_ref"]) if repro.get("image_ref") else None), + metadata=repo2env, + agent_timeout_s=_timeout(config, "agent", DEFAULT_AGENT_TIMEOUT_S), + verifier_timeout_s=_timeout(config, "verifier", DEFAULT_VERIFIER_TIMEOUT_S), + ) + + +class TaskSet: + """Discovers Repo2RLEnv tasks under a dataset root. + + Any directory holding a `task.toml` is a task, and discovery does not + descend into one once found. That covers the flat layout `generate --out` + writes, the `tasks//` layout `push` stages, and a single task directory + passed directly. + """ + + def __init__(self, root: str | Path) -> None: + self.root = Path(root).expanduser().resolve() + self._discovered: dict[str, Path] | None = None + + def task_ids(self) -> list[str]: + """Sorted identifiers of every task under the root.""" + return sorted(self._task_dirs()) + + def refresh(self) -> None: + """Forget the cached scan so the next lookup re-reads the filesystem.""" + self._discovered = None + + def get(self, task_id: str) -> Repo2RLEnvTask: + """Load one task by identifier, or by bare directory name when unique. + + Raises: + KeyError: if nothing matches, or a bare name is ambiguous. + """ + available = self._task_dirs() + if task_id in available: + return Repo2RLEnvTask.load(available[task_id], task_id=task_id) + + matches = [tid for tid in available if Path(tid).name == task_id] + if len(matches) == 1: + return Repo2RLEnvTask.load(available[matches[0]], task_id=matches[0]) + if len(matches) > 1: + raise KeyError( + f"task id {task_id!r} is ambiguous under {self.root}; use one of {sorted(matches)}" + ) + raise KeyError( + f"unknown task {task_id!r} under {self.root}; available: {sorted(available) or ''}" + ) + + def _task_dirs(self) -> dict[str, Path]: + if self._discovered is None: + self._discovered = self._scan() + return self._discovered + + def _scan(self) -> dict[str, Path]: + if not self.root.is_dir(): + return {} + if (self.root / TASK_CONFIG_FILE).is_file(): + return {self.root.name: self.root} + + found: dict[str, Path] = {} + stack = [(self.root, 0)] + while stack: + directory, depth = stack.pop() + if depth > _MAX_DISCOVERY_DEPTH: + continue + for child in sorted(directory.iterdir()): + if not child.is_dir() or child.name.startswith("."): + continue + if (child / TASK_CONFIG_FILE).is_file(): + found[child.relative_to(self.root).as_posix()] = child + else: + stack.append((child, depth + 1)) + return found + + +def _table(config: dict[str, Any], key: str) -> dict[str, Any]: + value = config.get(key) + return dict(value) if isinstance(value, dict) else {} + + +def _timeout(config: dict[str, Any], section: str, fallback: float) -> float: + raw = _table(config, section).get("timeout_sec") + try: + parsed = float(raw) # type: ignore[arg-type] + except (TypeError, ValueError): + return fallback + return parsed if parsed > 0 else fallback diff --git a/src/repo2rlenv/openenv/environment.py b/src/repo2rlenv/openenv/environment.py new file mode 100644 index 00000000..a6370fcd --- /dev/null +++ b/src/repo2rlenv/openenv/environment.py @@ -0,0 +1,309 @@ +"""Serve a Repo2RLEnv dataset as an OpenEnv environment. + +`repo2rlenv generate` produces verifiable task directories; this turns a +directory of them into a Gymnasium-style environment a trainer can drive over +OpenEnv's `reset()` / `step()` / `state` API. + +The module is deliberately thin. It decides which task to run +(`dataset.TaskSet`), asks the sandbox to execute things (`sandbox.DockerSandbox`), +and forwards the verifier's verdict (`reward.RewardReport`). It never computes a +reward itself — the reward is the one our own `tests/test.sh` wrote, unchanged. +""" + +from __future__ import annotations + +import logging +import os +from collections.abc import Callable +from typing import Any +from uuid import uuid4 + +from openenv.core.env_server.interfaces import Environment + +from repo2rlenv.openenv.dataset import Repo2RLEnvTask, TaskSet +from repo2rlenv.openenv.models import Repo2RLEnvAction, Repo2RLEnvObservation, Repo2RLEnvState +from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult, SandboxError, resolve_within + +logger = logging.getLogger(__name__) + +DEFAULT_COMMAND_TIMEOUT_S = 120.0 + +#: Upper bound on how many ids `Repo2RLEnvState.available_tasks` carries, so a +#: dataset with thousands of tasks does not bloat every state response. +MAX_LISTED_TASKS = 200 + +_Handler = Callable[[Repo2RLEnvAction, DockerSandbox, Repo2RLEnvTask], Repo2RLEnvObservation] + + +class Repo2RLEnvEnvironment(Environment[Repo2RLEnvAction, Repo2RLEnvObservation, Repo2RLEnvState]): + """Runs one Repo2RLEnv task per episode. + + Each `reset()` boots a fresh container for one task. The agent then works + through `exec` / `read` / `write`, and the training loop ends the episode + with `evaluate`, which runs the task's own verifier and forwards whatever + reward it wrote. + + Args: + dataset: directory of emitted tasks. Defaults to `$REPO2RLENV_TASKS_DIR`, + then to the `tasks/` directory next to this environment. + default_task_id: task used when `reset()` names none. Defaults to + `$REPO2RLENV_DEFAULT_TASK_ID`. + command_timeout_s: timeout applied to agent `exec` actions. The verifier + and the oracle instead use the timeouts declared in `task.toml`. + sandbox_factory: builds the sandbox. Injected by tests. + """ + + # Every episode gets its own container, so sessions share no mutable state. + SUPPORTS_CONCURRENT_SESSIONS: bool = True + + def __init__( + self, + dataset: str | None = None, + default_task_id: str | None = None, + command_timeout_s: float = DEFAULT_COMMAND_TIMEOUT_S, + sandbox_factory: Callable[[], DockerSandbox] | None = None, + ) -> None: + super().__init__() + self.command_timeout_s = command_timeout_s + self.default_task_id = default_task_id or os.getenv("REPO2RLENV_DEFAULT_TASK_ID") or None + self._sandbox_factory = sandbox_factory or DockerSandbox + self.tasks = TaskSet(_resolve_dataset(dataset)) + + self._task: Repo2RLEnvTask | None = None + self._sandbox: DockerSandbox | None = None + self._state = Repo2RLEnvState() + self._refresh_dataset_state() + + self._handlers: dict[str, _Handler] = { + "exec": self._do_exec, + "read": self._do_read, + "write": self._do_write, + "evaluate": self._do_evaluate, + "solve": self._do_solve, + } + + # --- Gymnasium API ------------------------------------------------------ + + def reset( + self, + seed: int | None = None, + episode_id: str | None = None, + **kwargs: Any, + ) -> Repo2RLEnvObservation: + """Start a fresh episode on one task. + + Accepts `task_id` to choose the task; defaults to `default_task_id`, or + to the only task in the dataset when there is exactly one. + """ + del seed + + self.close() + task = self.tasks.get(self._select_task_id(kwargs.get("task_id"))) + sandbox = self._sandbox_factory() + try: + sandbox.start(task) + except Exception: + sandbox.close() + raise + + self._task = task + self._sandbox = sandbox + self._state = Repo2RLEnvState( + episode_id=episode_id or str(uuid4()), + task_id=task.task_id, + task_name=task.name, + task_path=str(task.path), + pipeline=task.pipeline, + image=sandbox.image, + workdir=sandbox.paths.workdir, + ) + self._refresh_dataset_state() + + return self._observe("reset", output="", info={"task": task.summary()}) + + def step( + self, + action: Repo2RLEnvAction, + timeout_s: float | None = None, + **kwargs: Any, + ) -> Repo2RLEnvObservation: + """Apply one action to the running episode.""" + del timeout_s, kwargs + + if not isinstance(action, Repo2RLEnvAction): + raise TypeError(f"expected Repo2RLEnvAction, got {type(action).__name__}") + + self._state.step_count += 1 + self._state.last_action_type = action.action_type + + try: + sandbox, task = self._require_episode() + return self._handlers[action.action_type](action, sandbox, task) + except Exception as exc: + # Invalid actions and sandbox failures come back in the observation + # so a policy can recover; only server faults propagate. + logger.info("action %s failed: %s", action.action_type, exc) + return self._observe(action.action_type, output="", success=False, error=str(exc)) + + @property + def state(self) -> Repo2RLEnvState: + """Current episode state.""" + return self._state + + def close(self) -> None: + """Tear down the running sandbox, if any.""" + if self._sandbox is not None: + self._sandbox.close() + self._sandbox = None + self._task = None + + # --- action handlers ---------------------------------------------------- + + def _do_exec( + self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask + ) -> Repo2RLEnvObservation: + del task + if not action.command.strip(): + raise ValueError("exec requires a non-empty command") + result = sandbox.exec(action.command, timeout_s=action.timeout_s or self.command_timeout_s) + return self._from_exec("exec", result) + + def _do_read( + self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask + ) -> Repo2RLEnvObservation: + del task + target = resolve_within(sandbox.paths.workdir, action.path) + content = sandbox.read_text(target) + if content is None: + raise FileNotFoundError(f"no such file: {action.path}") + return self._observe("read", output=content) + + def _do_write( + self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask + ) -> Repo2RLEnvObservation: + del task + target = resolve_within(sandbox.paths.workdir, action.path) + sandbox.write_text(target, action.content) + return self._observe("write", output=f"wrote {len(action.content)} bytes to {action.path}") + + def _do_evaluate( + self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask + ) -> Repo2RLEnvObservation: + """Run the task's verifier and forward its reward. Ends the episode.""" + del action + result = sandbox.run_verifier(task) + report = sandbox.reward_report() + + self._state.evaluated = True + self._state.reward = report.value + self._state.last_exit_code = result.exit_code + + info = {**report.as_info(), "verifier_exit_code": result.exit_code} + if not report.graded: + # No reward file means the episode cannot be scored. Say so rather + # than inventing a number indistinguishable from a genuine 0.0. + return self._observe( + "evaluate", + output=result.output, + success=False, + error=( + f"the verifier wrote no reward file to {sandbox.paths.logs_verifier}; " + "the episode cannot be scored" + ), + exit_code=result.exit_code, + timed_out=result.timed_out, + done=True, + info=info, + ) + return self._observe( + "evaluate", + output=result.output, + exit_code=result.exit_code, + timed_out=result.timed_out, + reward=report.value, + done=True, + info=info, + ) + + def _do_solve( + self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask + ) -> Repo2RLEnvObservation: + """Apply the task's own oracle patch. + + Orchestration-only: it proves a task is solvable and produces gold + trajectories. Follow it with `evaluate`, which should return full reward. + """ + del action + return self._from_exec("solve", sandbox.run_solution(task)) + + # --- observation plumbing ----------------------------------------------- + + def _from_exec(self, action_type: str, result: ExecResult) -> Repo2RLEnvObservation: + self._state.last_exit_code = result.exit_code + return self._observe( + action_type, + output=result.output, + success=result.ok, + error="command timed out" if result.timed_out else "", + exit_code=result.exit_code, + timed_out=result.timed_out, + ) + + def _observe( + self, + action_type: str, + output: str, + success: bool = True, + error: str = "", + exit_code: int | None = None, + timed_out: bool = False, + reward: float | None = None, + done: bool = False, + info: dict[str, Any] | None = None, + ) -> Repo2RLEnvObservation: + return Repo2RLEnvObservation( + instruction=self._task.instruction if self._task else "", + output=output, + action_type=action_type, + success=success, + error=error, + exit_code=exit_code, + timed_out=timed_out, + task_id=self._state.task_id, + task_name=self._state.task_name, + pipeline=self._state.pipeline, + workdir=self._state.workdir, + info=info or {}, + reward=reward, + done=done, + ) + + # --- helpers ------------------------------------------------------------ + + def _select_task_id(self, requested: str | None) -> str: + task_id = requested or self.default_task_id + if task_id: + return task_id + available = self.tasks.task_ids() + if len(available) == 1: + return available[0] + raise ValueError( + f"reset() needs a task_id: the dataset at {self.tasks.root} holds " + f"{len(available)} tasks. Available: {available[:10]}" + f"{' ...' if len(available) > 10 else ''}" + ) + + def _require_episode(self) -> tuple[DockerSandbox, Repo2RLEnvTask]: + if self._sandbox is None or self._task is None: + raise SandboxError("no episode is running; call reset() first") + return self._sandbox, self._task + + def _refresh_dataset_state(self) -> None: + task_ids = self.tasks.task_ids() + self._state.task_count = len(task_ids) + self._state.available_tasks = task_ids[:MAX_LISTED_TASKS] + + +def _resolve_dataset(dataset: str | None) -> str: + """Where to look for tasks: the argument, the env var, then ./tasks.""" + return dataset or os.getenv("REPO2RLENV_TASKS_DIR") or "tasks" diff --git a/src/repo2rlenv/openenv/models.py b/src/repo2rlenv/openenv/models.py new file mode 100644 index 00000000..8671e489 --- /dev/null +++ b/src/repo2rlenv/openenv/models.py @@ -0,0 +1,113 @@ +"""OpenEnv wire types for a Repo2RLEnv task environment. + +Shared by the client and the server; neither side imports the other. + +`openenv` is an optional dependency — install it with +`pip install 'repo2rlenv[openenv]'`. +""" + +from __future__ import annotations + +from typing import Any, Literal + +from openenv.core.env_server.types import Action, Observation, State +from pydantic import Field + +#: What an agent may do while solving the task. +AGENT_ACTIONS: frozenset[str] = frozenset({"exec", "read", "write"}) + +#: Reserved for training orchestration. `evaluate` grades the episode and ends +#: it; `solve` applies the task's own oracle patch. Neither belongs to the +#: agent's action space — an agent that could grade or solve on demand would be +#: able to end its own episode or read out the answer. +CONTROL_ACTIONS: frozenset[str] = frozenset({"evaluate", "solve"}) + +ActionType = Literal["exec", "read", "write", "evaluate", "solve"] + + +class Repo2RLEnvAction(Action): + """One interaction with a Repo2RLEnv task sandbox. + + Attributes: + action_type: exec / read / write (agent), or evaluate / solve (orchestration). + command: shell command, for `exec`. + path: path relative to the working directory, for `read` and `write`. + content: file contents, for `write`. + timeout_s: overrides the default command timeout; ignored by + `evaluate` and `solve`, which use the timeouts in `task.toml`. + """ + + action_type: ActionType = Field(default="exec") + command: str = Field(default="") + path: str = Field(default="") + content: str = Field(default="") + timeout_s: float | None = Field(default=None, gt=0) + + +class Repo2RLEnvObservation(Observation): + """What the sandbox reported back. + + Attributes: + instruction: the task's instruction.md, repeated every step so a + stateless policy can always see the goal. + output: merged stdout/stderr, file contents for `read`, or a short + confirmation for `write`. + action_type: the action this observation answers, or "reset". + success: whether the action itself completed. Unrelated to the reward — + a failing test command is still a successful `exec`. + error: why the action failed, when it did. + exit_code: exit status, for actions that ran a command. + timed_out: whether the command was killed by its timeout. + task_id: identifier of the running task. + task_name: the task's qualified `/` name. + pipeline: which synthesis pipeline produced the task. + workdir: working directory inside the sandbox; `path` is relative to it. + info: extra detail — the reward breakdown after `evaluate`, the task + digest after `reset()`. + """ + + instruction: str = Field(default="") + output: str = Field(default="") + action_type: str = Field(default="") + success: bool = Field(default=True) + error: str = Field(default="") + exit_code: int | None = Field(default=None) + timed_out: bool = Field(default=False) + task_id: str = Field(default="") + task_name: str = Field(default="") + pipeline: str = Field(default="") + workdir: str = Field(default="") + info: dict[str, Any] = Field(default_factory=dict) + + +class Repo2RLEnvState(State): + """Server-side episode state, for training orchestration. + + Attributes: + task_id: identifier of the running task, empty before the first reset(). + task_name: the task's qualified name. + task_path: task directory on the server. + pipeline: which synthesis pipeline produced the task. + image: the image backing the sandbox. + workdir: working directory inside the sandbox. + available_tasks: task identifiers discovered in the dataset, truncated + for large datasets — see `task_count` for the true total. + task_count: number of tasks in the dataset. + last_action_type: the most recent action. + last_exit_code: exit status of the most recent command. + evaluated: whether the verifier has run; the episode ends when it has. + reward: reward reported by the verifier, once it has run. + """ + + task_id: str = Field(default="") + task_name: str = Field(default="") + task_path: str = Field(default="") + pipeline: str = Field(default="") + image: str = Field(default="") + workdir: str = Field(default="") + available_tasks: list[str] = Field(default_factory=list) + task_count: int = Field(default=0) + last_action_type: str = Field(default="") + last_exit_code: int | None = Field(default=None) + evaluated: bool = Field(default=False) + reward: float | None = Field(default=None) diff --git a/src/repo2rlenv/openenv/reward.py b/src/repo2rlenv/openenv/reward.py new file mode 100644 index 00000000..805e134e --- /dev/null +++ b/src/repo2rlenv/openenv/reward.py @@ -0,0 +1,153 @@ +"""The reward half of the Repo2RLEnv verifier contract. + +Every runtime verifier we emit ends by writing its verdict into +`/logs/verifier/`, never through its exit code (`test.sh` ends with `exit 0` on +purpose). Two files matter: + + reward.txt the scalar training signal + reward-details.json the diagnostic breakdown (F2P/P2P counts, resolved, + parse_status; or per-component diff-similarity scores) + +Harbor also allows a flat numeric `reward.json`, so we read that first and fall +back to `reward.txt` — the same precedence Harbor itself applies. + +The reward is produced *inside* the sandbox by the task's own verifier and only +forwarded from here. When no reward file exists the reward is `None`, never +`0.0`: a fabricated zero is indistinguishable from a genuine failure and would +quietly poison a training run. +""" + +from __future__ import annotations + +import json +from collections.abc import Callable +from dataclasses import dataclass, field +from typing import Any + +#: Reads a file name inside `/logs/verifier/`, returning None when absent. +#: Taking a reader rather than a path keeps this identical for a local +#: directory and for files inside a container. +LogReader = Callable[[str], "str | None"] + +REWARD_JSON = "reward.json" +REWARD_TXT = "reward.txt" +REWARD_DETAILS_JSON = "reward-details.json" + +#: Key treated as the scalar when `reward.json` carries several metrics. +PRIMARY_METRIC = "reward" + + +@dataclass(frozen=True) +class RewardReport: + """What the verifier left behind in `/logs/verifier/`. + + Attributes: + value: The scalar reward, or None when the verifier wrote no reward file. + source: Which artifact the scalar came from — reward.json / reward.txt / missing. + metrics: Every flat numeric metric from `reward.json`. + details: Parsed `reward-details.json`, when present. + errors: Problems encountered while reading the artifacts. + """ + + value: float | None = None + source: str = "missing" + metrics: dict[str, float] = field(default_factory=dict) + details: dict[str, Any] = field(default_factory=dict) + errors: list[str] = field(default_factory=list) + + @property + def graded(self) -> bool: + """Whether the verifier produced a usable reward.""" + return self.value is not None + + def as_info(self) -> dict[str, Any]: + """A JSON-serializable digest for `Observation.info`.""" + info: dict[str, Any] = {"reward_source": self.source} + if self.metrics: + info["reward_metrics"] = self.metrics + if self.details: + info["reward_details"] = self.details + if self.errors: + info["reward_errors"] = self.errors + return info + + +def read_reward(read_text: LogReader) -> RewardReport: + """Recover the verdict from a verifier log directory.""" + errors: list[str] = [] + details = _load_details(read_text, errors) + metrics, scalar = _load_metrics(read_text, errors) + + if scalar is not None: + return RewardReport(scalar, REWARD_JSON, metrics, details, errors) + + scalar = _load_scalar_txt(read_text, errors) + if scalar is not None: + return RewardReport(scalar, REWARD_TXT, metrics, details, errors) + + return RewardReport(None, "missing", metrics, details, errors) + + +def _load_metrics(read_text: LogReader, errors: list[str]) -> tuple[dict[str, float], float | None]: + raw = _read(read_text, REWARD_JSON, errors) + if raw is None: + return {}, None + + try: + payload = json.loads(raw) + except ValueError as exc: + errors.append(f"{REWARD_JSON} is not valid JSON: {exc}") + return {}, None + if not isinstance(payload, dict): + errors.append(f"{REWARD_JSON} must be a JSON object, got {type(payload).__name__}") + return {}, None + + metrics = { + str(key): float(val) + for key, val in payload.items() + # bool is an int subclass; the schema here is numeric-only. + if isinstance(val, (int, float)) and not isinstance(val, bool) + } + if PRIMARY_METRIC in metrics: + return metrics, metrics[PRIMARY_METRIC] + if len(metrics) == 1: + return metrics, next(iter(metrics.values())) + if metrics: + # Several metrics and no agreed primary: fall through to reward.txt + # rather than picking one arbitrarily. + errors.append( + f"{REWARD_JSON} has no {PRIMARY_METRIC!r} key among {sorted(metrics)}; " + f"falling back to {REWARD_TXT}" + ) + return metrics, None + + +def _load_scalar_txt(read_text: LogReader, errors: list[str]) -> float | None: + raw = _read(read_text, REWARD_TXT, errors) + if raw is None: + return None + try: + return float(raw.strip()) + except ValueError: + errors.append(f"{REWARD_TXT} is not a number: {raw.strip()[:80]!r}") + return None + + +def _load_details(read_text: LogReader, errors: list[str]) -> dict[str, Any]: + raw = _read(read_text, REWARD_DETAILS_JSON, errors) + if raw is None: + return {} + try: + payload = json.loads(raw) + except ValueError as exc: + errors.append(f"{REWARD_DETAILS_JSON} is not valid JSON: {exc}") + return {} + return payload if isinstance(payload, dict) else {} + + +def _read(read_text: LogReader, name: str, errors: list[str]) -> str | None: + try: + return read_text(name) + except Exception as exc: # pragma: no cover - backend-specific failures + errors.append(f"could not read {name}: {exc}") + return None diff --git a/src/repo2rlenv/openenv/sandbox.py b/src/repo2rlenv/openenv/sandbox.py new file mode 100644 index 00000000..f5abb274 --- /dev/null +++ b/src/repo2rlenv/openenv/sandbox.py @@ -0,0 +1,338 @@ +"""The Docker sandbox a Repo2RLEnv task runs in. + +Every runtime pipeline we ship bakes the repository's state into the task's own +image, so the sandbox is Docker — there is no meaningful "run it locally" mode +for a task whose starting state only exists inside a container. + +The sandbox reproduces the filesystem contract our verifiers are written +against: + + /workspace the checkout the agent edits (the image's WORKDIR) + /tests the task's tests/, staged just before the verifier runs + /solution the task's solution/, staged only for the oracle + /logs/verifier where test.sh writes reward.txt + reward-details.json + /logs/agent scratch space + +Files are streamed in over the Docker API rather than bind-mounted, so the +environment server can itself run inside a container. +""" + +from __future__ import annotations + +import io +import logging +import posixpath +import re +import tarfile +from dataclasses import dataclass +from pathlib import Path + +from repo2rlenv.openenv.dataset import Repo2RLEnvTask +from repo2rlenv.openenv.reward import RewardReport, read_reward + +logger = logging.getLogger(__name__) + +#: Exit code GNU `timeout` reports when it kills a command. +TIMEOUT_EXIT_CODE = 124 + +#: Where our pipelines put the checkout. Used only when the image itself +#: declares no WORKDIR. +DEFAULT_WORKDIR = "/workspace" + + +class SandboxError(RuntimeError): + """Raised when the sandbox cannot start or cannot run something.""" + + +@dataclass(frozen=True) +class ExecResult: + """Outcome of one command run inside the sandbox.""" + + exit_code: int + output: str + timed_out: bool = False + + @property + def ok(self) -> bool: + return self.exit_code == 0 and not self.timed_out + + +@dataclass(frozen=True) +class SandboxPaths: + """The absolute paths our task scripts are written against.""" + + workdir: str = DEFAULT_WORKDIR + tests: str = "/tests" + solution: str = "/solution" + logs: str = "/logs" + + @property + def logs_verifier(self) -> str: + return posixpath.join(self.logs, "verifier") + + @property + def logs_agent(self) -> str: + return posixpath.join(self.logs, "agent") + + def as_env(self) -> dict[str, str]: + """Path layout exported to task scripts. + + Harbor-lineage scripts read `TEST_DIR`; ours use absolute paths, but + exporting both keeps third-party tasks working unchanged. + """ + return { + "HARBOR_WORKDIR": self.workdir, + "HARBOR_TESTS_DIR": self.tests, + "HARBOR_SOLUTION_DIR": self.solution, + "HARBOR_LOGS_DIR": self.logs_verifier, + "HARBOR_AGENT_LOGS_DIR": self.logs_agent, + "TEST_DIR": self.tests, + } + + +class DockerSandbox: + """Runs one task inside its own image for the life of one episode. + + Args: + keep_container: leave the container in place after `close()`, for debugging. + """ + + def __init__(self, keep_container: bool = False) -> None: + self.paths = SandboxPaths() + self.keep_container = keep_container + self._client = None + self._container = None + self._image = "" + self._has_timeout: bool | None = None + + @property + def image(self) -> str: + """The image backing this sandbox.""" + return self._image + + # --- lifecycle ---------------------------------------------------------- + + def start(self, task: Repo2RLEnvTask) -> None: + """Resolve the task's image, boot a container, and lay out the paths.""" + client = self._connect() + self._image = self._resolve_image(task, client) + self._container = client.containers.run( + image=self._image, + command=["sleep", "infinity"], + detach=True, + labels={"repo2rlenv.task": task.task_id}, + auto_remove=False, + ) + self.paths = SandboxPaths(workdir=self._image_workdir(client)) + self.mkdirs(self.paths.workdir, self.paths.logs_verifier, self.paths.logs_agent) + + def close(self) -> None: + """Remove the container.""" + if self._container is not None and not self.keep_container: + try: + self._container.remove(force=True) + except Exception: # pragma: no cover - best-effort teardown + logger.warning("could not remove container", exc_info=True) + self._container = None + self._client = None + + # --- primitives --------------------------------------------------------- + + def exec( + self, + command: str, + *, + timeout_s: float, + env: dict[str, str] | None = None, + workdir: str | None = None, + ) -> ExecResult: + """Run `command` through bash and return its merged output.""" + container = self._require_container() + process_env = dict(self.paths.as_env()) + process_env.update(env or {}) + exit_code, output = container.exec_run( + cmd=["bash", "-c", self._with_timeout(command, timeout_s)], + workdir=workdir or self.paths.workdir, + environment=process_env, + demux=False, + ) + text = output.decode("utf-8", errors="replace") if output else "" + # The Docker API reports a null exit code when the exec never started. + status = int(exit_code) if exit_code is not None else 1 + return ExecResult(status, text, timed_out=status == TIMEOUT_EXIT_CODE) + + def read_text(self, path: str) -> str | None: + """Read a text file, returning None when it does not exist.""" + result = self.exec(f"cat {_quote(path)}", timeout_s=60.0) + return result.output if result.ok else None + + def write_text(self, path: str, content: str) -> None: + """Write a text file, creating parent directories as needed.""" + container = self._require_container() + directory, name = posixpath.split(path) + self.mkdirs(directory) + container.put_archive(directory, _tar_bytes({name: content.encode("utf-8")})) + + def upload_dir(self, source: Path, destination: str) -> None: + """Copy a host directory into the container.""" + container = self._require_container() + self.mkdirs(destination) + stream = io.BytesIO() + with tarfile.open(fileobj=stream, mode="w") as archive: + for entry in sorted(source.rglob("*")): + archive.add(entry, arcname=entry.relative_to(source).as_posix()) + container.put_archive(destination, stream.getvalue()) + + def mkdirs(self, *paths: str) -> None: + """Create directories inside the container. + + Runs from `/` so it works before the working directory exists — a fresh + image often declares a WORKDIR that is not in the filesystem yet. + """ + quoted = " ".join(_quote(p) for p in paths if p) + if not quoted: + return + result = self.exec(f"mkdir -p {quoted}", timeout_s=60.0, workdir="/") + if not result.ok: + raise SandboxError(f"could not create {list(paths)}: {result.output.strip()}") + + # --- episode phases ----------------------------------------------------- + + def run_verifier(self, task: Repo2RLEnvTask) -> ExecResult: + """Stage `tests/` and run `tests/test.sh`. + + Raises: + SandboxError: if the task ships no verifier. + """ + if task.test_script is None: + raise SandboxError( + f"task {task.task_id!r} has no tests/test.sh, so it cannot be graded" + ) + # Start from an empty verifier log directory: the reward must describe + # *this* run. The agent shares the container and could otherwise plant a + # reward file that outlives a verifier which fails before writing one. + self.exec(f"rm -rf {_quote(self.paths.logs_verifier)}", timeout_s=60.0, workdir="/") + self.mkdirs(self.paths.logs_verifier) + self.upload_dir(task.tests_dir, self.paths.tests) + script = posixpath.join(self.paths.tests, task.test_script.name) + return self.exec(f"bash {_quote(script)}", timeout_s=task.verifier_timeout_s) + + def run_solution(self, task: Repo2RLEnvTask) -> ExecResult: + """Stage `solution/` and run `solution/solve.sh` — the oracle. + + Raises: + SandboxError: if the task ships no oracle. + """ + if task.solve_script is None: + raise SandboxError( + f"task {task.task_id!r} has no solution/solve.sh, so it has no oracle" + ) + self.upload_dir(task.solution_dir, self.paths.solution) + script = posixpath.join(self.paths.solution, task.solve_script.name) + return self.exec(f"bash {_quote(script)}", timeout_s=task.agent_timeout_s) + + def reward_report(self) -> RewardReport: + """Read the verifier's verdict out of `/logs/verifier`.""" + return read_reward( + lambda name: self.read_text(posixpath.join(self.paths.logs_verifier, name)) + ) + + # --- docker helpers ----------------------------------------------------- + + def _connect(self): + if self._client is None: + try: + import docker + except ImportError as exc: + raise SandboxError( + "the OpenEnv runtime needs the Docker SDK: pip install 'repo2rlenv[openenv]'" + ) from exc + try: + self._client = docker.from_env() + self._client.ping() + except Exception as exc: + raise SandboxError(f"could not reach the Docker daemon: {exc}") from exc + return self._client + + def _resolve_image(self, task: Repo2RLEnvTask, client) -> str: + """Pull the pushed image when there is one, else build the task's Dockerfile.""" + pullable = task.pullable_image + if pullable: + try: + client.images.get(pullable) + except Exception: + logger.info("pulling %s", pullable) + client.images.pull(pullable) + return pullable + + if task.dockerfile is None: + raise SandboxError( + f"task {task.task_id!r} has no environment/Dockerfile and no pushed image, so it " + "cannot be executed. Text-only `pr_diff` tasks are scored against " + "solution/patch.diff instead — see repo2rlenv.reward." + ) + tag = f"repo2rlenv/{_slug(task.task_id)}:latest" + logger.info("building %s from %s", tag, task.dockerfile) + client.images.build( + path=str(task.environment_dir), dockerfile=task.dockerfile.name, tag=tag, rm=True + ) + return tag + + def _image_workdir(self, client) -> str: + try: + config = client.images.get(self._image).attrs.get("Config", {}) + return str(config.get("WorkingDir") or DEFAULT_WORKDIR) + except Exception: # pragma: no cover - image metadata is best-effort + return DEFAULT_WORKDIR + + def _with_timeout(self, command: str, timeout_s: float) -> str: + """Bound `command` with GNU timeout when the image provides it.""" + if self._has_timeout is None: + container = self._require_container() + probe, _ = container.exec_run(cmd=["sh", "-c", "command -v timeout"]) + self._has_timeout = int(probe) == 0 + if not self._has_timeout: + return command + return f"timeout -k 5 {int(max(timeout_s, 1))} bash -c {_quote(command)}" + + def _require_container(self): + if self._container is None: + raise SandboxError("sandbox is not running; call start() first") + return self._container + + +def resolve_within(base: str, relative: str) -> str: + """Resolve `relative` under `base`, rejecting anything that escapes it. + + Applied to every agent-supplied path so a policy cannot read or write + outside the checkout — in particular it cannot reach /tests or /solution. + + Raises: + ValueError: if `relative` is absolute or escapes `base`. + """ + if posixpath.isabs(relative): + raise ValueError(f"path must be relative to the working directory: {relative!r}") + base_norm = posixpath.normpath(base) + target = posixpath.normpath(posixpath.join(base_norm, relative)) + if target != base_norm and not target.startswith(base_norm.rstrip("/") + "/"): + raise ValueError(f"path escapes the working directory: {relative!r}") + return target + + +def _tar_bytes(files: dict[str, bytes]) -> bytes: + stream = io.BytesIO() + with tarfile.open(fileobj=stream, mode="w") as archive: + for name, payload in files.items(): + info = tarfile.TarInfo(name=name) + info.size = len(payload) + info.mode = 0o644 + archive.addfile(info, io.BytesIO(payload)) + return stream.getvalue() + + +def _quote(value: str) -> str: + return "'" + value.replace("'", "'\\''") + "'" + + +def _slug(value: str) -> str: + return re.sub(r"[^a-z0-9_.-]+", "-", value.lower()).strip("-") or "task" diff --git a/tests/test_openenv_export.py b/tests/test_openenv_export.py new file mode 100644 index 00000000..6b32a216 --- /dev/null +++ b/tests/test_openenv_export.py @@ -0,0 +1,405 @@ +"""The OpenEnv export path: dataset parsing, reward contract, and env emission. + +Hermetic — no Docker, no network. The Docker-backed sandbox is exercised by the +end-to-end run documented in docs/reference/OPENENV.md, not here. +""" + +from __future__ import annotations + +import json +import tomllib +from pathlib import Path + +import pytest +import yaml + +from repo2rlenv.emitter.harbor import HarborTask, write_harbor_task +from repo2rlenv.emitter.openenv import EmitError, write_openenv_env +from repo2rlenv.openenv.dataset import Repo2RLEnvTask, TaskFormatError, TaskSet +from repo2rlenv.openenv.reward import read_reward + +# --------------------------------------------------------------------------- +# helpers +# --------------------------------------------------------------------------- + + +def _emit( + dest: Path, + name: str = "demo__task-1", + *, + dockerfile: str | None = "FROM python:3.12-slim\nWORKDIR /workspace\n", + test_script: str | None = "#!/bin/bash\nexit 0\n", +) -> Path: + """Write a task with the real Harbor emitter, so tests track the real format.""" + task = HarborTask( + name=name, + org="repo2rlenv", + description="example", + instruction="# Fix it\n\nmake the tests pass\n", + oracle_diff="--- a/x.py\n+++ b/x.py\n@@\n-1\n+2\n", + repo2env={"pipeline": "pr_runtime", "repo": "demo/repo"}, + environment_dockerfile=dockerfile, + test_script=test_script, + ) + return write_harbor_task(task, dest) + + +def _reader(files: dict[str, str]): + return lambda name: files.get(name) + + +# --------------------------------------------------------------------------- +# reading an emitted task back +# --------------------------------------------------------------------------- + + +def test_load_reads_our_own_emitted_task(tmp_path: Path): + """The reader must accept exactly what the Harbor emitter writes.""" + path = _emit(tmp_path) + task = Repo2RLEnvTask.load(path) + + # We emit `version`, not Harbor's `schema_version`. + assert task.schema_version == "1.0" + assert task.name == "repo2rlenv/demo__task-1" + assert task.pipeline == "pr_runtime" + assert task.instruction.startswith("# Fix it") + assert task.content_hash.startswith("sha256:") + assert task.dockerfile is not None + assert task.test_script is not None + assert task.solve_script is not None + assert task.oracle_diff is not None + assert task.runnable + + +def test_load_rejects_a_non_task_directory(tmp_path: Path): + with pytest.raises(TaskFormatError): + Repo2RLEnvTask.load(tmp_path) + + +def test_timeouts_come_from_task_toml(tmp_path: Path): + task = Repo2RLEnvTask.load(_emit(tmp_path)) + # The emitter writes agent=1800, verifier=300. + assert task.agent_timeout_s == 1800.0 + assert task.verifier_timeout_s == 300.0 + + +def test_text_only_task_is_not_runnable(tmp_path: Path): + """`pr_diff` with emit_harbor_env=False ships no image and no verifier.""" + task = Repo2RLEnvTask.load(_emit(tmp_path, dockerfile=None, test_script=None)) + assert task.dockerfile is None + assert task.test_script is None + assert not task.runnable + + +def test_only_registry_mode_yields_a_pullable_image(tmp_path: Path): + """local_only / inline_dockerfile image refs may exist on no other machine.""" + path = _emit(tmp_path) + # The emitter seeds mode=local_only for Dockerfile-bearing tasks. + assert Repo2RLEnvTask.load(path).repro_mode == "local_only" + assert Repo2RLEnvTask.load(path).pullable_image is None + + toml_path = path / "task.toml" + data = tomllib.loads(toml_path.read_text()) + repro = data["metadata"]["repo2env"]["reproducibility"] + repro["mode"] = "registry" + repro["image_ref"] = "ghcr.io/acme/task:abc123" + toml_path.write_text(_dumps(data)) + + reloaded = Repo2RLEnvTask.load(path) + assert reloaded.pullable_image == "ghcr.io/acme/task:abc123" + + +def _dumps(data: dict) -> str: + import tomli_w + + return tomli_w.dumps(data) + + +# --------------------------------------------------------------------------- +# discovery +# --------------------------------------------------------------------------- + + +def test_taskset_finds_flat_and_nested_layouts(tmp_path: Path): + """`generate --out` writes flat; `push` stages under tasks//.""" + _emit(tmp_path, "flat-task") + _emit(tmp_path / "tasks", "staged-task") + + assert TaskSet(tmp_path).task_ids() == ["flat-task", "tasks/staged-task"] + + +def test_taskset_accepts_a_single_task_directory(tmp_path: Path): + path = _emit(tmp_path, "solo") + assert TaskSet(path).task_ids() == ["solo"] + + +def test_taskset_resolves_a_bare_name_and_reports_unknown_ids(tmp_path: Path): + _emit(tmp_path / "tasks", "nested-one") + task_set = TaskSet(tmp_path) + + assert task_set.get("nested-one").task_id == "tasks/nested-one" + with pytest.raises(KeyError): + task_set.get("nope") + + +# --------------------------------------------------------------------------- +# the reward contract +# --------------------------------------------------------------------------- + + +def test_reward_txt_is_the_scalar_our_verifiers_write(): + report = read_reward(_reader({"reward.txt": "0.750000\n"})) + assert report.value == pytest.approx(0.75) + assert report.source == "reward.txt" + assert report.graded + + +def test_reward_json_wins_over_reward_txt(): + report = read_reward(_reader({"reward.json": '{"reward": 0.5}', "reward.txt": "1.0"})) + assert report.value == pytest.approx(0.5) + assert report.source == "reward.json" + + +def test_details_sidecar_is_surfaced_but_never_scored(): + """reward-details.json is diagnostics; the scalar still comes from reward.txt.""" + details = {"resolved": False, "f2p_passed": 0, "f2p_total": 3, "parse_status": "ok"} + report = read_reward(_reader({"reward.txt": "0.0", "reward-details.json": json.dumps(details)})) + assert report.value == 0.0 + assert report.source == "reward.txt" + assert report.details == details + assert report.as_info()["reward_details"] == details + + +def test_missing_reward_is_none_not_zero(): + """A fabricated 0.0 is indistinguishable from a real failure.""" + report = read_reward(_reader({})) + assert report.value is None + assert not report.graded + assert report.source == "missing" + + +def test_unparsable_reward_is_reported_not_guessed(): + report = read_reward(_reader({"reward.txt": "not-a-number"})) + assert report.value is None + assert any("not a number" in e for e in report.errors) + + +# --------------------------------------------------------------------------- +# emitting the environment package +# --------------------------------------------------------------------------- + + +def test_export_writes_a_deployable_package(tmp_path: Path): + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + dest = tmp_path / "env" + + package = write_openenv_env(dataset, dest, name="Demo Env") + + assert package.task_count == 1 + assert package.runnable_task_count == 1 + assert package.name == "demo-env" + for rel in ("openenv.yaml", "Dockerfile", "README.md", "pyproject.toml", "server/app.py"): + assert (dest / rel).is_file(), rel + + +def test_export_copies_tasks_verbatim(tmp_path: Path): + """The whole point: serving adds a layer, it does not convert the data.""" + dataset = tmp_path / "ds" + source = _emit(dataset, "demo__task-1") + dest = tmp_path / "env" + + write_openenv_env(dataset, dest) + + copied = dest / "tasks" / "demo__task-1" + for rel in ("task.toml", "instruction.md", "tests/test.sh", "solution/patch.diff"): + assert (copied / rel).read_text() == (source / rel).read_text(), rel + + +def test_manifest_matches_the_openenv_schema(tmp_path: Path): + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + dest = tmp_path / "env" + + write_openenv_env(dataset, dest, name="click-env", port=9000) + manifest = yaml.safe_load((dest / "openenv.yaml").read_text()) + + assert manifest["spec_version"] == 1 + assert manifest["name"] == "click-env" + assert manifest["type"] == "space" + assert manifest["runtime"] == "fastapi" + assert manifest["app"] == "server.app:app" + assert manifest["port"] == 9000 + assert manifest["action"] == "Repo2RLEnvAction" + assert manifest["observation"] == "Repo2RLEnvObservation" + + +def test_readme_is_a_space_card_naming_a_real_task(tmp_path: Path): + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + dest = tmp_path / "env" + + write_openenv_env(dataset, dest, name="click-env") + readme = (dest / "README.md").read_text() + + assert readme.startswith("---\n") + assert "sdk: docker" in readme + assert "app_port: 8000" in readme + # The quickstart must reference a task that actually ships in the package. + assert 'task_id="demo__task-1"' in readme + + +def test_dockerfile_wires_the_tasks_dir_and_port(tmp_path: Path): + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + dest = tmp_path / "env" + + write_openenv_env( + dataset, dest, name="click-env", port=9000, requirement="repo2rlenv[openenv]==9.9.9" + ) + dockerfile = (dest / "Dockerfile").read_text() + + assert "repo2rlenv[openenv]==9.9.9" in dockerfile + assert "ENV REPO2RLENV_TASKS_DIR=/app/tasks" in dockerfile + assert '"--port", "9000"' in dockerfile + # The server starts task containers on the host daemon. + assert "/var/run/docker.sock" in dockerfile + + +def test_export_flags_text_only_tasks_as_unrunnable(tmp_path: Path): + dataset = tmp_path / "ds" + _emit(dataset, "runtime-task") + _emit(dataset, "text-task", dockerfile=None, test_script=None) + dest = tmp_path / "env" + + package = write_openenv_env(dataset, dest) + + assert package.task_count == 2 + assert package.runnable_task_count == 1 + assert "scored" in (dest / "README.md").read_text() + + +def test_export_rejects_an_empty_dataset(tmp_path: Path): + with pytest.raises(EmitError): + write_openenv_env(tmp_path, tmp_path / "env") + + +def test_export_is_rerunnable_and_prunes_removed_tasks(tmp_path: Path): + """Re-exporting must not leave a stale task behind in the package.""" + dataset = tmp_path / "ds" + _emit(dataset, "keep-me") + stale = _emit(dataset, "delete-me") + dest = tmp_path / "env" + write_openenv_env(dataset, dest) + assert (dest / "tasks" / "delete-me").is_dir() + + import shutil + + shutil.rmtree(stale) + package = write_openenv_env(dataset, dest) + + assert package.task_count == 1 + assert not (dest / "tasks" / "delete-me").exists() + + +def test_emitted_app_module_defers_to_the_library(tmp_path: Path): + """The package ships config, not generated runtime logic.""" + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + dest = tmp_path / "env" + + write_openenv_env(dataset, dest) + app_py = (dest / "server" / "app.py").read_text() + + assert "from repo2rlenv.openenv import build_app" in app_py + assert "app = build_app()" in app_py + + +# --------------------------------------------------------------------------- +# runtime invariants — need the optional `openenv` extra +# --------------------------------------------------------------------------- + + +def test_dataset_reading_does_not_need_the_openenv_extra(): + """`pip install repo2rlenv` must be enough to read a dataset and export it. + + Guards the lazy __getattr__ in repo2rlenv.openenv: importing the package or + the emitter must not drag in `openenv`. + """ + import subprocess + import sys + + code = ( + "import sys;" + "import repo2rlenv.openenv as oe;" + "from repo2rlenv.emitter import write_openenv_env;" + "oe.TaskSet; oe.Repo2RLEnvTask; oe.read_reward;" + "print('openenv' in sys.modules)" + ) + result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True) + assert result.returncode == 0, result.stderr + assert result.stdout.strip() == "False" + + +@pytest.mark.parametrize("relative", ["../etc/passwd", "../../x", "/tests/test.sh", "a/../../b"]) +def test_agent_paths_cannot_escape_the_workspace(relative: str): + pytest.importorskip("openenv") + from repo2rlenv.openenv.sandbox import resolve_within + + with pytest.raises(ValueError): + resolve_within("/workspace", relative) + + +@pytest.mark.parametrize("relative", ["calc.py", "src/pkg/mod.py", "./a.py"]) +def test_agent_paths_inside_the_workspace_resolve(relative: str): + pytest.importorskip("openenv") + from repo2rlenv.openenv.sandbox import resolve_within + + assert resolve_within("/workspace", relative).startswith("/workspace") + + +def test_grading_and_solving_are_not_agent_actions(): + """An agent that could grade or solve on demand would break the boundary.""" + pytest.importorskip("openenv") + from repo2rlenv.openenv.models import AGENT_ACTIONS, CONTROL_ACTIONS + + assert {"exec", "read", "write"} == AGENT_ACTIONS + assert {"evaluate", "solve"} == CONTROL_ACTIONS + assert not (AGENT_ACTIONS & CONTROL_ACTIONS) + + +def test_action_schema_rejects_unknown_action_types(): + pytest.importorskip("openenv") + from repo2rlenv.openenv.models import Repo2RLEnvAction + + with pytest.raises(ValueError): + Repo2RLEnvAction(action_type="rm_rf") + + +def test_client_round_trips_what_the_server_serializes(): + """The trainer-facing client must parse the server's own step payload.""" + pytest.importorskip("openenv") + from repo2rlenv.openenv.client import Repo2RLEnvClient + from repo2rlenv.openenv.models import Repo2RLEnvAction, Repo2RLEnvObservation + + observation = Repo2RLEnvObservation( + output="ok", + action_type="evaluate", + reward=0.75, + done=True, + info={"reward_source": "reward.txt"}, + ) + payload = { + "observation": observation.model_dump(), + "reward": 0.75, + "done": True, + } + client = Repo2RLEnvClient(base_url="http://localhost:8000") + + result = client._parse_result(payload) + assert result.reward == pytest.approx(0.75) + assert result.done is True + assert result.observation.info["reward_source"] == "reward.txt" + + action = Repo2RLEnvAction(action_type="write", path="a.py", content="x = 1\n") + assert Repo2RLEnvAction.model_validate(client._step_payload(action)) == action diff --git a/uv.lock b/uv.lock index d6a5ef2b..b4f4f9be 100644 --- a/uv.lock +++ b/uv.lock @@ -1,6 +1,27 @@ version = 1 revision = 3 requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform != 'win32'", + "python_full_version < '3.13' and sys_platform == 'win32'", + "python_full_version < '3.13' and sys_platform == 'emscripten'", + "python_full_version < '3.13' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] + +[[package]] +name = "aiofile" +version = "3.11.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "caio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/41/2fea7e193e061ce54eacc3b7bc0e6a99e4fcff43c78cf0a76dd781ed8334/aiofile-3.11.1.tar.gz", hash = "sha256:1f91912c6643d2a4e49ca4ae3514f0bf3867ce948a36d99a6411b8f4755f4cf9", size = 19342, upload-time = "2026-05-16T08:18:33.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/cd/0d76dfc5de72bde52f55f53e925c7d152d9c7906634ec1e0cbc7e8d4ad93/aiofile-3.11.1-py3-none-any.whl", hash = "sha256:ce77d14ac07f77bc2b757834a5c129321f3f705c474593deed5ab209079a52c9", size = 20446, upload-time = "2026-05-16T08:18:32.051Z" }, +] [[package]] name = "aiohappyeyeballs" @@ -149,6 +170,152 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, ] +[[package]] +name = "audioop-lts" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/53/946db57842a50b2da2e0c1e34bd37f36f5aadba1a929a3971c5d7841dbca/audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0", size = 30686, upload-time = "2025-08-05T16:43:17.409Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/d4/94d277ca941de5a507b07f0b592f199c22454eeaec8f008a286b3fbbacd6/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800", size = 46523, upload-time = "2025-08-05T16:42:20.836Z" }, + { url = "https://files.pythonhosted.org/packages/f8/5a/656d1c2da4b555920ce4177167bfeb8623d98765594af59702c8873f60ec/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303", size = 27455, upload-time = "2025-08-05T16:42:22.283Z" }, + { url = "https://files.pythonhosted.org/packages/1b/83/ea581e364ce7b0d41456fb79d6ee0ad482beda61faf0cab20cbd4c63a541/audioop_lts-0.2.2-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:9a13dc409f2564de15dd68be65b462ba0dde01b19663720c68c1140c782d1d75", size = 26997, upload-time = "2025-08-05T16:42:23.849Z" }, + { url = "https://files.pythonhosted.org/packages/b8/3b/e8964210b5e216e5041593b7d33e97ee65967f17c282e8510d19c666dab4/audioop_lts-0.2.2-cp313-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51c916108c56aa6e426ce611946f901badac950ee2ddaf302b7ed35d9958970d", size = 85844, upload-time = "2025-08-05T16:42:25.208Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2e/0a1c52faf10d51def20531a59ce4c706cb7952323b11709e10de324d6493/audioop_lts-0.2.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47eba38322370347b1c47024defbd36374a211e8dd5b0dcbce7b34fdb6f8847b", size = 85056, upload-time = "2025-08-05T16:42:26.559Z" }, + { url = "https://files.pythonhosted.org/packages/75/e8/cd95eef479656cb75ab05dfece8c1f8c395d17a7c651d88f8e6e291a63ab/audioop_lts-0.2.2-cp313-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba7c3a7e5f23e215cb271516197030c32aef2e754252c4c70a50aaff7031a2c8", size = 93892, upload-time = "2025-08-05T16:42:27.902Z" }, + { url = "https://files.pythonhosted.org/packages/5c/1e/a0c42570b74f83efa5cca34905b3eef03f7ab09fe5637015df538a7f3345/audioop_lts-0.2.2-cp313-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def246fe9e180626731b26e89816e79aae2276f825420a07b4a647abaa84becc", size = 96660, upload-time = "2025-08-05T16:42:28.9Z" }, + { url = "https://files.pythonhosted.org/packages/50/d5/8a0ae607ca07dbb34027bac8db805498ee7bfecc05fd2c148cc1ed7646e7/audioop_lts-0.2.2-cp313-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e160bf9df356d841bb6c180eeeea1834085464626dc1b68fa4e1d59070affdc3", size = 79143, upload-time = "2025-08-05T16:42:29.929Z" }, + { url = "https://files.pythonhosted.org/packages/12/17/0d28c46179e7910bfb0bb62760ccb33edb5de973052cb2230b662c14ca2e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4b4cd51a57b698b2d06cb9993b7ac8dfe89a3b2878e96bc7948e9f19ff51dba6", size = 84313, upload-time = "2025-08-05T16:42:30.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/ba/bd5d3806641564f2024e97ca98ea8f8811d4e01d9b9f9831474bc9e14f9e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4a53aa7c16a60a6857e6b0b165261436396ef7293f8b5c9c828a3a203147ed4a", size = 93044, upload-time = "2025-08-05T16:42:31.959Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5e/435ce8d5642f1f7679540d1e73c1c42d933331c0976eb397d1717d7f01a3/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:3fc38008969796f0f689f1453722a0f463da1b8a6fbee11987830bfbb664f623", size = 78766, upload-time = "2025-08-05T16:42:33.302Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3b/b909e76b606cbfd53875693ec8c156e93e15a1366a012f0b7e4fb52d3c34/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:15ab25dd3e620790f40e9ead897f91e79c0d3ce65fe193c8ed6c26cffdd24be7", size = 87640, upload-time = "2025-08-05T16:42:34.854Z" }, + { url = "https://files.pythonhosted.org/packages/30/e7/8f1603b4572d79b775f2140d7952f200f5e6c62904585d08a01f0a70393a/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:03f061a1915538fd96272bac9551841859dbb2e3bf73ebe4a23ef043766f5449", size = 86052, upload-time = "2025-08-05T16:42:35.839Z" }, + { url = "https://files.pythonhosted.org/packages/b5/96/c37846df657ccdda62ba1ae2b6534fa90e2e1b1742ca8dcf8ebd38c53801/audioop_lts-0.2.2-cp313-abi3-win32.whl", hash = "sha256:3bcddaaf6cc5935a300a8387c99f7a7fbbe212a11568ec6cf6e4bc458c048636", size = 26185, upload-time = "2025-08-05T16:42:37.04Z" }, + { url = "https://files.pythonhosted.org/packages/34/a5/9d78fdb5b844a83da8a71226c7bdae7cc638861085fff7a1d707cb4823fa/audioop_lts-0.2.2-cp313-abi3-win_amd64.whl", hash = "sha256:a2c2a947fae7d1062ef08c4e369e0ba2086049a5e598fda41122535557012e9e", size = 30503, upload-time = "2025-08-05T16:42:38.427Z" }, + { url = "https://files.pythonhosted.org/packages/34/25/20d8fde083123e90c61b51afb547bb0ea7e77bab50d98c0ab243d02a0e43/audioop_lts-0.2.2-cp313-abi3-win_arm64.whl", hash = "sha256:5f93a5db13927a37d2d09637ccca4b2b6b48c19cd9eda7b17a2e9f77edee6a6f", size = 24173, upload-time = "2025-08-05T16:42:39.704Z" }, + { url = "https://files.pythonhosted.org/packages/58/a7/0a764f77b5c4ac58dc13c01a580f5d32ae8c74c92020b961556a43e26d02/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:73f80bf4cd5d2ca7814da30a120de1f9408ee0619cc75da87d0641273d202a09", size = 47096, upload-time = "2025-08-05T16:42:40.684Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ed/ebebedde1a18848b085ad0fa54b66ceb95f1f94a3fc04f1cd1b5ccb0ed42/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:106753a83a25ee4d6f473f2be6b0966fc1c9af7e0017192f5531a3e7463dce58", size = 27748, upload-time = "2025-08-05T16:42:41.992Z" }, + { url = "https://files.pythonhosted.org/packages/cb/6e/11ca8c21af79f15dbb1c7f8017952ee8c810c438ce4e2b25638dfef2b02c/audioop_lts-0.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fbdd522624141e40948ab3e8cdae6e04c748d78710e9f0f8d4dae2750831de19", size = 27329, upload-time = "2025-08-05T16:42:42.987Z" }, + { url = "https://files.pythonhosted.org/packages/84/52/0022f93d56d85eec5da6b9da6a958a1ef09e80c39f2cc0a590c6af81dcbb/audioop_lts-0.2.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:143fad0311e8209ece30a8dbddab3b65ab419cbe8c0dde6e8828da25999be911", size = 92407, upload-time = "2025-08-05T16:42:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/87/1d/48a889855e67be8718adbc7a01f3c01d5743c325453a5e81cf3717664aad/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfbbc74ec68a0fd08cfec1f4b5e8cca3d3cd7de5501b01c4b5d209995033cde9", size = 91811, upload-time = "2025-08-05T16:42:45.325Z" }, + { url = "https://files.pythonhosted.org/packages/98/a6/94b7213190e8077547ffae75e13ed05edc488653c85aa5c41472c297d295/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cfcac6aa6f42397471e4943e0feb2244549db5c5d01efcd02725b96af417f3fe", size = 100470, upload-time = "2025-08-05T16:42:46.468Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/78450d7cb921ede0cfc33426d3a8023a3bda755883c95c868ee36db8d48d/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:752d76472d9804ac60f0078c79cdae8b956f293177acd2316cd1e15149aee132", size = 103878, upload-time = "2025-08-05T16:42:47.576Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e2/cd5439aad4f3e34ae1ee852025dc6aa8f67a82b97641e390bf7bd9891d3e/audioop_lts-0.2.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:83c381767e2cc10e93e40281a04852facc4cd9334550e0f392f72d1c0a9c5753", size = 84867, upload-time = "2025-08-05T16:42:49.003Z" }, + { url = "https://files.pythonhosted.org/packages/68/4b/9d853e9076c43ebba0d411e8d2aa19061083349ac695a7d082540bad64d0/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c0022283e9556e0f3643b7c3c03f05063ca72b3063291834cca43234f20c60bb", size = 90001, upload-time = "2025-08-05T16:42:50.038Z" }, + { url = "https://files.pythonhosted.org/packages/58/26/4bae7f9d2f116ed5593989d0e521d679b0d583973d203384679323d8fa85/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a2d4f1513d63c795e82948e1305f31a6d530626e5f9f2605408b300ae6095093", size = 99046, upload-time = "2025-08-05T16:42:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/b2/67/a9f4fb3e250dda9e9046f8866e9fa7d52664f8985e445c6b4ad6dfb55641/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:c9c8e68d8b4a56fda8c025e538e639f8c5953f5073886b596c93ec9b620055e7", size = 84788, upload-time = "2025-08-05T16:42:52.198Z" }, + { url = "https://files.pythonhosted.org/packages/70/f7/3de86562db0121956148bcb0fe5b506615e3bcf6e63c4357a612b910765a/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:96f19de485a2925314f5020e85911fb447ff5fbef56e8c7c6927851b95533a1c", size = 94472, upload-time = "2025-08-05T16:42:53.59Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/fd772bf9078ae1001207d2df1eef3da05bea611a87dd0e8217989b2848fa/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e541c3ef484852ef36545f66209444c48b28661e864ccadb29daddb6a4b8e5f5", size = 92279, upload-time = "2025-08-05T16:42:54.632Z" }, + { url = "https://files.pythonhosted.org/packages/4f/41/affea7181592ab0ab560044632571a38edaf9130b84928177823fbf3176a/audioop_lts-0.2.2-cp313-cp313t-win32.whl", hash = "sha256:d5e73fa573e273e4f2e5ff96f9043858a5e9311e94ffefd88a3186a910c70917", size = 26568, upload-time = "2025-08-05T16:42:55.627Z" }, + { url = "https://files.pythonhosted.org/packages/28/2b/0372842877016641db8fc54d5c88596b542eec2f8f6c20a36fb6612bf9ee/audioop_lts-0.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9191d68659eda01e448188f60364c7763a7ca6653ed3f87ebb165822153a8547", size = 30942, upload-time = "2025-08-05T16:42:56.674Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/baf2b9cc7e96c179bb4a54f30fcd83e6ecb340031bde68f486403f943768/audioop_lts-0.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c174e322bb5783c099aaf87faeb240c8d210686b04bd61dfd05a8e5a83d88969", size = 24603, upload-time = "2025-08-05T16:42:57.571Z" }, + { url = "https://files.pythonhosted.org/packages/5c/73/413b5a2804091e2c7d5def1d618e4837f1cb82464e230f827226278556b7/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f9ee9b52f5f857fbaf9d605a360884f034c92c1c23021fb90b2e39b8e64bede6", size = 47104, upload-time = "2025-08-05T16:42:58.518Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/daa3308dc6593944410c2c68306a5e217f5c05b70a12e70228e7dd42dc5c/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:49ee1a41738a23e98d98b937a0638357a2477bc99e61b0f768a8f654f45d9b7a", size = 27754, upload-time = "2025-08-05T16:43:00.132Z" }, + { url = "https://files.pythonhosted.org/packages/4e/86/c2e0f627168fcf61781a8f72cab06b228fe1da4b9fa4ab39cfb791b5836b/audioop_lts-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b00be98ccd0fc123dcfad31d50030d25fcf31488cde9e61692029cd7394733b", size = 27332, upload-time = "2025-08-05T16:43:01.666Z" }, + { url = "https://files.pythonhosted.org/packages/c7/bd/35dce665255434f54e5307de39e31912a6f902d4572da7c37582809de14f/audioop_lts-0.2.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d2e0f9f7a69403e388894d4ca5ada5c47230716a03f2847cfc7bd1ecb589d6", size = 92396, upload-time = "2025-08-05T16:43:02.991Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d2/deeb9f51def1437b3afa35aeb729d577c04bcd89394cb56f9239a9f50b6f/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9b0b8a03ef474f56d1a842af1a2e01398b8f7654009823c6d9e0ecff4d5cfbf", size = 91811, upload-time = "2025-08-05T16:43:04.096Z" }, + { url = "https://files.pythonhosted.org/packages/76/3b/09f8b35b227cee28cc8231e296a82759ed80c1a08e349811d69773c48426/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2b267b70747d82125f1a021506565bdc5609a2b24bcb4773c16d79d2bb260bbd", size = 100483, upload-time = "2025-08-05T16:43:05.085Z" }, + { url = "https://files.pythonhosted.org/packages/0b/15/05b48a935cf3b130c248bfdbdea71ce6437f5394ee8533e0edd7cfd93d5e/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0337d658f9b81f4cd0fdb1f47635070cc084871a3d4646d9de74fdf4e7c3d24a", size = 103885, upload-time = "2025-08-05T16:43:06.197Z" }, + { url = "https://files.pythonhosted.org/packages/83/80/186b7fce6d35b68d3d739f228dc31d60b3412105854edb975aa155a58339/audioop_lts-0.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:167d3b62586faef8b6b2275c3218796b12621a60e43f7e9d5845d627b9c9b80e", size = 84899, upload-time = "2025-08-05T16:43:07.291Z" }, + { url = "https://files.pythonhosted.org/packages/49/89/c78cc5ac6cb5828f17514fb12966e299c850bc885e80f8ad94e38d450886/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0d9385e96f9f6da847f4d571ce3cb15b5091140edf3db97276872647ce37efd7", size = 89998, upload-time = "2025-08-05T16:43:08.335Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4b/6401888d0c010e586c2ca50fce4c903d70a6bb55928b16cfbdfd957a13da/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:48159d96962674eccdca9a3df280e864e8ac75e40a577cc97c5c42667ffabfc5", size = 99046, upload-time = "2025-08-05T16:43:09.367Z" }, + { url = "https://files.pythonhosted.org/packages/de/f8/c874ca9bb447dae0e2ef2e231f6c4c2b0c39e31ae684d2420b0f9e97ee68/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fefe5868cd082db1186f2837d64cfbfa78b548ea0d0543e9b28935ccce81ce9", size = 84843, upload-time = "2025-08-05T16:43:10.749Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c0/0323e66f3daebc13fd46b36b30c3be47e3fc4257eae44f1e77eb828c703f/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:58cf54380c3884fb49fdd37dfb7a772632b6701d28edd3e2904743c5e1773602", size = 94490, upload-time = "2025-08-05T16:43:12.131Z" }, + { url = "https://files.pythonhosted.org/packages/98/6b/acc7734ac02d95ab791c10c3f17ffa3584ccb9ac5c18fd771c638ed6d1f5/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:088327f00488cdeed296edd9215ca159f3a5a5034741465789cad403fcf4bec0", size = 92297, upload-time = "2025-08-05T16:43:13.139Z" }, + { url = "https://files.pythonhosted.org/packages/13/c3/c3dc3f564ce6877ecd2a05f8d751b9b27a8c320c2533a98b0c86349778d0/audioop_lts-0.2.2-cp314-cp314t-win32.whl", hash = "sha256:068aa17a38b4e0e7de771c62c60bbca2455924b67a8814f3b0dee92b5820c0b3", size = 27331, upload-time = "2025-08-05T16:43:14.19Z" }, + { url = "https://files.pythonhosted.org/packages/72/bb/b4608537e9ffcb86449091939d52d24a055216a36a8bf66b936af8c3e7ac/audioop_lts-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a5bf613e96f49712073de86f20dbdd4014ca18efd4d34ed18c75bd808337851b", size = 31697, upload-time = "2025-08-05T16:43:15.193Z" }, + { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" }, +] + +[[package]] +name = "authlib" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "joserfc" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/98/7d93f30d029643c0275dbc0bd6d5a6f670661ee6c9a94d93af7ab4887600/authlib-1.7.2.tar.gz", hash = "sha256:2cea25fefcd4e7173bdf1372c0afc265c8034b23a8cd5dcb6a9164b826c64231", size = 176511, upload-time = "2026-05-06T08:10:23.116Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/95/adcb68e20c34162e9135f370d6e31737719c2b6f94bc953fe7ed1f10fe21/authlib-1.7.2-py2.py3-none-any.whl", hash = "sha256:3e1faedc9d87e7d56a164eca3ccb6ace0d61b94abe83e92242f8dc8bba9b4a9f", size = 259548, upload-time = "2026-05-06T08:10:21.436Z" }, +] + +[[package]] +name = "beartype" +version = "0.22.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/94/1009e248bbfbab11397abca7193bea6626806be9a327d399810d523a07cb/beartype-0.22.9.tar.gz", hash = "sha256:8f82b54aa723a2848a56008d18875f91c1db02c32ef6a62319a002e3e25a975f", size = 1608866, upload-time = "2025-12-13T06:50:30.72Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/cc/18245721fa7747065ab478316c7fea7c74777d07f37ae60db2e84f8172e8/beartype-0.22.9-py3-none-any.whl", hash = "sha256:d16c9bbc61ea14637596c5f6fbff2ee99cbe3573e46a716401734ef50c3060c2", size = 1333658, upload-time = "2025-12-13T06:50:28.266Z" }, +] + +[[package]] +name = "brotli" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f7/16/c92ca344d646e71a43b8bb353f0a6490d7f6e06210f8554c8f874e454285/brotli-1.2.0.tar.gz", hash = "sha256:e310f77e41941c13340a95976fe66a8a95b01e783d430eeaf7a2f87e0a57dd0a", size = 7388632, upload-time = "2025-11-05T18:39:42.86Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/ee/b0a11ab2315c69bb9b45a2aaed022499c9c24a205c3a49c3513b541a7967/brotli-1.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:35d382625778834a7f3061b15423919aa03e4f5da34ac8e02c074e4b75ab4f84", size = 861543, upload-time = "2025-11-05T18:38:24.183Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2f/29c1459513cd35828e25531ebfcbf3e92a5e49f560b1777a9af7203eb46e/brotli-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a61c06b334bd99bc5ae84f1eeb36bfe01400264b3c352f968c6e30a10f9d08b", size = 444288, upload-time = "2025-11-05T18:38:25.139Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/feba03130d5fceadfa3a1bb102cb14650798c848b1df2a808356f939bb16/brotli-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acec55bb7c90f1dfc476126f9711a8e81c9af7fb617409a9ee2953115343f08d", size = 1528071, upload-time = "2025-11-05T18:38:26.081Z" }, + { url = "https://files.pythonhosted.org/packages/2b/38/f3abb554eee089bd15471057ba85f47e53a44a462cfce265d9bf7088eb09/brotli-1.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:260d3692396e1895c5034f204f0db022c056f9e2ac841593a4cf9426e2a3faca", size = 1626913, upload-time = "2025-11-05T18:38:27.284Z" }, + { url = "https://files.pythonhosted.org/packages/03/a7/03aa61fbc3c5cbf99b44d158665f9b0dd3d8059be16c460208d9e385c837/brotli-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:072e7624b1fc4d601036ab3f4f27942ef772887e876beff0301d261210bca97f", size = 1419762, upload-time = "2025-11-05T18:38:28.295Z" }, + { url = "https://files.pythonhosted.org/packages/21/1b/0374a89ee27d152a5069c356c96b93afd1b94eae83f1e004b57eb6ce2f10/brotli-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adedc4a67e15327dfdd04884873c6d5a01d3e3b6f61406f99b1ed4865a2f6d28", size = 1484494, upload-time = "2025-11-05T18:38:29.29Z" }, + { url = "https://files.pythonhosted.org/packages/cf/57/69d4fe84a67aef4f524dcd075c6eee868d7850e85bf01d778a857d8dbe0a/brotli-1.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7a47ce5c2288702e09dc22a44d0ee6152f2c7eda97b3c8482d826a1f3cfc7da7", size = 1593302, upload-time = "2025-11-05T18:38:30.639Z" }, + { url = "https://files.pythonhosted.org/packages/d5/3b/39e13ce78a8e9a621c5df3aeb5fd181fcc8caba8c48a194cd629771f6828/brotli-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:af43b8711a8264bb4e7d6d9a6d004c3a2019c04c01127a868709ec29962b6036", size = 1487913, upload-time = "2025-11-05T18:38:31.618Z" }, + { url = "https://files.pythonhosted.org/packages/62/28/4d00cb9bd76a6357a66fcd54b4b6d70288385584063f4b07884c1e7286ac/brotli-1.2.0-cp312-cp312-win32.whl", hash = "sha256:e99befa0b48f3cd293dafeacdd0d191804d105d279e0b387a32054c1180f3161", size = 334362, upload-time = "2025-11-05T18:38:32.939Z" }, + { url = "https://files.pythonhosted.org/packages/1c/4e/bc1dcac9498859d5e353c9b153627a3752868a9d5f05ce8dedd81a2354ab/brotli-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:b35c13ce241abdd44cb8ca70683f20c0c079728a36a996297adb5334adfc1c44", size = 369115, upload-time = "2025-11-05T18:38:33.765Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d4/4ad5432ac98c73096159d9ce7ffeb82d151c2ac84adcc6168e476bb54674/brotli-1.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e5825ba2c9998375530504578fd4d5d1059d09621a02065d1b6bfc41a8e05ab", size = 861523, upload-time = "2025-11-05T18:38:34.67Z" }, + { url = "https://files.pythonhosted.org/packages/91/9f/9cc5bd03ee68a85dc4bc89114f7067c056a3c14b3d95f171918c088bf88d/brotli-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0cf8c3b8ba93d496b2fae778039e2f5ecc7cff99df84df337ca31d8f2252896c", size = 444289, upload-time = "2025-11-05T18:38:35.6Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b6/fe84227c56a865d16a6614e2c4722864b380cb14b13f3e6bef441e73a85a/brotli-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8565e3cdc1808b1a34714b553b262c5de5fbda202285782173ec137fd13709f", size = 1528076, upload-time = "2025-11-05T18:38:36.639Z" }, + { url = "https://files.pythonhosted.org/packages/55/de/de4ae0aaca06c790371cf6e7ee93a024f6b4bb0568727da8c3de112e726c/brotli-1.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:26e8d3ecb0ee458a9804f47f21b74845cc823fd1bb19f02272be70774f56e2a6", size = 1626880, upload-time = "2025-11-05T18:38:37.623Z" }, + { url = "https://files.pythonhosted.org/packages/5f/16/a1b22cbea436642e071adcaf8d4b350a2ad02f5e0ad0da879a1be16188a0/brotli-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67a91c5187e1eec76a61625c77a6c8c785650f5b576ca732bd33ef58b0dff49c", size = 1419737, upload-time = "2025-11-05T18:38:38.729Z" }, + { url = "https://files.pythonhosted.org/packages/46/63/c968a97cbb3bdbf7f974ef5a6ab467a2879b82afbc5ffb65b8acbb744f95/brotli-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ecdb3b6dc36e6d6e14d3a1bdc6c1057c8cbf80db04031d566eb6080ce283a48", size = 1484440, upload-time = "2025-11-05T18:38:39.916Z" }, + { url = "https://files.pythonhosted.org/packages/06/9d/102c67ea5c9fc171f423e8399e585dabea29b5bc79b05572891e70013cdd/brotli-1.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3e1b35d56856f3ed326b140d3c6d9db91740f22e14b06e840fe4bb1923439a18", size = 1593313, upload-time = "2025-11-05T18:38:41.24Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/9526d14fa6b87bc827ba1755a8440e214ff90de03095cacd78a64abe2b7d/brotli-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54a50a9dad16b32136b2241ddea9e4df159b41247b2ce6aac0b3276a66a8f1e5", size = 1487945, upload-time = "2025-11-05T18:38:42.277Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e8/3fe1ffed70cbef83c5236166acaed7bb9c766509b157854c80e2f766b38c/brotli-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1b1d6a4efedd53671c793be6dd760fcf2107da3a52331ad9ea429edf0902f27a", size = 334368, upload-time = "2025-11-05T18:38:43.345Z" }, + { url = "https://files.pythonhosted.org/packages/ff/91/e739587be970a113b37b821eae8097aac5a48e5f0eca438c22e4c7dd8648/brotli-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:b63daa43d82f0cdabf98dee215b375b4058cce72871fd07934f179885aad16e8", size = 369116, upload-time = "2025-11-05T18:38:44.609Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/298c2ddf786bb7347a1cd71d63a347a79e5712a7c0cba9e3c3458ebd976f/brotli-1.2.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6c12dad5cd04530323e723787ff762bac749a7b256a5bece32b2243dd5c27b21", size = 863080, upload-time = "2025-11-05T18:38:45.503Z" }, + { url = "https://files.pythonhosted.org/packages/84/0c/aac98e286ba66868b2b3b50338ffbd85a35c7122e9531a73a37a29763d38/brotli-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3219bd9e69868e57183316ee19c84e03e8f8b5a1d1f2667e1aa8c2f91cb061ac", size = 445453, upload-time = "2025-11-05T18:38:46.433Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f1/0ca1f3f99ae300372635ab3fe2f7a79fa335fee3d874fa7f9e68575e0e62/brotli-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:963a08f3bebd8b75ac57661045402da15991468a621f014be54e50f53a58d19e", size = 1528168, upload-time = "2025-11-05T18:38:47.371Z" }, + { url = "https://files.pythonhosted.org/packages/d6/a6/2ebfc8f766d46df8d3e65b880a2e220732395e6d7dc312c1e1244b0f074a/brotli-1.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9322b9f8656782414b37e6af884146869d46ab85158201d82bab9abbcb971dc7", size = 1627098, upload-time = "2025-11-05T18:38:48.385Z" }, + { url = "https://files.pythonhosted.org/packages/f3/2f/0976d5b097ff8a22163b10617f76b2557f15f0f39d6a0fe1f02b1a53e92b/brotli-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf9cba6f5b78a2071ec6fb1e7bd39acf35071d90a81231d67e92d637776a6a63", size = 1419861, upload-time = "2025-11-05T18:38:49.372Z" }, + { url = "https://files.pythonhosted.org/packages/9c/97/d76df7176a2ce7616ff94c1fb72d307c9a30d2189fe877f3dd99af00ea5a/brotli-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7547369c4392b47d30a3467fe8c3330b4f2e0f7730e45e3103d7d636678a808b", size = 1484594, upload-time = "2025-11-05T18:38:50.655Z" }, + { url = "https://files.pythonhosted.org/packages/d3/93/14cf0b1216f43df5609f5b272050b0abd219e0b54ea80b47cef9867b45e7/brotli-1.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1530af5c3c275b8524f2e24841cbe2599d74462455e9bae5109e9ff42e9361", size = 1593455, upload-time = "2025-11-05T18:38:51.624Z" }, + { url = "https://files.pythonhosted.org/packages/b3/73/3183c9e41ca755713bdf2cc1d0810df742c09484e2e1ddd693bee53877c1/brotli-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2d085ded05278d1c7f65560aae97b3160aeb2ea2c0b3e26204856beccb60888", size = 1488164, upload-time = "2025-11-05T18:38:53.079Z" }, + { url = "https://files.pythonhosted.org/packages/64/6a/0c78d8f3a582859236482fd9fa86a65a60328a00983006bcf6d83b7b2253/brotli-1.2.0-cp314-cp314-win32.whl", hash = "sha256:832c115a020e463c2f67664560449a7bea26b0c1fdd690352addad6d0a08714d", size = 339280, upload-time = "2025-11-05T18:38:54.02Z" }, + { url = "https://files.pythonhosted.org/packages/f5/10/56978295c14794b2c12007b07f3e41ba26acda9257457d7085b0bb3bb90c/brotli-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e7c0af964e0b4e3412a0ebf341ea26ec767fa0b4cf81abb5e897c9338b5ad6a3", size = 375639, upload-time = "2025-11-05T18:38:55.67Z" }, +] + +[[package]] +name = "cachetools" +version = "7.1.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/55/af/861ebc2e318a5c3300e3eb63bc4d30f3d70a46d13b360093728ac0705eed/cachetools-7.1.6.tar.gz", hash = "sha256:c7a79e7f30ba9943c1cefd08cc36f006aaae086e017af9166f1d59d6170c47e1", size = 40572, upload-time = "2026-07-23T22:47:53.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/f2/2086ba18a925a73586c4d4e61d25f4a6058e56fd00d77ce8f1d361ab4c9b/cachetools-7.1.6-py3-none-any.whl", hash = "sha256:2c12e255780330af28b91bb7fb96cce4c766f04e38396b9a24510190a5827096", size = 16954, upload-time = "2026-07-23T22:47:52.397Z" }, +] + +[[package]] +name = "caio" +version = "0.9.25" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/88/b8527e1b00c1811db339a1df8bd1ae49d146fcea9d6a5c40e3a80aaeb38d/caio-0.9.25.tar.gz", hash = "sha256:16498e7f81d1d0f5a4c0ad3f2540e65fe25691376e0a5bd367f558067113ed10", size = 26781, upload-time = "2025-12-26T15:21:36.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/25/79c98ebe12df31548ba4eaf44db11b7cad6b3e7b4203718335620939083c/caio-0.9.25-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fb7ff95af4c31ad3f03179149aab61097a71fd85e05f89b4786de0359dffd044", size = 36983, upload-time = "2025-12-26T15:21:36.075Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2b/21288691f16d479945968a0a4f2856818c1c5be56881d51d4dac9b255d26/caio-0.9.25-cp312-cp312-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:97084e4e30dfa598449d874c4d8e0c8d5ea17d2f752ef5e48e150ff9d240cd64", size = 82012, upload-time = "2025-12-26T15:22:20.983Z" }, + { url = "https://files.pythonhosted.org/packages/03/c4/8a1b580875303500a9c12b9e0af58cb82e47f5bcf888c2457742a138273c/caio-0.9.25-cp312-cp312-manylinux_2_34_aarch64.whl", hash = "sha256:4fa69eba47e0f041b9d4f336e2ad40740681c43e686b18b191b6c5f4c5544bfb", size = 81502, upload-time = "2026-03-04T22:08:22.381Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/0fe770b8ffc8362c48134d1592d653a81a3d8748d764bec33864db36319d/caio-0.9.25-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:6bebf6f079f1341d19f7386db9b8b1f07e8cc15ae13bfdaff573371ba0575d69", size = 80200, upload-time = "2026-03-04T22:08:23.382Z" }, + { url = "https://files.pythonhosted.org/packages/31/57/5e6ff127e6f62c9f15d989560435c642144aa4210882f9494204bc892305/caio-0.9.25-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d6c2a3411af97762a2b03840c3cec2f7f728921ff8adda53d7ea2315a8563451", size = 36979, upload-time = "2025-12-26T15:21:35.484Z" }, + { url = "https://files.pythonhosted.org/packages/a3/9f/f21af50e72117eb528c422d4276cbac11fb941b1b812b182e0a9c70d19c5/caio-0.9.25-cp313-cp313-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0998210a4d5cd5cb565b32ccfe4e53d67303f868a76f212e002a8554692870e6", size = 81900, upload-time = "2025-12-26T15:22:21.919Z" }, + { url = "https://files.pythonhosted.org/packages/9c/12/c39ae2a4037cb10ad5eb3578eb4d5f8c1a2575c62bba675f3406b7ef0824/caio-0.9.25-cp313-cp313-manylinux_2_34_aarch64.whl", hash = "sha256:1a177d4777141b96f175fe2c37a3d96dec7911ed9ad5f02bac38aaa1c936611f", size = 81523, upload-time = "2026-03-04T22:08:25.187Z" }, + { url = "https://files.pythonhosted.org/packages/22/59/f8f2e950eb4f1a5a3883e198dca514b9d475415cb6cd7b78b9213a0dd45a/caio-0.9.25-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:9ed3cfb28c0e99fec5e208c934e5c157d0866aa9c32aa4dc5e9b6034af6286b7", size = 80243, upload-time = "2026-03-04T22:08:26.449Z" }, + { url = "https://files.pythonhosted.org/packages/69/ca/a08fdc7efdcc24e6a6131a93c85be1f204d41c58f474c42b0670af8c016b/caio-0.9.25-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fab6078b9348e883c80a5e14b382e6ad6aabbc4429ca034e76e730cf464269db", size = 36978, upload-time = "2025-12-26T15:21:41.055Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6c/d4d24f65e690213c097174d26eda6831f45f4734d9d036d81790a27e7b78/caio-0.9.25-cp314-cp314-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:44a6b58e52d488c75cfaa5ecaa404b2b41cc965e6c417e03251e868ecd5b6d77", size = 81832, upload-time = "2025-12-26T15:22:22.757Z" }, + { url = "https://files.pythonhosted.org/packages/87/a4/e534cf7d2d0e8d880e25dd61e8d921ffcfe15bd696734589826f5a2df727/caio-0.9.25-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:628a630eb7fb22381dd8e3c8ab7f59e854b9c806639811fc3f4310c6bd711d79", size = 81565, upload-time = "2026-03-04T22:08:27.483Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ed/bf81aeac1d290017e5e5ac3e880fd56ee15e50a6d0353986799d1bc5cfd5/caio-0.9.25-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:0ba16aa605ccb174665357fc729cf500679c2d94d5f1458a6f0d5ca48f2060a7", size = 80071, upload-time = "2026-03-04T22:08:28.751Z" }, + { url = "https://files.pythonhosted.org/packages/86/93/1f76c8d1bafe3b0614e06b2195784a3765bbf7b0a067661af9e2dd47fc33/caio-0.9.25-py3-none-any.whl", hash = "sha256:06c0bb02d6b929119b1cfbe1ca403c768b2013a369e2db46bfa2a5761cf82e40", size = 19087, upload-time = "2025-12-26T15:22:00.221Z" }, +] + [[package]] name = "certifi" version = "2026.4.22" @@ -158,6 +325,91 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" }, ] +[[package]] +name = "cffi" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/5f/ff100cae70ebe9d8df1c01a00e510e45d9adb5c1fdda84791b199141de97/cffi-2.1.0.tar.gz", hash = "sha256:efc1cdd798b1aaf39b4610bba7aad28c9bea9b910f25c784ccf9ec1fa719d1f9", size = 531036, upload-time = "2026-07-06T21:34:30.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/85/990925db5df586ec90beb97529c853497e7f85ba0234830447faf41c3057/cffi-2.1.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:df2b82571a1b30f58a87bf4e5a9e78d2b1eff6c6ce8fd3aa3757221f93f0863f", size = 184829, upload-time = "2026-07-06T21:32:44.324Z" }, + { url = "https://files.pythonhosted.org/packages/4b/92/e7bb136ad6b5352603732cf907ef862ca103f20f2031c1735a46300c20c9/cffi-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78474632761faa0fb96f30b1c928c84ebcf68713cbb80d15bab09dfe61640fde", size = 184728, upload-time = "2026-07-06T21:32:45.683Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c0/d1ec30ffb370f748f2fb54425972bfef9871e0132e82fb589c46b6676049/cffi-2.1.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:5972433ad71a9e46516584ef60a0fda12d9dc459938d1539c3ddecf9bdc1368d", size = 214815, upload-time = "2026-07-06T21:32:48.557Z" }, + { url = "https://files.pythonhosted.org/packages/1b/dc/5620cf930688be01f2d673804291de757a934c90b946dbdc3d84130c2ea4/cffi-2.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b6422532152adf4e59b110cb2808cee7a033800952f5c036b4af047ee43199e7", size = 222429, upload-time = "2026-07-06T21:32:49.848Z" }, + { url = "https://files.pythonhosted.org/packages/4b/a4/77b53abbf7a1e0beb9637edbef2a94d15f9c822f591e85d439ffd91519a6/cffi-2.1.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:46b1c8db8f6122420f32d02fffb924c2fe9bc772d228c7c711748fff56aabb2b", size = 210315, upload-time = "2026-07-06T21:32:51.221Z" }, + { url = "https://files.pythonhosted.org/packages/58/0c/f528df19cc94b675087324d4760d9e6d5bfae97d6217aa4fac43de4f5fcc/cffi-2.1.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9fafc5aa2e2a39aaf7f8cc0c1f044a9b07fca12e558dca53a3cc5c654ad67a7", size = 208859, upload-time = "2026-07-06T21:32:52.512Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/c9522a81c32132799a1972c39f5c5f8b4c8b9f00488a23feaa6c06f07741/cffi-2.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e9f50d192a3e525b15a75ab5114e442d83d657b7ec29182a991bc9a88fd3a66", size = 221844, upload-time = "2026-07-06T21:32:53.704Z" }, + { url = "https://files.pythonhosted.org/packages/6e/28/bd53988b9833e8f8ad539d26f4c07a6b3f6bcb1e9e02e7ca038250b3428d/cffi-2.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:98fff996e983a36d3aa2eca83af40c5821202e7e6f32d13ae94e3d2286f10cfe", size = 225287, upload-time = "2026-07-06T21:32:54.907Z" }, + { url = "https://files.pythonhosted.org/packages/79/99/0d0fd37f055224085f42bbb2c022d002e17dde4a97972822327b07d84101/cffi-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:379de10ce1ba048b1448599d1b37b24caee16309d1ac98d3982fc997f768700b", size = 223681, upload-time = "2026-07-06T21:32:56.329Z" }, + { url = "https://files.pythonhosted.org/packages/b0/80/c138990aa2a70b1a269f6e06348729836d733d6f970867943f61d367f8cc/cffi-2.1.0-cp312-cp312-win32.whl", hash = "sha256:9b8f0f26ca4e7513c534d351eca551947d053fac438f2a04ac96d882909b0d3a", size = 175269, upload-time = "2026-07-06T21:32:57.777Z" }, + { url = "https://files.pythonhosted.org/packages/a8/eb/f636456ff21a83fc13c032b58cc5dde061691546ac79efa284b2989b7982/cffi-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:c97f080ea627e2863524c5af3836e2270b5f5dfff1f104392b959f8df0c5d384", size = 185881, upload-time = "2026-07-06T21:32:59.253Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/400ea43e721727dca8a65c4521390e9196757caba4a45643acb2b63271b8/cffi-2.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:6d194185eabd279f1c05ebe3504265ddfc5ad2b58d0714f7db9f01da592e9eb6", size = 180088, upload-time = "2026-07-06T21:33:02.278Z" }, + { url = "https://files.pythonhosted.org/packages/96/88/a996879e2eeccb815f6e3a5967b12a308257412acec882039d386bd2aa7b/cffi-2.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:10537b1df4967ca26d21e5072d7d54188354483b91dc75058968d3f0cf13fbda", size = 194331, upload-time = "2026-07-06T21:33:03.697Z" }, + { url = "https://files.pythonhosted.org/packages/58/85/7ae00d5c8dd6266f4e944c3db630f3c5c9a98b61d469c714d848b1d8138a/cffi-2.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a95b05f9baf29b91171b3a8bd2020b028835243e7b0ff6bb23e2a3c228518b1b", size = 196966, upload-time = "2026-07-06T21:33:05.353Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e9/45c3a76ad8d43ad9261f4c95436da61128d3ca545d72b9612c0ab5be0b1c/cffi-2.1.0-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:15faec4adfff450819f3aee0e2e02c812de6edb88203aa58807955db2003472a", size = 184795, upload-time = "2026-07-06T21:33:06.699Z" }, + { url = "https://files.pythonhosted.org/packages/84/4c/82f132cb4418ee6d953d982b19191e87e2a6372c8a4ce36e50b69d6ade4a/cffi-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:716ff8ec22f20b4d988b12884086bcef0fc99737043e503f7a3935a6be99b1ea", size = 184746, upload-time = "2026-07-06T21:33:08.071Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1c/4ed5a0e5bdca6cbc275556de3328dd1b76fd0c11cc13c88fe66d1d8715f2/cffi-2.1.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:63960549e4f8dc41e31accb97b975abaecfc44c03e396c093a6436763c2ea7db", size = 214747, upload-time = "2026-07-06T21:33:09.671Z" }, + { url = "https://files.pythonhosted.org/packages/3a/a6/e879bb68cc23a2bc9ba8f4b7d8019f0c2694bad2ab6c4a3701d429439f58/cffi-2.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff067a8d8d880e7809e4ac88eb009bb848870115317b306666502ccad30b147f", size = 222392, upload-time = "2026-07-06T21:33:10.896Z" }, + { url = "https://files.pythonhosted.org/packages/88/f6/01890cfd63c08f8eb96a8319b0443690197d240a8bd6346048cf7bde9190/cffi-2.1.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3b926723c13eba9f81d2ef3820d63aeceec3b2d4639906047bf675cb8a7a500d", size = 210285, upload-time = "2026-07-06T21:33:12.251Z" }, + { url = "https://files.pythonhosted.org/packages/a6/cf/2b684132056f438567b61e19d690dd31cd0921ace051e0a458be6074369e/cffi-2.1.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:47ff3a8bfd8cb9da1af7524b965127095055654c177fcfc7578debcb015eecd0", size = 208801, upload-time = "2026-07-06T21:33:13.617Z" }, + { url = "https://files.pythonhosted.org/packages/6f/08/f2e7d62c460faae0926f2d6e423694aa409ced3bc1fe2927a0a6e5f05416/cffi-2.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:799416bae98336e400981ff6e532d67d5c709cfb30afb79865a1315f94b0e224", size = 221808, upload-time = "2026-07-06T21:33:15.466Z" }, + { url = "https://files.pythonhosted.org/packages/38/37/04f54b8e63a02f3d908332c9effbf8c366167c6f733ed8a3d4f79b7e2a1e/cffi-2.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:961be50688f7fba2fa65f63712d3b9b341a22311f5253460ce933f52f0de1c8c", size = 225241, upload-time = "2026-07-06T21:33:16.869Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d6/c72eecca433cd3e681c65ed313ab4835d9d4a379704d0f628a6a05f51c2e/cffi-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bf5c6cf48238b0eb4c086978c492ad1cbc22373fc5b2d7353b3a598ce6db887a", size = 223588, upload-time = "2026-07-06T21:33:18.239Z" }, + { url = "https://files.pythonhosted.org/packages/c6/4b/e706f67279140f92939da3475ad610df18bfd52d50f14953a8e5fede71d5/cffi-2.1.0-cp313-cp313-win32.whl", hash = "sha256:db3eb7d46527159a878ec3460e9d40615bc25ba337d477db681aea6e4f05c5d2", size = 175248, upload-time = "2026-07-06T21:33:19.799Z" }, + { url = "https://files.pythonhosted.org/packages/5a/47/59eb7975cb0e4ef0afa764ea945b29a5bb4537a9f771cb7d6c8a5dd74c95/cffi-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:8e74a6135550c4748af665b1b1118b6aab33b1fc6a16f9aff630af107c3b4512", size = 185717, upload-time = "2026-07-06T21:33:21.47Z" }, + { url = "https://files.pythonhosted.org/packages/5a/af/34fee85c48f8d94efc8597bc09470c9dd274c145f1c12e0fbc6ab6d38d74/cffi-2.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:2282cd5e38aa8accd03e99d1256af8411c84cdbee6a89d841b563fdbd1f3e50f", size = 180114, upload-time = "2026-07-06T21:33:22.515Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f0/81478e482afa03f6d18dc8f2afb5edc45b3080853b634b5ed91961be0998/cffi-2.1.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2117334c3af3bdcb9a88522b844a2bdb5efdc4f71c6c822df55486ae1c3347a", size = 194142, upload-time = "2026-07-06T21:33:23.657Z" }, + { url = "https://files.pythonhosted.org/packages/7d/95/8de304305cd9204974b0ca051b86d307cafca13aa575a0ef1b44d92c0d8c/cffi-2.1.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:702c436735fbe99d59ada02a1f65cfc0d31c0ee8b7290912f8fbc5cd1e4b16c3", size = 196819, upload-time = "2026-07-06T21:33:25.007Z" }, + { url = "https://files.pythonhosted.org/packages/20/71/7c8372d30e42415602ed9f268f7cfd66f1b855fed881ecd168bcb45dbc0b/cffi-2.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1ff3456eab0d889592d1936d6125bbfbc7ae4d3354a700f8bd80450a66445d4d", size = 184965, upload-time = "2026-07-06T21:33:26.605Z" }, + { url = "https://files.pythonhosted.org/packages/d6/5c/584e626835f0375c928176c04137c96927165cb8733cdb3150ec04e5ee5e/cffi-2.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c4165821e131d6d4ca444347c2b694e2311bcfa3fe5a861cc72968f28867beac", size = 184952, upload-time = "2026-07-06T21:33:27.823Z" }, + { url = "https://files.pythonhosted.org/packages/2e/d2/065fcae1c73979fac8e054462478d0ff8a29c40cdc2ed7ea5676a061df53/cffi-2.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:276f20fffd7b396e12516ba8edf9509210ac248cbbc5acbc39cd512f9f59ebe6", size = 222353, upload-time = "2026-07-06T21:33:29.178Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a5/e8bbb1ce5b3ac2f53ad6a10bde44318a5a8d99d4f4a000d44a6e39aeb3e4/cffi-2.1.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7d5980a3433d4b71a5e120f9dd551403d7824e31e2e67124fe2769c404c06913", size = 210051, upload-time = "2026-07-06T21:33:30.534Z" }, + { url = "https://files.pythonhosted.org/packages/28/ed/c127d3ac36e899c965e3361357c3befacd6578c03f40125183e41c3b219e/cffi-2.1.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6ca4919c6e4f89aa99c42510b42cf54596892c00b3f9077f6bdd1505e24b9c8d", size = 208630, upload-time = "2026-07-06T21:33:31.753Z" }, + { url = "https://files.pythonhosted.org/packages/cc/d7/97d3136f81db489ec8d1d67748c110d6c994268fd7528014aa9f2b085e4e/cffi-2.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d53d10f7da99ae46f7373b9150393e9c5eab9b224909982b43832668de4779f5", size = 221593, upload-time = "2026-07-06T21:33:33.044Z" }, + { url = "https://files.pythonhosted.org/packages/d3/27/93195977168ee63aed233a1a0993a2178798654d1f4bddcdd321d6fd3b21/cffi-2.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c351efb95e832a853a29361675f33a7ce53de1a109cd73fd47af0712213aa4ce", size = 225146, upload-time = "2026-07-06T21:33:34.224Z" }, + { url = "https://files.pythonhosted.org/packages/b3/c1/6dbd291ee2ae5a50a034aa057207081f545923bbf15dad4511e985aafff5/cffi-2.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf7c7a88e2bac086f06d14577332760bdeecc42bdec8ac4077f6260557d9326", size = 223240, upload-time = "2026-07-06T21:33:35.57Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6f/ade5ce9863a57992a6ea3d0d10d7e29b8749fc127204b3d493d667b2815f/cffi-2.1.0-cp314-cp314-win32.whl", hash = "sha256:1854b724d00f6654c742097d5387569021be12d3a0f770eae1df8f8acfcc6acd", size = 177723, upload-time = "2026-07-06T21:33:51.626Z" }, + { url = "https://files.pythonhosted.org/packages/41/de/92b9eeed4ae4a21d6fd9b2a2c8505cbed573299902ea73981cc13f7ff62c/cffi-2.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:1b96bfe2c4bd825681b7d311ad6d9b7280a091f43e8f63da5729638083cd3bfb", size = 187937, upload-time = "2026-07-06T21:33:53.403Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1a/cc6ae6c2913a03aab8898eee57963cf1035b8df5872ed8b9115fcc7e2be8/cffi-2.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:7d28dff1db6764108bc30788d85d61c876beff416d9a49cb9dd7c5a9f34f5804", size = 183001, upload-time = "2026-07-06T21:33:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/14/f0/134c00ce0779ec86dea2aa1aac69339c2741a8045072676763512363a2ea/cffi-2.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7ea6b3e2c4250ff1de21c630fe72d0f63eb95c2c32ffbf64a358cf4a8836d714", size = 188538, upload-time = "2026-07-06T21:33:36.792Z" }, + { url = "https://files.pythonhosted.org/packages/50/d8/3b86aba791cb610d24e8a3e1b2cd529e71fa15096b04e4d4e360049d4a4c/cffi-2.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6af371f3767faeffc6ac1ef57cdfd25844403e9d3f476c5537caee499de96376", size = 188230, upload-time = "2026-07-06T21:33:38.011Z" }, + { url = "https://files.pythonhosted.org/packages/14/d0/117dcd9209255ad8571fbc8c92ef32593a1d294dcec91ddc4e4db50606f2/cffi-2.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb4e8997a49aa2c08a3e43c9045d224448b8941d88e7ac163c7d383e560cbf98", size = 223899, upload-time = "2026-07-06T21:33:39.514Z" }, + { url = "https://files.pythonhosted.org/packages/b6/3d/f20f8b886b254e3ad10e15cd4186d3aed49f3e6a35ab37aab9f8f25f7c03/cffi-2.1.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bf01d8c84cbea96b944c73b22182e6c7c432b3475632b8111dbfdc95ddad6e13", size = 211652, upload-time = "2026-07-06T21:33:40.851Z" }, + { url = "https://files.pythonhosted.org/packages/28/3b/fad54de07260b93ddeef4b96d0131d57ea900675df1d410ae1deee52d7a6/cffi-2.1.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:33eb1ad83ebe8f313e0df035c406227d55a79456704a863fad9842136af5ad7d", size = 210755, upload-time = "2026-07-06T21:33:42.183Z" }, + { url = "https://files.pythonhosted.org/packages/cc/82/3d5c705acb7abbba9bbd7d79b8e62e0f25b6120eb7ae6ac49f1b721722fe/cffi-2.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ac0f1a2d0cfa7eea3f2aaf006ab6e70e8feeb16b75d65b7e5939982ca2f11056", size = 223933, upload-time = "2026-07-06T21:33:43.603Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d0/47e338384ab6b1004241002fa616301020cea4fc95f283506565d252f276/cffi-2.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c16914df9fb7f500e440e6875fa23ff5e0b31db01fa9c06af98d59a91f0dc2e4", size = 226749, upload-time = "2026-07-06T21:33:45.046Z" }, + { url = "https://files.pythonhosted.org/packages/70/25/65bd5b58ea4bfdfc15cde02cb5365f89ef8ab8b2adfb8fe5c4bd4233382f/cffi-2.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5ecbd0499275d57506d397eebe1981cee87b47fcd9ef5c22cab7ed7644a39a94", size = 225703, upload-time = "2026-07-06T21:33:46.374Z" }, + { url = "https://files.pythonhosted.org/packages/dc/78/aa01ac599a8a4322533d45a1f9bc93b338276d2d59dabbe7c6d92a775c81/cffi-2.1.0-cp314-cp314t-win32.whl", hash = "sha256:7d034dcffa09e9a46c93fa3a3be402096cb5354ac6e41ab8e5cc9cd8b642ad76", size = 182857, upload-time = "2026-07-06T21:33:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/b9/26/d00496b22de4d4228f32dde94ad996f350c8aad676d63bcca0743c8dea4d/cffi-2.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0582a58f3051372229ca8e7f5f589f9e5632678208d8636fea3676711fdf7fe5", size = 194065, upload-time = "2026-07-06T21:33:48.953Z" }, + { url = "https://files.pythonhosted.org/packages/d5/dd/0c7dbf815a579ff005008a2d815a55d6bb047c349eef536d9dc53d3f0a8d/cffi-2.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:510aeeeac94811b138077451da1fb18b308a5feab47dd2b603af55804155e1c8", size = 186404, upload-time = "2026-07-06T21:33:50.309Z" }, + { url = "https://files.pythonhosted.org/packages/55/c7/8c8c50cb11c6750051daf12164098a9a6f027ac4356967fd4d800a07f242/cffi-2.1.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:2e9dabb9abcb7ad15938c7196ad5c1718a4e6d33cc79b4c0209bdb64c4a54a5c", size = 194121, upload-time = "2026-07-06T21:33:56.109Z" }, + { url = "https://files.pythonhosted.org/packages/99/e2/67680bf19a6b60d2bb7ff83baefa2a4c3d2d7dc0f3277034b802e1fc504c/cffi-2.1.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:37f525a7e7e50c017fdebe58b787be310ad59357ae43a053943a6e1a6c526001", size = 196820, upload-time = "2026-07-06T21:33:57.288Z" }, + { url = "https://files.pythonhosted.org/packages/ed/da/4bbe583a3b3a5c8c60892124fe17f3fa3656523faf0d3484eae90f091853/cffi-2.1.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:95f2954c2c9473d892eca6e0409f3568b37ab62a8eedb122461f73cc273476e3", size = 184936, upload-time = "2026-07-06T21:33:58.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/4b/1f4c36ab273980d7aa75bb126ea4f8971f24a96108acad3a0a084028c57b/cffi-2.1.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:cdf2448aab5f661c9315308ec8b93f4e8a1a67a3c733f8631067a2b67d5913dc", size = 185045, upload-time = "2026-07-06T21:34:00.085Z" }, + { url = "https://files.pythonhosted.org/packages/ef/c3/ad299dc38f3583f8d916b299f028af418a9ec98bc695fcbebeae7420691c/cffi-2.1.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:90bec57cf82089383bd06a605b3eb8daebf7e5a668520beaf6e327a83a947699", size = 222342, upload-time = "2026-07-06T21:34:01.814Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d8/df4543cc087245044ed02ef3ad8e0a26619d0075ac7a77a12dc81177851b/cffi-2.1.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6274dcb2d15cef48daa73ed1be5a40d501d74dccd0cd6db364776d12cb6ba022", size = 210073, upload-time = "2026-07-06T21:34:03.255Z" }, + { url = "https://files.pythonhosted.org/packages/2c/0e/fac738d73728c6cea2a88a2883dca54892496cbba88a1dc1f2909cb8a6f5/cffi-2.1.0-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b71d409cccee78310ab5dec549aed052aaea483346e282c7b02362596e01bb0", size = 208551, upload-time = "2026-07-06T21:34:04.433Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3f/0b04a700dd64f465c93020253a793a82c9b4dff9961f48facd0df945d9b8/cffi-2.1.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7d3538f9c0e50670f4deb93dbb696576e60590369cae2faf7de681e597a8a1f1", size = 221649, upload-time = "2026-07-06T21:34:06.157Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7c/b7379a5704c79eda57ce075869ba70a0368d1c850f803b3c0d078d39dcaf/cffi-2.1.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:8f9ec95b8a043d3dfbc74d9abc6f7baf524dd27a8dc160b0a32ff9cdab650c28", size = 225203, upload-time = "2026-07-06T21:34:07.489Z" }, + { url = "https://files.pythonhosted.org/packages/5a/02/d5e6c43ea85c41bda2a184a3418f195fe7cf602967a8d2b94e085b83deef/cffi-2.1.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:af5e2915d41fe6c961694d7bfdc8562942638200f3ce2765dfb8b745cf997629", size = 223263, upload-time = "2026-07-06T21:34:08.712Z" }, + { url = "https://files.pythonhosted.org/packages/2c/d8/772b8259bf75749adffb1c546828978381fb516f60cf701f6c83daf60c85/cffi-2.1.0-cp315-cp315-win32.whl", hash = "sha256:0a42c688d19fca6e095a53c6a6e2295a5b050a8b289f109adab02a9e61a25de6", size = 177696, upload-time = "2026-07-06T21:34:26.355Z" }, + { url = "https://files.pythonhosted.org/packages/2f/dd/afa2191fc6d57fedd26e5844a2fe2fcc0bbfa00961bbaa5a41e4921e7cca/cffi-2.1.0-cp315-cp315-win_amd64.whl", hash = "sha256:bccbbb5ee76a61f9d99b5bf3846a51d7fca4b6a732fe46f89295610edaf41853", size = 187914, upload-time = "2026-07-06T21:34:27.58Z" }, + { url = "https://files.pythonhosted.org/packages/05/ef/6cd4f8c671517162379dc79cfae5aea9106bc38abb89628d5c16adf6a838/cffi-2.1.0-cp315-cp315-win_arm64.whl", hash = "sha256:8d35c139744adb3e727cd51b1a18324bbe44b8bd41bf8322bca4d41289f48eda", size = 183004, upload-time = "2026-07-06T21:34:28.905Z" }, + { url = "https://files.pythonhosted.org/packages/11/b6/12fc55092817a5faa26fb8c40c7f9d662e11a46ee248c137aafc42517d92/cffi-2.1.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f9912624a0c0b834b7520d7769b3644453aabc0a7e1c839da7359f050750e9bc", size = 188378, upload-time = "2026-07-06T21:34:09.926Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2e/cdac88979f295fde5daa69622c7d2111e56e7ceb94f211357fbe452339e4/cffi-2.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:df92f2aba50eb4d96718b68ef76f2e57a57b54f2fa62333496d16c6d585a85ca", size = 188319, upload-time = "2026-07-06T21:34:11.101Z" }, + { url = "https://files.pythonhosted.org/packages/e0/27/1d0b408497e41a74795af122d7b603c418c5fed0171450f899afd04e594f/cffi-2.1.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0520e1f4c35f44e209cbbb421b67eec42e6a157f59444dfb6058874ff3610e5d", size = 223904, upload-time = "2026-07-06T21:34:12.606Z" }, + { url = "https://files.pythonhosted.org/packages/8b/31/e115c985105dd7ffb32444505f18ceb874bb42d992af05d5dced7ecf1980/cffi-2.1.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3681e031db29958a7502f5c0c9d6bbc4c36cb20f7b104086fa642d1799631ff8", size = 211554, upload-time = "2026-07-06T21:34:13.987Z" }, + { url = "https://files.pythonhosted.org/packages/5a/67/9e6e09409336d9e515c58367e7cfcf4f89df06ad25252675595a58eb59d5/cffi-2.1.0-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:762f99479dcb369f60ab9017ad4ab97a36a1dd7c1ee5a3b15db0f4b8659120cd", size = 210795, upload-time = "2026-07-06T21:34:15.972Z" }, + { url = "https://files.pythonhosted.org/packages/19/e5/d3cc82a4a0be7902af279c04181ad038449c096734464a5ae1de3e1401bd/cffi-2.1.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0611e7ebf90573a535ebdc33ae9da222d037853983e13359f580fab781ca017f", size = 223843, upload-time = "2026-07-06T21:34:17.509Z" }, + { url = "https://files.pythonhosted.org/packages/b9/65/b434abc97ce7cecc2c640fde160507c0ecc7e21544b483ba3325d2e2ea17/cffi-2.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:86cf8755a791f72c85dc287128cc62d4f24d392e3f1e15837245623f4a33cccc", size = 226773, upload-time = "2026-07-06T21:34:19.05Z" }, + { url = "https://files.pythonhosted.org/packages/b5/9f/d4dc66ca651eb1145a133314cda721abf13cfac3d28c4a0402263ae6ad75/cffi-2.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:ba00f661f8ba35d075c937174e27c2c421cec3942fd2e0ea3e66996757c0fdd9", size = 225719, upload-time = "2026-07-06T21:34:20.576Z" }, + { url = "https://files.pythonhosted.org/packages/68/5a/e536c528bc8057496c360c0978559a2dc45653f89dd6151078aa7d8fca1a/cffi-2.1.0-cp315-cp315t-win32.whl", hash = "sha256:cb96698e3c7413d906ce83f8ffd245ec1bd94707541f299d0ce4d6b0193e982b", size = 182760, upload-time = "2026-07-06T21:34:22.059Z" }, + { url = "https://files.pythonhosted.org/packages/d3/0b/0ffe8b82d3875bced5fa1e7986a7a46b748262a40ab7f60b475eb9fb1bb3/cffi-2.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f146d154428a2523f9cc7936c02353c2459b8f6cf07d3cd1ee1c0a611109c5d5", size = 193769, upload-time = "2026-07-06T21:34:23.589Z" }, + { url = "https://files.pythonhosted.org/packages/a0/17/1073b53b68c9b5ca6914adf5f8bf55aacc2d3be102418c90700160ea8605/cffi-2.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:cbb7640ce37159548d2147b5b8c241f962143d4c71231431820783f4dc78f210", size = 186405, upload-time = "2026-07-06T21:34:24.857Z" }, +] + [[package]] name = "charset-normalizer" version = "3.4.7" @@ -252,6 +504,71 @@ 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 = "cryptography" +version = "49.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/99/d1c90d6041656cc6ee229dc99cd67fd0cd5aec3c5f7d72fffc27cc750054/cryptography-49.0.0.tar.gz", hash = "sha256:f89660a348f4f78a92366240a61404e337586ef7f5909a2fef59ca88ef505493", size = 854345, upload-time = "2026-06-12T20:02:30.512Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/22/adf66990e63584a68dfb50c24f48a125c07b1699899381c8151e63ed458c/cryptography-49.0.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:966fe0e9c67490071f14c0d2b1cb2dfb3023c5ce39457343931415f08382f2db", size = 4032100, upload-time = "2026-06-12T20:02:32.143Z" }, + { url = "https://files.pythonhosted.org/packages/09/41/3797cfaf69cae04a13ee78ebd83f0678d9c02b4779d21ce24445326f1a69/cryptography-49.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:36d1709f992593689b45bda411498d62c6e365f2ca00b84657d4dadd24de16db", size = 4692978, upload-time = "2026-06-12T20:01:21.305Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8b/43011f7ebe515a8aa20d61f290a326cd890c2e738e16e59eaff8d9c3a412/cryptography-49.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0e959b578856a3924bc0cbb710fc12c387b9412a951389f3ca61704a9e25f325", size = 4716422, upload-time = "2026-06-12T20:01:48.566Z" }, + { url = "https://files.pythonhosted.org/packages/4a/91/01ce7303a4579e6d3a6abef01bd322848e9ea7a219adcabc5048b9033571/cryptography-49.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:53ecee2e23f7169b6117e99fc8a944e5e50f79e69758a83b52a00cb98ab2b2d2", size = 4700503, upload-time = "2026-06-12T20:02:47.091Z" }, + { url = "https://files.pythonhosted.org/packages/62/99/a2c95cf8293f07491e9e27c20cc4dcd18176d944e674679adeb1d0173fd6/cryptography-49.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2eda353d8a27bcbcaa4cbed18994a74ab4d19a2ca897db188ea269ab9b71419b", size = 5309779, upload-time = "2026-06-12T20:02:08.987Z" }, + { url = "https://files.pythonhosted.org/packages/20/2c/0622f20ff02b2ef32558733443805dc82fd4c275be01b2d19d14676f3a1b/cryptography-49.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2afe9051da7ae7bd5905da5a949280c7d2bb75682e188f650a9d0f2756b834c6", size = 4749683, upload-time = "2026-06-12T20:02:03.335Z" }, + { url = "https://files.pythonhosted.org/packages/a3/5b/c5246635d5fd3b64e0d45ae10e99fd32fe9676a79915ccfe5a61ba9af1a5/cryptography-49.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:0b82e28ee398a386f0807bba7884d30f25218855690f45115831bcce5d90822c", size = 4337874, upload-time = "2026-06-12T20:02:54.323Z" }, + { url = "https://files.pythonhosted.org/packages/6d/88/05563c7fe2e914e87d1a536d06fe83e66b4e1d95cb593e05aea375531da8/cryptography-49.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ccac2bfebc306b862133e3bb71f3f6ee8bb525240089b2d952e4144b3a6d5da7", size = 4700283, upload-time = "2026-06-12T20:01:34.822Z" }, + { url = "https://files.pythonhosted.org/packages/c4/b6/d7696e4e890d6ae1469935164c9e5215c557671cb78d6e3f458ccceaa632/cryptography-49.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d0527ce944105f257f605a827d6ebead966c752038b6e8656abb9c5edee6fc68", size = 5265844, upload-time = "2026-06-12T20:01:24.09Z" }, + { url = "https://files.pythonhosted.org/packages/a9/3c/f3ad17eecc1a57b0ba236dc01f90e783c51f4a2f35f64777cc4f47a184b2/cryptography-49.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:cbc77da8c523d5abd028635ba850a6966fcee2c82e2bf65a41d1d8afe0f98be9", size = 4749290, upload-time = "2026-06-12T20:01:30.848Z" }, + { url = "https://files.pythonhosted.org/packages/4f/01/339573cf1023163a400b0b5d16f6d507de413b9f60be6fd1b77feeaf6737/cryptography-49.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b87e65d263b3e5d3bb92a57e2a6638e2f31110fa7aa890c7b2dbba42248d0a3f", size = 4834612, upload-time = "2026-06-12T20:01:29.246Z" }, + { url = "https://files.pythonhosted.org/packages/71/fd/577302e213a1be9468f92d1afef66fcf1ef83d516819d9992ca547f592bd/cryptography-49.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:66ec79c3904820572d7e987abdf304281f141d37ad9a489b8e97066e7b9b6459", size = 4980804, upload-time = "2026-06-12T20:01:42.853Z" }, + { url = "https://files.pythonhosted.org/packages/1f/09/f42b1d190c5ba75f72062a387f8030d1d75f6ab035788f1d9c4b01de6525/cryptography-49.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:e5dfc1e64de5677cec922ffa8da89c546d0415bf6efdf081842e5d44c84e1f0e", size = 3810026, upload-time = "2026-06-12T20:02:39.262Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9e/db72b3ae7fc9cfad53e630e56c6ae83b9b6ff0bf3718ffb8012d20b3aabf/cryptography-49.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:73a205dce83953d131a4aa1e0fd917a2fd1c5b1eef251e9d7152efefcbf5caf7", size = 4013892, upload-time = "2026-06-12T20:02:10.735Z" }, + { url = "https://files.pythonhosted.org/packages/86/12/c48a424f38db03027be9f7ed5c7dc5de9933dbee992865f98b13727a009d/cryptography-49.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:196ecd6a36e4e9aa10270393bb98d8df88fccee0bf1e5128b91ae4eb4375896d", size = 4678835, upload-time = "2026-06-12T20:02:48.743Z" }, + { url = "https://files.pythonhosted.org/packages/68/28/8a3ad4653662c93fc44dc4e5d8fd374c25c42e07b34bbfbadf49cf57a5a8/cryptography-49.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7abcee80084cda3f7691f3eb1ce480d8df49cec637b429aa35986c1de71738aa", size = 4697239, upload-time = "2026-06-12T20:02:56.03Z" }, + { url = "https://files.pythonhosted.org/packages/a8/b2/2193fc74f81aee4f9b62733133b73b5176718932ed8f2e4b03fa040480a6/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:4ae387c9cb68ea569ca17e490d66d8142b81c3cc814bf179974b7d146e490bbb", size = 4685593, upload-time = "2026-06-12T20:02:50.666Z" }, + { url = "https://files.pythonhosted.org/packages/47/f1/1d3eaa243bfc5de4a187b22aa8c048b3e4980bfbe830ac46e6bac2e66947/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:f37d847238971164fdbc68ade6f6574aecc9c0af714190e2083429ff68f4ce9d", size = 5289961, upload-time = "2026-06-12T20:01:46.468Z" }, + { url = "https://files.pythonhosted.org/packages/58/39/2d51306721330c486495853eda1c567880ff036de15a14c4b74f399934af/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:c2bc30226390d60ea19d9f82b19db005fe0452154a23c1c410c12ea801e43561", size = 4731145, upload-time = "2026-06-12T20:02:16.832Z" }, + { url = "https://files.pythonhosted.org/packages/17/50/983e838c7fd0d87fd8c969bcdd328edaf5f756e38df5281637424c155873/cryptography-49.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:07cab27cc7b7e0fd28e5e26bb9eeedde5c135c868b46de4a27845abe94af6122", size = 4321719, upload-time = "2026-06-12T20:02:52.611Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f5/8f571d7e27c55bce9f76f026143bcb1e040a4233149ecca0bea5fa5dd5f7/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:b20133d204d2bb56ba047642199603876c872026ca53e79c35b83772ab2cc505", size = 4685209, upload-time = "2026-06-12T20:02:07.282Z" }, + { url = "https://files.pythonhosted.org/packages/e7/84/0e27016a6fc5a0886f797018b26aa42f40c09a82332bff77822a451deaaa/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b970c6da94d5bb18629db453d14f2a1300f6bf59b61e9b82377931ef95504866", size = 5246285, upload-time = "2026-06-12T20:01:32.439Z" }, + { url = "https://files.pythonhosted.org/packages/11/2d/5e1fb307cb5931881516b464c98774b3f2c36b5d4bb9a2830253cf553cad/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:d8ecde755e2e91bf773fc94e8c9d730cd7f2007004cb492263a794ec3899a1c8", size = 4730441, upload-time = "2026-06-12T20:02:01.469Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c0/bff5a02ee731d207d6a1ed51732549d8c53d2bc8da1d10ec6f2844201d68/cryptography-49.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e3fb64c420688e5319ae25113a354015abbd8dffbfbc41781a1ea66fc7622ac3", size = 4815869, upload-time = "2026-06-12T20:01:36.574Z" }, + { url = "https://files.pythonhosted.org/packages/b9/26/814681d14248d95d73d5c3eea0c39a94eb8302df966f670a2c60de90974b/cryptography-49.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32703d93296f5c1f4b53349ad3a250c2cae0fdecd3a3dd5d47e616d8d616af27", size = 4960948, upload-time = "2026-06-12T20:02:18.688Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fe/93ecac273d3738939d023612ad12cca9a3740a5345d69fda04134c43fd96/cryptography-49.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:33cd0565932807baddb67b96dbee92f2c374b5c89dee09fd74079aeb8c8dba61", size = 3799153, upload-time = "2026-06-12T20:01:39.059Z" }, + { url = "https://files.pythonhosted.org/packages/19/2a/5bb823f5bedcf80718cea7fbc95ec5515cca3769633c4b01a32be7f30e7c/cryptography-49.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ec5e529fb80935c94fe7b729f9972b50e351a0e6b50aa294fd5cabb109fcc29a", size = 4025947, upload-time = "2026-06-12T20:01:25.745Z" }, + { url = "https://files.pythonhosted.org/packages/3d/df/40577043ca124e17012f408ddddaeb213b856336ac82ddb3bc915f39e29f/cryptography-49.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f78ff2c9ed8dc2d036b0f4d640e22522213d047c1b14e61205a7e55c80a494d4", size = 4692429, upload-time = "2026-06-12T20:01:53.628Z" }, + { url = "https://files.pythonhosted.org/packages/2c/99/2d13299eb3dd27b02dcfaafcc91d6b5cb3329f7cbd6d8f51921acd566c1a/cryptography-49.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:35b151772baff2c74cba7fa290ceaff4c3b11c0c881eb93eb5dbc05a7cfbba18", size = 4700968, upload-time = "2026-06-12T20:02:45.383Z" }, + { url = "https://files.pythonhosted.org/packages/a5/4d/9c0cd02f95e2602dd5e563da149ee0830abef3537be8b34dc56281ebe27a/cryptography-49.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0f21641cf4b30fca7aee061ced0ec7ad7b073518088b7c9969a297c0ae796c69", size = 4697758, upload-time = "2026-06-12T20:01:41.13Z" }, + { url = "https://files.pythonhosted.org/packages/24/01/186c825898477d77e2324d5360fefe622ff1d8d1963ec0554e2cada8ec77/cryptography-49.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9e82dcc8e56052715fb18b2429e3bca4823b1629136a2084fc45a9a5cecb9b64", size = 5298863, upload-time = "2026-06-12T20:02:24.579Z" }, + { url = "https://files.pythonhosted.org/packages/b8/7b/62cbbab75d0659865bf0273790031544a0b16c8072d258f9428dcd8190dc/cryptography-49.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6f2debedf9ca60cf1d5bd466475638af5130f89965605cd818484d19987d3a21", size = 4735983, upload-time = "2026-06-12T20:01:50.14Z" }, + { url = "https://files.pythonhosted.org/packages/6c/72/3e798c064bc39e471008075d0f9bc9daf77a80879c092e4a8e170c585ed4/cryptography-49.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:8c25ceb16df5b9435f3f6a9829204985b0e0cbee3b48aacd432c7d2c850b44d9", size = 4334173, upload-time = "2026-06-12T20:01:44.743Z" }, + { url = "https://files.pythonhosted.org/packages/f0/ee/6fca21d1ac73e06f8bef71940abfd4d2f6472b4bca284d770f32bd4086f6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:28d8b15e6275f12c8a207dc309dfa957903c927d08d0cc937ee3f63f200693cc", size = 4697298, upload-time = "2026-06-12T20:02:20.918Z" }, + { url = "https://files.pythonhosted.org/packages/67/d0/a5fcd3515f0bae49a7b6d0413cc1bdccdcc1fc0047037a0d480642cdc5d6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:6fc361c34fb6aac015ce19435876635e5c6d21db31998b0920f675f131e043b8", size = 5254338, upload-time = "2026-06-12T20:02:22.737Z" }, + { url = "https://files.pythonhosted.org/packages/a0/84/84fe36f19caf857d61cb7fc9c63035a47ffabd84ea12d1d393148efa3615/cryptography-49.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:2400ef9c9e2299a25614eb1dea3db54a69b1349efd043bfac9c67630d136df36", size = 4735650, upload-time = "2026-06-12T20:02:41.389Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a0/db537264e234f7273a73ec020873d6d6b39dfd8a53db78b550ca8320440e/cryptography-49.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:67e1d20ad9ef3a563c59ef22e7a8a0b8210bd26604369ea4a30a7c66aefe504e", size = 4834820, upload-time = "2026-06-12T20:01:51.847Z" }, + { url = "https://files.pythonhosted.org/packages/93/77/8df9eb486495979bccecd1062e2eaf435250e84437040295b57d09048b0b/cryptography-49.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:42b0684e0e40cf26122427802486f6d93aea593612603a94fbf260c7eb1e9c1b", size = 4967968, upload-time = "2026-06-12T20:02:12.524Z" }, + { url = "https://files.pythonhosted.org/packages/c2/e6/f60198ea8d9dfa15fff9ed4ca02ce362f6eadd9ba757dcc50634c4257b63/cryptography-49.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:026ac7423e6fa66872d3bf889be5974507da3944f866f704fa200eadacd00001", size = 3785547, upload-time = "2026-06-12T20:02:26.847Z" }, +] + +[[package]] +name = "cyclopts" +version = "4.22.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "docstring-parser" }, + { name = "rich" }, + { name = "rich-rst" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/98/ca72a91d5c25a2ae1baf19d27b31f12288cb9d8a3168b65b3cd54d40d277/cyclopts-4.22.2.tar.gz", hash = "sha256:0721e90e7209885e78f7637cfba255c12e89206b633e35d185305e349ba20ecd", size = 194511, upload-time = "2026-07-24T20:53:08.739Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/75/a11bfb5045e58b4ef69337b848985918e829fe9a90572a761d17c1a992f5/cyclopts-4.22.2-py3-none-any.whl", hash = "sha256:9c2cdf6a621886cd0af631a67437eb7d0084f33f9e8fba2d2562a1aecf75f2ff", size = 233906, upload-time = "2026-07-24T20:53:07.064Z" }, +] + [[package]] name = "distro" version = "1.9.0" @@ -261,6 +578,142 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, ] +[[package]] +name = "dnspython" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" }, +] + +[[package]] +name = "docker" +version = "7.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "requests" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/88/7f/731ff914b0255d3d065f45fd4e626d4b8c95dbcbaada049f337a6ac16410/docker-7.2.0.tar.gz", hash = "sha256:cebb93773d334f778e023a7ee352a8d6e13ab1bd3b863a4d4a59dec897df43ac", size = 118731, upload-time = "2026-07-09T14:53:46.39Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/23/529140fe1aab80fc6992f93a706deec709140a6397439139a054e1515c45/docker-7.2.0-py3-none-any.whl", hash = "sha256:a3f45fdeb9165e2d25d9a1d02ddf3bc70fb572cf5ebbf9b58558c22caf29b71f", size = 148775, upload-time = "2026-07-09T14:53:45.224Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", hash = "sha256:292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015", size = 29341, upload-time = "2026-04-14T04:09:19.867Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" }, +] + +[[package]] +name = "email-validator" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dnspython" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "fastapi" +version = "0.140.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/29/a4/7e4dc8867a5c7f53355655314f3007e4a1f18b3ada60d49b6509b303fe29/fastapi-0.140.9.tar.gz", hash = "sha256:fadc1dae3671c34a542a34b14e3cec92ebe774b9f6ae6ae8da7339a9f0e9c287", size = 422649, upload-time = "2026-07-28T12:38:57.359Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/ea/113074d315b02e94ea452b0a0e0397d91d7791000215b098c03b68c2d471/fastapi-0.140.9-py3-none-any.whl", hash = "sha256:313ab1c00f02d1a2255573d456d2cb519e87826d3eb82ce75ea2da2e983bcb64", size = 131098, upload-time = "2026-07-28T12:38:55.736Z" }, +] + +[[package]] +name = "fastmcp" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastmcp-slim", extra = ["client", "server"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/23/14/c1ffb91b7d1fece86c81e1f9df5474f30fd97e4cdaa398814bbbeee88568/fastmcp-3.4.5.tar.gz", hash = "sha256:a95f2bc876bef42e8b50f7872f24f3f2fe3b1d37408c734e8b9d9e03014b72d3", size = 28800521, upload-time = "2026-07-27T19:20:01.231Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/4f/73450a436c963c0382d15a882fc5d08f15aadc329194df1b54495a7c8383/fastmcp-3.4.5-py3-none-any.whl", hash = "sha256:5d3d438eb2917e63e6faf53e8cb8fe26d887ec3232f848093a4eecad7fa34861", size = 8017, upload-time = "2026-07-27T19:19:57.942Z" }, +] + +[[package]] +name = "fastmcp-slim" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pydantic", extra = ["email"] }, + { name = "pydantic-settings" }, + { name = "python-dotenv" }, + { name = "rich" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/81/1d/f3e271fbcd01ce01a4cf623b336d8e1305c192aa5d5e8e0223b7167462e9/fastmcp_slim-3.4.5.tar.gz", hash = "sha256:5badc3bceee61f61297eeb9494f499325f3ce1cafabf4611b31f6c3e9d7dff59", size = 591622, upload-time = "2026-07-27T19:15:19.455Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/3b/16d8aa8224094519f30b078138e725b8a731bf0a13f1f850e58b5f9b3cc4/fastmcp_slim-3.4.5-py3-none-any.whl", hash = "sha256:bc31217827c4999812543c83ee95ed9a47f3ed1e3fd0bd4f64371e375b748eca", size = 766478, upload-time = "2026-07-27T19:15:18.015Z" }, +] + +[package.optional-dependencies] +client = [ + { name = "authlib" }, + { name = "exceptiongroup" }, + { name = "httpx" }, + { name = "mcp" }, + { name = "opentelemetry-api" }, + { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] }, + { name = "starlette" }, +] +server = [ + { name = "authlib" }, + { name = "cyclopts" }, + { name = "exceptiongroup" }, + { name = "griffelib" }, + { name = "httpx" }, + { name = "joserfc" }, + { name = "jsonref" }, + { name = "jsonschema-path" }, + { name = "mcp" }, + { name = "openapi-pydantic" }, + { name = "opentelemetry-api" }, + { name = "packaging" }, + { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] }, + { name = "pyperclip" }, + { name = "python-multipart" }, + { name = "pyyaml" }, + { name = "starlette" }, + { name = "uncalled-for" }, + { name = "uvicorn" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + [[package]] name = "fastuuid" version = "0.14.0" @@ -409,6 +862,79 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/0c/043d5e551459da400957a1395e0febbf771446ff34291afcbe3d8be2a279/fsspec-2026.4.0-py3-none-any.whl", hash = "sha256:11ef7bb35dab8a394fde6e608221d5cf3e8499401c249bebaeaad760a1a8dec2", size = 203402, upload-time = "2026-04-29T20:42:36.842Z" }, ] +[[package]] +name = "gradio" +version = "6.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "audioop-lts", marker = "python_full_version >= '3.13'" }, + { name = "brotli" }, + { name = "fastapi" }, + { name = "gradio-client" }, + { name = "groovy" }, + { name = "hf-gradio" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "jinja2" }, + { name = "markupsafe" }, + { name = "numpy" }, + { name = "orjson" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pillow" }, + { name = "pydantic" }, + { name = "pydub" }, + { name = "python-multipart" }, + { name = "pytz" }, + { name = "pyyaml" }, + { name = "safehttpx" }, + { name = "semantic-version" }, + { name = "starlette" }, + { name = "tomlkit" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "uvicorn" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/96/3618f8a189180ab3d4e5f8b258fd92e419eda9f49b6ab4dd50c6782cda33/gradio-6.20.0.tar.gz", hash = "sha256:8672866e9225a1f8297325a6742bb525a3a0ddc8aa4d75d99beb10a27ea2915f", size = 44844340, upload-time = "2026-07-07T18:53:57.402Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/f4/7dc4540836e326391a9d1ba20193d795d5a4582839b60f5c10397f5120bb/gradio-6.20.0-py3-none-any.whl", hash = "sha256:91d2ec29c37917d55b18dba87aa15bb15c4796d84dce9a9ef4ec7d87453a7fee", size = 30964820, upload-time = "2026-07-07T18:53:52.403Z" }, +] + +[[package]] +name = "gradio-client" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fsspec" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "packaging" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e8/e6/6b6029f5fe2ad7f1211105d530e34d991014c2cae463f9223033031cfc4f/gradio_client-2.5.0.tar.gz", hash = "sha256:4cde99bad62149595c30c90876ca2e405e3a13687ecf895474f3412cb476673d", size = 59013, upload-time = "2026-04-20T23:16:21.518Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/81/0a861b8e1ff42960139c6cd4c7dd591292fa09ea1ae2d87677441cba4c00/gradio_client-2.5.0-py3-none-any.whl", hash = "sha256:d43e2179c29076292a76485ad7ed2e6eaa19d14ac58283bd7f5beabfe4ca958c", size = 59952, upload-time = "2026-04-20T23:16:20.186Z" }, +] + +[[package]] +name = "griffelib" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/e4/8d187ea29c2e30b3a09505c567513077d6117861bde1fbd997a167f262ec/griffelib-2.1.0.tar.gz", hash = "sha256:762a186d2c6fd6794d4ea20d428d597ffb857cb56b66421651cbba15bdd5e813", size = 216234, upload-time = "2026-06-19T12:05:42.278Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/d3/5268aeabf2ad82658c4e2ff3a060648d0f02f3926cb53247c0e4d0dab49e/griffelib-2.1.0-py3-none-any.whl", hash = "sha256:cc7b3d2d2865ad0b909fcc38086e3f554b5ea7acbaa7bbb7ecaa3f5dfb7d9f00", size = 142560, upload-time = "2026-06-19T12:05:38.742Z" }, +] + +[[package]] +name = "groovy" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/36/bbdede67400277bef33d3ec0e6a31750da972c469f75966b4930c753218f/groovy-0.1.2.tar.gz", hash = "sha256:25c1dc09b3f9d7e292458aa762c6beb96ea037071bf5e917fc81fb78d2231083", size = 17325, upload-time = "2025-02-28T20:24:56.068Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/27/3d6dcadc8a3214d8522c1e7f6a19554e33659be44546d44a2f7572ac7d2a/groovy-0.1.2-py3-none-any.whl", hash = "sha256:7f7975bab18c729a257a8b1ae9dcd70b7cafb1720481beae47719af57c35fa64", size = 14090, upload-time = "2025-02-28T20:24:55.152Z" }, +] + [[package]] name = "h11" version = "0.16.0" @@ -418,6 +944,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, ] +[[package]] +name = "hf-gradio" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gradio-client" }, + { name = "typer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ce/86/c9694b7cfada5780e75769e60dc161a161f4dd7fc91b61db5e3a3338bef9/hf_gradio-0.4.1.tar.gz", hash = "sha256:a017d942618f0d495a58ee4563047fa04bef614c00e0cb789a9a6d0633cffa7b", size = 6560, upload-time = "2026-04-22T14:01:32.334Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/2d/afff2ee87e75d8eb85c92bb8cf0e15b05c23c2ebd8fd8dec781d8601ed7f/hf_gradio-0.4.1-py3-none-any.whl", hash = "sha256:76b8cb8be6abe62d74c1ad2d35b42f0629db89aa9e1a8d033cecfe7c856eeab3", size = 4482, upload-time = "2026-04-17T19:53:31.827Z" }, +] + [[package]] name = "hf-xet" version = "1.5.0" @@ -463,6 +1002,42 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, ] +[[package]] +name = "httptools" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342, upload-time = "2026-05-25T22:17:48.841Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247, upload-time = "2026-05-25T22:17:07.843Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064, upload-time = "2026-05-25T22:17:09.136Z" }, + { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851, upload-time = "2026-05-25T22:17:10.106Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842, upload-time = "2026-05-25T22:17:11.218Z" }, + { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238, upload-time = "2026-05-25T22:17:12.728Z" }, + { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567, upload-time = "2026-05-25T22:17:13.842Z" }, + { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918, upload-time = "2026-05-25T22:17:15.155Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148, upload-time = "2026-05-25T22:17:16.333Z" }, + { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368, upload-time = "2026-05-25T22:17:17.586Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447, upload-time = "2026-05-25T22:17:18.564Z" }, + { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448, upload-time = "2026-05-25T22:17:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460, upload-time = "2026-05-25T22:17:20.882Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312, upload-time = "2026-05-25T22:17:22.085Z" }, + { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117, upload-time = "2026-05-25T22:17:23.074Z" }, + { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183, upload-time = "2026-05-25T22:17:24.004Z" }, + { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079, upload-time = "2026-05-25T22:17:25.216Z" }, + { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596, upload-time = "2026-05-25T22:17:26.186Z" }, + { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865, upload-time = "2026-05-25T22:17:27.542Z" }, + { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189, upload-time = "2026-05-25T22:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610, upload-time = "2026-05-25T22:17:29.816Z" }, + { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705, upload-time = "2026-05-25T22:17:31.133Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023, upload-time = "2026-05-25T22:17:32.401Z" }, + { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405, upload-time = "2026-05-25T22:17:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497, upload-time = "2026-05-25T22:17:34.732Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585, upload-time = "2026-05-25T22:17:35.813Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297, upload-time = "2026-05-25T22:17:37.08Z" }, + { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535, upload-time = "2026-05-25T22:17:38.032Z" }, + { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209, upload-time = "2026-05-25T22:17:39.473Z" }, +] + [[package]] name = "httpx" version = "0.28.1" @@ -478,6 +1053,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, ] +[[package]] +name = "httpx-sse" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" }, +] + [[package]] name = "huggingface-hub" version = "1.13.0" @@ -528,6 +1112,48 @@ 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 = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/1f/c23395957d41ccf27c4e535c3d334c4051e5395b3752057ba4cbaec35c56/jaraco_functools-4.6.0.tar.gz", hash = "sha256:880c577ec9720b3a052d5bc611fb9f2269b3d87902ef42440df443b88e443280", size = 20837, upload-time = "2026-07-14T01:28:02.544Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/36/ecc85bc96c273dc8a11273ed4782272975e6338d4a3e9228621175edf0e3/jaraco_functools-4.6.0-py3-none-any.whl", hash = "sha256:99e3dc0060c5cbe8fcd1cdb36258e2a65ca40f1566b2033b12abb1bb44dd3c30", size = 11677, upload-time = "2026-07-14T01:28:01.59Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + [[package]] name = "jinja2" version = "3.1.6" @@ -612,6 +1238,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" }, ] +[[package]] +name = "joserfc" +version = "1.7.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/e0/27a6a081ae25420eda6768ceae05d7022a7f2447f420588843f2a44e4298/joserfc-1.7.4.tar.gz", hash = "sha256:b3bc561672ae541b17a9237053b48a03dacddd92d68047b3ecdfb4b5714a88ed", size = 234027, upload-time = "2026-07-19T15:43:02.739Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/bf/249dcd99b3376375910b7fa922383b57792975c8758f50d44612e749226c/joserfc-1.7.4-py3-none-any.whl", hash = "sha256:32d46c2cd5e3203c13e87a6c61333cab310b1ba80cd54b4c4f386a848a122463", size = 71000, upload-time = "2026-07-19T15:43:01.299Z" }, +] + +[[package]] +name = "jsonref" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814, upload-time = "2023-01-16T16:10:04.455Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" }, +] + [[package]] name = "jsonschema" version = "4.23.0" @@ -627,6 +1274,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462, upload-time = "2024-07-08T18:40:00.165Z" }, ] +[[package]] +name = "jsonschema-path" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "pathable" }, + { name = "pyyaml" }, + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/39/79/cd02a4df6d9270efdc7d3feefe6edd730b0820c39eeaa107a2faee8322d5/jsonschema_path-0.5.0.tar.gz", hash = "sha256:493b156ba895c97602655b620a8456caa2ce08c1aa389f5a7addec065e6e855c", size = 19597, upload-time = "2026-05-19T20:45:00.971Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/2c/9e69d73c4297508be9e3b64a970ea3971b3eb8db64ffc5802d40bd25981f/jsonschema_path-0.5.0-py3-none-any.whl", hash = "sha256:2790a070bc7abb08ea3dbe4d340ece4efadf639223001f020c7503229ba068e2", size = 24077, upload-time = "2026-05-19T20:44:59.225Z" }, +] + [[package]] name = "jsonschema-specifications" version = "2025.9.1" @@ -639,6 +1301,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, ] +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + [[package]] name = "litellm" version = "1.83.14" @@ -737,6 +1416,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, ] +[[package]] +name = "mcp" +version = "1.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpx" }, + { name = "httpx-sse" }, + { name = "jsonschema" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "sse-starlette" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", hash = "sha256:d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683", size = 638501, upload-time = "2026-06-26T12:57:29.093Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", hash = "sha256:2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df", size = 222620, upload-time = "2026-06-26T12:57:27.218Z" }, +] + [[package]] name = "mdurl" version = "0.1.2" @@ -746,6 +1450,15 @@ 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 = "more-itertools" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/f4da6f02cdffe04d6362210b807146a26044c88d839208aec273bb0d9184/more_itertools-11.1.0.tar.gz", hash = "sha256:48e8f4d9e7e5878571ecf6f2b4e57634f93cd474cc8cfbd2376f2d11b396e30d", size = 145772, upload-time = "2026-05-22T14:14:29.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/3d/1087453384dbde46a8c7f9356eead2c58be8a7bf156bca40243377c85715/more_itertools-11.1.0-py3-none-any.whl", hash = "sha256:4b65538ae22f6fed0ce4874efd317463a7489796a0939fa66824dd542125a192", size = 72226, upload-time = "2026-05-22T14:14:28.824Z" }, +] + [[package]] name = "multidict" version = "6.7.1" @@ -845,6 +1558,57 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, ] +[[package]] +name = "numpy" +version = "2.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" }, + { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" }, + { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" }, + { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" }, + { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" }, + { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" }, + { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" }, + { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" }, + { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" }, + { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" }, + { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" }, + { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" }, + { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" }, + { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" }, + { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" }, + { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" }, + { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/db/f4/731b6085a83faf6ca843394cbd5e217280c214399f7e8b21b9f552af0ae2/numpy-2.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7c786fe9a5bbe360022e584c5a34cf6b54265c71bd7ec8ac3d8fec38968071f8", size = 16795063, upload-time = "2026-07-04T17:07:07.374Z" }, + { url = "https://files.pythonhosted.org/packages/bf/64/0e215f2048dd11a55bb989ed41b3585ef57452404e638d703a211a3e4157/numpy-2.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32985c896d897419ef8da6917872d80b78ad0ea26d85b23245c7366ffde76d75", size = 11776652, upload-time = "2026-07-04T17:07:09.907Z" }, + { url = "https://files.pythonhosted.org/packages/b5/59/2b844c7a6e9deff69b404a66221e1542937734f65d5e6e39411876053862/numpy-2.5.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:efd736408cc97c79b9e6917338dfc8f06013b2274f992e96b1d9a81a71e2a2c2", size = 5335944, upload-time = "2026-07-04T17:07:12.227Z" }, + { url = "https://files.pythonhosted.org/packages/86/51/9bf7cb2cabcebc9e017e4ec7e6322b378317a542c08b4cb68479c1efc716/numpy-2.5.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:ab84dc6b074fa881cae55bea94cc4f68e285181ba7f32497bf7dee6b1496165b", size = 6656266, upload-time = "2026-07-04T17:07:14.368Z" }, + { url = "https://files.pythonhosted.org/packages/83/3e/fb7615b211b82a32f44d5180a6d421b61f84d4fadd578b48ba4ac34e189f/numpy-2.5.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caf3e317d33d60c37986b452613f4ab51246d0691350c03d0cb4a898627f4a95", size = 15179720, upload-time = "2026-07-04T17:07:16.272Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/0f992cb24560673496c5d68de61913b57166ce530ffda07c1f280e0cc464/numpy-2.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:54ad769f17bc2d833b620851989f62054fb9ab93c969d9e1dc3c8e3d56beea21", size = 16664835, upload-time = "2026-07-04T17:07:19.021Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2f/97d6475ee91afe2587797d09446f9d3e475ad4cb681662d824809327b75a/numpy-2.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c12afb53450fa976d4c681c50a7423729a4c51c0465ed9f32b8a9cabbc472373", size = 16539135, upload-time = "2026-07-04T17:07:22.015Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/4db81e4ba0be7e2776b1de68c82aa862c7f8ec27e1b4927d4ae075e20678/numpy-2.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c11c405efc5ff6816d5983c96cdfa215bab3428961243af3ff59b228490438", size = 18426684, upload-time = "2026-07-04T17:07:24.941Z" }, + { url = "https://files.pythonhosted.org/packages/1f/64/c0ba2d90724d450279a7df8f32057241070250a26a7e2b5337d77347f481/numpy-2.5.1-cp314-cp314-win32.whl", hash = "sha256:f2479a47f8d5932d1718168a681ad6e536a9df484c83cfcf9de365e164537ace", size = 6116103, upload-time = "2026-07-04T17:07:27.622Z" }, + { url = "https://files.pythonhosted.org/packages/c1/1a/837f9ed7405adcd7a40538792eb169eddd8fa5630c16a1ef49dae71a30f4/numpy-2.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:24d0eb82c0541d3415a33425db64ae439dffccd7b4dbcb30e7c35120205c506a", size = 12562177, upload-time = "2026-07-04T17:07:29.887Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/49707938b6dd0a78a9178dd93227dc89e4c11af47f5c798d70366e8d0483/numpy-2.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5a4c988b38d261deeeaad9954e3deb091ad905c94e8bb6708654ef1d97f286b0", size = 10627739, upload-time = "2026-07-04T17:07:32.568Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c7/bb4b882cfe7f299cbc8b66e42e7dd78cf9d14e40f9469fc5e3db7e15b3bd/numpy-2.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a33276be12fa045805f477f22482088b66bb758ffbe89a9d21457de863a32e22", size = 11894709, upload-time = "2026-07-04T17:07:34.941Z" }, + { url = "https://files.pythonhosted.org/packages/40/3f/5af7f4a7f6224aef48017aa82bb6174c7a659d724be0c75017b7e64a55b4/numpy-2.5.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f089d7b00756190aacf1f5d34bdf38c3c430ac82b4f868f8cede73380460fce7", size = 5453810, upload-time = "2026-07-04T17:07:37.495Z" }, + { url = "https://files.pythonhosted.org/packages/20/c9/3474309bc94d634d3f9c3eddf03250ecb8c22cd948ef16fef69a77cc5d7b/numpy-2.5.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:09e9bfd8d2cf479c7d174804fb3811c53a8e9f20a37444008606b57d6b7a826d", size = 6761189, upload-time = "2026-07-04T17:07:39.563Z" }, + { url = "https://files.pythonhosted.org/packages/90/8a/558ae39fdd55d7e7f7fef9a84a6e964ac6b23edbd2a07e52bb084500507d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e68d8dd1e7eba712948f2053a29ec86917bc70ba1358df869d9f06649ef9cf09", size = 15225039, upload-time = "2026-07-04T17:07:41.682Z" }, + { url = "https://files.pythonhosted.org/packages/63/27/ca7392b2d030277bdf0273e7d23255b3ee57d57a7c170a6f4fb3981e1e5d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99d5095fa265a0c4152e7bb12759e14381ef5496152f1ce58f44bdf55c44beb4", size = 16701306, upload-time = "2026-07-04T17:07:44.611Z" }, + { url = "https://files.pythonhosted.org/packages/02/42/03d53ae7996c44d4374a8262e9dc41671fd56cbb98f7d47ef85cf5da4c6b/numpy-2.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ab87a91b3cc3382b8956095bd8f95e00cf679bb81554339be1a2ba404a1473c1", size = 16589955, upload-time = "2026-07-04T17:07:47.694Z" }, + { url = "https://files.pythonhosted.org/packages/7b/15/6c1784ae469640e65db111e9a34b3d0f14d91e8a38b9ce34810ced370dbb/numpy-2.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:224ca51130ef7da85bea2191625181cb4f337f9cb64b471f10c1a12aa8b60077", size = 18464252, upload-time = "2026-07-04T17:07:50.684Z" }, + { url = "https://files.pythonhosted.org/packages/94/a8/f98e50356cf167df656c526c2dfeec2d7dde182f2a3da4b458a5938e2776/numpy-2.5.1-cp314-cp314t-win32.whl", hash = "sha256:6eab239876581b2b3c5a242281b6007bbdbcd1c7085d7709bb57c5929b11e6bf", size = 6263298, upload-time = "2026-07-04T17:07:53.445Z" }, + { url = "https://files.pythonhosted.org/packages/72/ac/96ae880cdecad0b3275d9359fcec72667b49a4863c9f12942e43679dda02/numpy-2.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:83ce9c80d5b521b0d77ddcbe5447c218d247929b6cc056ca5351342accfff0af", size = 12748623, upload-time = "2026-07-04T17:07:55.384Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5a/4d2b1601df3602dba7a14f3348ba9bfe94a18adb428e693df6154c293831/numpy-2.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:5a6db61f9aaa57e369905c67d852045d3c4f7126405b29d09b19dec118e9c9cb", size = 10697674, upload-time = "2026-07-04T17:07:58.506Z" }, +] + [[package]] name = "openai" version = "2.24.0" @@ -864,6 +1628,110 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c9/30/844dc675ee6902579b8eef01ed23917cc9319a1c9c0c14ec6e39340c96d0/openai-2.24.0-py3-none-any.whl", hash = "sha256:fed30480d7d6c884303287bde864980a4b137b60553ffbcf9ab4a233b7a73d94", size = 1120122, upload-time = "2026-02-24T20:02:05.669Z" }, ] +[[package]] +name = "openapi-pydantic" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/2e/58d83848dd1a79cb92ed8e63f6ba901ca282c5f09d04af9423ec26c56fd7/openapi_pydantic-0.5.1.tar.gz", hash = "sha256:ff6835af6bde7a459fb93eb93bb92b8749b754fc6e51b2f1590a19dc3005ee0d", size = 60892, upload-time = "2025-01-08T19:29:27.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/cf/03675d8bd8ecbf4445504d8071adab19f5f993676795708e36402ab38263/openapi_pydantic-0.5.1-py3-none-any.whl", hash = "sha256:a3a09ef4586f5bd760a8df7f43028b60cafb6d9f61de2acba9574766255ab146", size = 96381, upload-time = "2025-01-08T19:29:25.275Z" }, +] + +[[package]] +name = "openenv" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastapi" }, + { name = "fastmcp" }, + { name = "gradio" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "openai" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "rich" }, + { name = "tomli" }, + { name = "tomli-w" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "uvicorn" }, + { name = "websockets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/38/5552b1b208c8b8971a1895a74f3b9e52f824059d3aa5d08992088931d969/openenv-0.4.1.tar.gz", hash = "sha256:08c7c13455854beee5c8f311f57d95180772e3e9ac9c85278d681864488016a3", size = 201919, upload-time = "2026-07-03T11:37:24.139Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/18/787ddb930e29705479fdd0a58b2ca7fa243c9441f8f1ece33629f8d82b8b/openenv-0.4.1-py3-none-any.whl", hash = "sha256:24c46788c80fa322b34b8e1f8b3adfe42fb8ceec7df99a8b96b44eea0a295921", size = 236036, upload-time = "2026-07-03T11:37:22.607Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.44.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ee/8b/aa9e2d8b8dfa7c946f7dec5d1f8f6ba8eca062f43509a06bdb5ce93d26c0/opentelemetry_api-1.44.0.tar.gz", hash = "sha256:67647e5e9566edcf421166fdf022b3537f818635daa852b289e34604dc6fb33a", size = 72406, upload-time = "2026-07-16T15:25:32.678Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/6f/a04e900f465ff3221ccc395522503e2d10e79fa21f2723c8e177aae1e0d1/opentelemetry_api-1.44.0-py3-none-any.whl", hash = "sha256:94b98c893a91b88657eaac1e3ba89618cdb85be6918196705354f34728b2cdef", size = 60018, upload-time = "2026-07-16T15:25:11.657Z" }, +] + +[[package]] +name = "orjson" +version = "3.11.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/0c/964746fcafbd16f8ff53219ad9f6b412b34f345c75f384ad434ceaadb538/orjson-3.11.9.tar.gz", hash = "sha256:4fef17e1f8722c11587a6ef18e35902450221da0028e65dbaaa543619e68e48f", size = 5599163, upload-time = "2026-05-06T15:11:08.309Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/6d/11867a3ffa3a3608d84a4de51ef4dd0896d6b5cc9132fbe1daf593e677bc/orjson-3.11.9-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9ef6fe90aadef185c7b128859f40beb24720b4ecea95379fc9000931179c3a49", size = 228515, upload-time = "2026-05-06T15:09:57.265Z" }, + { url = "https://files.pythonhosted.org/packages/24/75/05912954c8b288f34fcf5cd4b9b071cb4f6e77b9961e175e56ebb258089f/orjson-3.11.9-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:e5c9b8f28e726e97d97696c826bc7bea5d71cecd63576dba92924a32c1961291", size = 128409, upload-time = "2026-05-06T15:09:59.063Z" }, + { url = "https://files.pythonhosted.org/packages/ab/86/1c3a47df3bc8191ea9ac51603bbb872a95167a364320c269f2557911f406/orjson-3.11.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26a473dbb4162108b27901492546f83c76fdcea3d0eadff00ae7a07e18dcce09", size = 132106, upload-time = "2026-05-06T15:10:00.798Z" }, + { url = "https://files.pythonhosted.org/packages/d7/cf/b33b5f3e695ae7d63feef9d915c37cc3b8f465493dcd4f8e0b4c697a2366/orjson-3.11.9-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:011382e2a60fda9d46f1cdee31068cfc52ffe952b587d683ec0463002802a0f4", size = 127864, upload-time = "2026-05-06T15:10:02.15Z" }, + { url = "https://files.pythonhosted.org/packages/31/6a/6cf69385a58208024fcb8c014e2141b8ce838aba6492b589f8acfff97fab/orjson-3.11.9-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2d3dc759490128c5c1711a53eeaa8ee1d437fd0038ffd2b6008abf46db3f882", size = 135213, upload-time = "2026-05-06T15:10:03.515Z" }, + { url = "https://files.pythonhosted.org/packages/e8/f8/0b1bd3e8f2efcdd376af5c8cfd79eaf13f018080c0089c80ebd724e3c7fb/orjson-3.11.9-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d8ea516b3726d190e1b4297e6f4e7a8650347ae053868a18163b4dd3641d1fff", size = 145994, upload-time = "2026-05-06T15:10:05.083Z" }, + { url = "https://files.pythonhosted.org/packages/f3/59/dab79f61044c529d2c81aecdc589b1f833a1c8dec11ba3b1c2498a02ca7e/orjson-3.11.9-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:380cdce7ba24989af81d0a7013d0aaec5d0e2a21734c0e2681b1bc4f141957fe", size = 132744, upload-time = "2026-05-06T15:10:06.853Z" }, + { url = "https://files.pythonhosted.org/packages/0e/a4/82b7a2fe5d8a67a59ed831b24d59a3d46ea7d207b66e1602d376541d94a6/orjson-3.11.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be4fa4f0af7fa18951f7ab3fc2148e223af211bf03f59e1c6034ec3f97f21d61", size = 134014, upload-time = "2026-05-06T15:10:08.213Z" }, + { url = "https://files.pythonhosted.org/packages/50/c7/375e83a76851b73b2e39f3bcf0e5a19e2b89bad13e5bca97d0b293d27f24/orjson-3.11.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a8f5f8bc7ce7d59f08d9f99fa510c06496164a24cb5f3d34537dbd9ca30132e2", size = 141509, upload-time = "2026-05-06T15:10:09.595Z" }, + { url = "https://files.pythonhosted.org/packages/7f/7c/49d5d82a3d3097f641f094f552131f1e2723b0b8cb0fa2874ab65ecfffa6/orjson-3.11.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4d7fde5501b944f83b3e665e1b31343ff6e154b15560a16b7130ea1e594a4206", size = 415127, upload-time = "2026-05-06T15:10:11.049Z" }, + { url = "https://files.pythonhosted.org/packages/3a/dc/7446c538590d55f455647e5f3c61fc33f7108714e7afcffa6a2a033f8350/orjson-3.11.9-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cde1a448023ba7d5bb4c01c5afb48894380b5e4956e0627266526587ef4e535f", size = 148025, upload-time = "2026-05-06T15:10:12.842Z" }, + { url = "https://files.pythonhosted.org/packages/df/e5/4d2d8af06f788329b4f78f8cc3679bb395392fcaa1e4d8d3c33e85308fa4/orjson-3.11.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:71e63adb0e1f1ed5d9e168f50a91ceb93ae6420731d222dc7da5c69409aa47aa", size = 136943, upload-time = "2026-05-06T15:10:14.405Z" }, + { url = "https://files.pythonhosted.org/packages/06/69/850264ccf6d80f6b174620d30a87f65c9b1490aba33fe6b62798e618cad3/orjson-3.11.9-cp312-cp312-win32.whl", hash = "sha256:2d057a602cdd19a0ad680417527c45b6961a095081c0f46fe0e03e304aac6470", size = 131606, upload-time = "2026-05-06T15:10:15.791Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d5/973a43fc9c55e20f2051e9830997649f669be0cb3ca52192087c0143f118/orjson-3.11.9-cp312-cp312-win_amd64.whl", hash = "sha256:59e403b1cc5a676da8eaf31f6254801b7341b3e29efa85f92b48d272637e77be", size = 127101, upload-time = "2026-05-06T15:10:17.129Z" }, + { url = "https://files.pythonhosted.org/packages/fe/ae/495470f0e4a18f73fa10b7f6b84b464ec4cc5291c4e0c7c2a6c400bef006/orjson-3.11.9-cp312-cp312-win_arm64.whl", hash = "sha256:9af678d6488357948f1f84c6cd1c1d397c014e1ae2f98ae082a44eb48f602624", size = 126736, upload-time = "2026-05-06T15:10:18.645Z" }, + { url = "https://files.pythonhosted.org/packages/32/33/93fcc25907235c344ae73122f8a4e01d2d393ef062b4af7d2e2487a32c37/orjson-3.11.9-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:4bab1b2d6141fe7b32ae71dac905666ece4f94936efbfb13d55bb7739a3a6021", size = 228458, upload-time = "2026-05-06T15:10:20.079Z" }, + { url = "https://files.pythonhosted.org/packages/8f/27/b1e6dadb3c080313c03fdd8067b85e6a0460c7d8d6a1c3984ef77b904e4d/orjson-3.11.9-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:844417969855fc7a41be124aafe83dc424592a7f77cd4501900c67307122b92c", size = 128368, upload-time = "2026-05-06T15:10:21.549Z" }, + { url = "https://files.pythonhosted.org/packages/21/0f/c9ede0bf052f6b4051e64a7d4fa91b725cccf8321a6a786e86eb03519f00/orjson-3.11.9-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffe02797b5e9f3a9d8292ddcd289b474ad13e81ad83cd1891a240811f1d2cb81", size = 132070, upload-time = "2026-05-06T15:10:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/fd/26/d398e28048dc18205bbe812f2c88cb9b40313db2470778e25964796458fe/orjson-3.11.9-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e4eed3b200023042814d2fc8a5d2e880f13b52e1ed2485e83da4f3962f7dc1a", size = 127892, upload-time = "2026-05-06T15:10:24.714Z" }, + { url = "https://files.pythonhosted.org/packages/66/60/52b0054c4c700d5aa7fc5b7ca96917400d8f061307778578e67a10e25852/orjson-3.11.9-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aff7da9952a5ad1cef8e68017724d96c7b9a66e99e91d6252e1b133d67a7b10", size = 135217, upload-time = "2026-05-06T15:10:26.084Z" }, + { url = "https://files.pythonhosted.org/packages/d5/97/1e3dc2b2a28b7b2528f403d2fc1d79ec5f39af3bc143ab65d3ec26426385/orjson-3.11.9-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d4e98d6f3b8afed8bc8cd9718ec0cdf46661826beefb53fe8eafb37f2bf0362", size = 145980, upload-time = "2026-05-06T15:10:28.062Z" }, + { url = "https://files.pythonhosted.org/packages/fc/39/31fbfe7850f2de32dee7e7e5c09f26d403ab01e440ac96001c6b01ad3c99/orjson-3.11.9-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a81d52442a7c99b3662333235b3adf96a1715864658b35bb797212be7bddb97", size = 132738, upload-time = "2026-05-06T15:10:29.727Z" }, + { url = "https://files.pythonhosted.org/packages/a1/08/dca0082dd2a194acb93e5457e73455388e2e2ca464a2672449a9ddbb679d/orjson-3.11.9-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e39364e726a8fff737309aff059ff67d8a8c8d5b677be7bb49a8b3e84b7e218", size = 134033, upload-time = "2026-05-06T15:10:31.152Z" }, + { url = "https://files.pythonhosted.org/packages/11/d4/5bdb0626801230139987385554c5d4c42255218ac906525bf4347f22cd95/orjson-3.11.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4fd66214623f1b17501df9f0543bef0b833979ab5b6ded1e1d123222866aa8c9", size = 141492, upload-time = "2026-05-06T15:10:32.641Z" }, + { url = "https://files.pythonhosted.org/packages/fa/88/a21fb53b3ede6703aede6dce4710ed4111e5b201cfa6bbff5e544f9d47d7/orjson-3.11.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:8ecc30f10465fa1e0ce13fd01d9e22c316e5053a719a8d915d4545a09a5ff677", size = 415087, upload-time = "2026-05-06T15:10:34.438Z" }, + { url = "https://files.pythonhosted.org/packages/3d/57/1b30daf70f0d8180e9a73cefbfbdd99e4bf19eb020466502b01fba7e0e50/orjson-3.11.9-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:97db4c94a7db398a5bd636273324f0b3fd58b350bbbac8bb380ceb825a9b40f4", size = 148031, upload-time = "2026-05-06T15:10:36.358Z" }, + { url = "https://files.pythonhosted.org/packages/04/83/45fbb6d962e260807f99441db9613cee868ceda4baceda59b3720a563f97/orjson-3.11.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f78cf8fec5bd627f4082b8dfeac7871b43d7f3274904492a43dab39f18a19a0", size = 136915, upload-time = "2026-05-06T15:10:38.013Z" }, + { url = "https://files.pythonhosted.org/packages/5f/cc/2d10025f9056d376e4127ec05a5808b218d46f035fdc08178a5411b34250/orjson-3.11.9-cp313-cp313-win32.whl", hash = "sha256:d4087e5c0209a0a8efe4de3303c234b9c44d1174161dcd851e8eea07c7560b32", size = 131613, upload-time = "2026-05-06T15:10:39.569Z" }, + { url = "https://files.pythonhosted.org/packages/67/bd/2775ff28bfe883b9aa1ff348300542eb2ef1ee18d8ae0e3a49846817a865/orjson-3.11.9-cp313-cp313-win_amd64.whl", hash = "sha256:051b102c93b4f634e89f3866b07b9a9a98915ada541f4ec30f177067b2694979", size = 127086, upload-time = "2026-05-06T15:10:41.262Z" }, + { url = "https://files.pythonhosted.org/packages/91/2b/d26799e580939e32a7da9a39531bc9e58e15ca32ffaa6a8cb3e9bb0d22cd/orjson-3.11.9-cp313-cp313-win_arm64.whl", hash = "sha256:cce9127885941bd28f080cecf1f1d288336b7e0d812c345b08be88b572796254", size = 126696, upload-time = "2026-05-06T15:10:42.651Z" }, + { url = "https://files.pythonhosted.org/packages/8e/eb/5da01e356015aee6ecfa1187ced87aef51364e306f5e695dd52719bf0e78/orjson-3.11.9-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:b6ef1979adc4bc243523f1a2ba91418030a8e29b0a99cbe7e0e2d6807d4dce6e", size = 228465, upload-time = "2026-05-06T15:10:44.097Z" }, + { url = "https://files.pythonhosted.org/packages/64/62/3e0e0c14c957133bcd855395c62b55ed4e3b0af23ffea11b032cb1dcbdb1/orjson-3.11.9-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:f36b7f32c7c0db4a719f1fc5824db4a9c6f8bd1a354debb91faf26ebf3a4c71e", size = 128364, upload-time = "2026-05-06T15:10:45.839Z" }, + { url = "https://files.pythonhosted.org/packages/5a/5a/07d8aa117211a8ed7630bda80c8c0b14d04e0f8dcf99bcf49656e4a710eb/orjson-3.11.9-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08f4d8ebb44925c794e535b2bebc507cebf32209df81de22ae285fb0d8d66de0", size = 132063, upload-time = "2026-05-06T15:10:47.267Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ec/4acaf21483e18aa945be74a474c74b434f284b549f275a0a39b9f98956e9/orjson-3.11.9-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6cc7923789694fd58f001cbcac7e47abc13af4d560ebbfcf3b41a8b1a0748124", size = 122356, upload-time = "2026-05-06T15:10:48.765Z" }, + { url = "https://files.pythonhosted.org/packages/13/d8/5f0555e7638801323b7a75850f92e7dfa891bc84fe27a1ba4449170d1200/orjson-3.11.9-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea5c46eb2d3af39e806b986f4b09d5c2706a1f5afde3cbf7544ce6616127173c", size = 129592, upload-time = "2026-05-06T15:10:50.13Z" }, + { url = "https://files.pythonhosted.org/packages/b6/30/ed9860412a3603ceb3c5955bfd72d28b9d0e7ba6ed81add14f83d7114236/orjson-3.11.9-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f5d89a2ed90731df3be64bab0aa44f78bff39fdc9d71c291f4a8023aa46425b7", size = 140491, upload-time = "2026-05-06T15:10:51.582Z" }, + { url = "https://files.pythonhosted.org/packages/d0/17/adc514dea7ac7c505527febf884934b815d34f0c7b8693c1a8b39c5c4a57/orjson-3.11.9-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:25e4aed0312d292c09f61af25bba34e0b2c88546041472b09088c39a4d828af1", size = 127309, upload-time = "2026-05-06T15:10:53.329Z" }, + { url = "https://files.pythonhosted.org/packages/76/3e/c0b690253f0b82d86e99949af13533363acfb5432ecb5d53dd5b3bce9c34/orjson-3.11.9-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aaea64f3f467d22e70eeed68bdccb3bc4f83f650446c4a03c59f2cba28a108db", size = 134030, upload-time = "2026-05-06T15:10:54.988Z" }, + { url = "https://files.pythonhosted.org/packages/c1/7a/bc82a0bb25e9faaf92dc4d9ef002732efc09737706af83e346788641d4a7/orjson-3.11.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a028425d1b440c5d92a6be1e1a020739dfe67ea87d96c6dbe828c1b30041728b", size = 141482, upload-time = "2026-05-06T15:10:56.663Z" }, + { url = "https://files.pythonhosted.org/packages/01/55/e69188b939f77d5d32a9833745ace31ea5ccae3ab613a1ec185d3cd2c4fb/orjson-3.11.9-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5b192c6cf397e4455b11523c5cf2b18ed084c1bbd61b6c0926344d2129481972", size = 415178, upload-time = "2026-05-06T15:10:58.446Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1a/b8a5a7ac527e80b9cb11d51e3f6689b709279183264b9ec5c7bc680bb8b5/orjson-3.11.9-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea407d4ccf5891d667d045fecae97a7a1e5e87b3b97f97ae1803c2e741130be0", size = 148089, upload-time = "2026-05-06T15:11:00.441Z" }, + { url = "https://files.pythonhosted.org/packages/97/4e/00503f64204bf859b37213a63927028f30fb6268cd8677fb0a5ad48155e1/orjson-3.11.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f63aaf97afd9f6dec5b1a68e1b8da12bfccb4cb9a9a65c3e0b6c847849e7586", size = 136921, upload-time = "2026-05-06T15:11:02.176Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ba/a23b82a0a8d0ed7bed4e5f5035aae751cad4ff6a1e8d2ecd14d8860f5929/orjson-3.11.9-cp314-cp314-win32.whl", hash = "sha256:e30ab17845bb9fa54ccf67fa4f9f5282652d54faa6d17452f47d0f369d038673", size = 131638, upload-time = "2026-05-06T15:11:03.696Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/0c6798456bade745c75c452342dabacce5798196483e77e643be1f53877d/orjson-3.11.9-cp314-cp314-win_amd64.whl", hash = "sha256:32ef5f4283a3be81913947d19608eacb7c6608026851123790cd9cc8982af34b", size = 127078, upload-time = "2026-05-06T15:11:05.123Z" }, + { url = "https://files.pythonhosted.org/packages/16/21/5a3f1e8913103b703a436a5664238e5b965ec392b555fe68943ea3691e6b/orjson-3.11.9-cp314-cp314-win_arm64.whl", hash = "sha256:eebdbdeef0094e4f5aefa20dcd4eb2368ab5e7a3b4edea27f1e7b2892e009cf9", size = 126687, upload-time = "2026-05-06T15:11:06.602Z" }, +] + [[package]] name = "packaging" version = "26.2" @@ -873,6 +1741,141 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, ] +[[package]] +name = "pandas" +version = "3.0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/be/4f/5f3422a2afec5ffc46308b79e53291365a93748b498ac2e58bead0197916/pandas-3.0.5.tar.gz", hash = "sha256:dca3734d6ab7c906e6730f0788b0a1dbb9f2467731f9711f77995c8e9d62d712", size = 4658219, upload-time = "2026-07-22T22:19:28.819Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/54/1dc810ea558d1320b597aa140a514f2fdf1d2ea09c38cf556f13ea712ec9/pandas-3.0.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa290c16964d4963fbfbc358928239cf3bd755b20e988ce944877def2f44471d", size = 10411717, upload-time = "2026-07-22T22:18:08.307Z" }, + { url = "https://files.pythonhosted.org/packages/68/56/fbe81c09195924d8b7b8d4461a20458fe80a6a5ed6b24f0314da684277e1/pandas-3.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2e26bb46934b8a2ca0c3de1d3d606fc5f6746584791b2db264d58cf370e08dc", size = 9957095, upload-time = "2026-07-22T22:18:10.6Z" }, + { url = "https://files.pythonhosted.org/packages/e0/51/fac252f4a913ed5eabf3c11b880a9e8d5a6c10f0b2129d0462212d238b4d/pandas-3.0.5-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73fa87b08a7ef706f8aafda39ddaccf2a99047bea62d8c88a0361bcafb2237bc", size = 10485458, upload-time = "2026-07-22T22:18:12.834Z" }, + { url = "https://files.pythonhosted.org/packages/12/98/e976540c1addf70442be7842a18cf70884a964abbf69442504f4d2939989/pandas-3.0.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d373ce03ffd84010ed9839fa73672a9c8256990532e158440c0085db7d914b34", size = 10998091, upload-time = "2026-07-22T22:18:15.209Z" }, + { url = "https://files.pythonhosted.org/packages/a4/8c/1f29b5be8d3fc47dd7567eb167fabba2085879b31e0287ce7cba6d3d2ff4/pandas-3.0.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2a29c53d85ea98c5e792c59ef82ee9fbe6ca902c0d0adb6b23f45ef894cd7bf6", size = 11499501, upload-time = "2026-07-22T22:18:17.689Z" }, + { url = "https://files.pythonhosted.org/packages/9d/e2/bd9c98ad2df7b38bde002adde4cdf353519da51881634323b126c55997f9/pandas-3.0.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a5ad3b02ed6bc7d7ae9b70804b2c6aa31827489d150f8e623ce82491b82085d7", size = 12060559, upload-time = "2026-07-22T22:18:20.147Z" }, + { url = "https://files.pythonhosted.org/packages/f3/9a/ffbd852d58bd74a617fe2f8ee6a58a96982271ce41cf981eab22190b4a4b/pandas-3.0.5-cp312-cp312-pyemscripten_2024_0_wasm32.whl", hash = "sha256:b2acb4650527eec6822c3dadb2b771277b65e7dae7a267d4bccf65fd1bb3fbce", size = 7197652, upload-time = "2026-07-22T22:18:22.502Z" }, + { url = "https://files.pythonhosted.org/packages/70/b5/d2d3e9ae73362ba4229651b0ee1455cf78073a1ce585f6ff693782ce263e/pandas-3.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:80a611068e8a3ac23f7398c6c14eb46dc974e5cc9997f653e2dcfd1da74edd41", size = 9831691, upload-time = "2026-07-22T22:18:24.534Z" }, + { url = "https://files.pythonhosted.org/packages/52/51/dea1e89d6a6796b9c43f85a09b484ee03edb8a4c4842e73e200a8c11301c/pandas-3.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:25ff585b972a18ef1fe9ffa3ac6544d9950508aa76832e5147640b6022821e49", size = 9105796, upload-time = "2026-07-22T22:18:27.064Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/7b95c4a0025227d6f118c4039b423412ac6a982db02864166185d812fbc7/pandas-3.0.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c1c05a767fe8e5b4fe9e1c29806829c582052eaedb9120a3da83ba3f69e24a5b", size = 10385742, upload-time = "2026-07-22T22:18:29.346Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0c/dc78fd8c4da477b4b5e8ad37295af352190d21ef63a9ee1bc071753074cc/pandas-3.0.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b86765f268b56f7e665b93bce9d5df69dee7f99e595cf8fb839483ab315942a3", size = 9932067, upload-time = "2026-07-22T22:18:31.833Z" }, + { url = "https://files.pythonhosted.org/packages/3e/71/3592c055cf44df9808550f9368ceda80ff2b224d355ef73fe251dcda1802/pandas-3.0.5-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c597ecf5616b5c420372c1d4d4c00dbbfba7398bea857dcc984347e1ea48417b", size = 10466756, upload-time = "2026-07-22T22:18:34.195Z" }, + { url = "https://files.pythonhosted.org/packages/e3/70/4363150359f95b4cb4bcbb34ca23572bb5495749a621a8f3d5a1ddfd293c/pandas-3.0.5-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4b11c36e218331d0387cbe3a0a5f75162357a1d92d57b2b08a336ff94b19b2be", size = 10938525, upload-time = "2026-07-22T22:18:36.81Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d0/317e7a0c67c0e69fa905a0161409397a7dc2d46ff611f6ca4803352c042b/pandas-3.0.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cf52e1f61d229496da17dc7ab54acdee627357e7008fd4fecba3d0ba2937fa58", size = 11489303, upload-time = "2026-07-22T22:18:39.287Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8d/36dade89b49e4f9d5cbdbe863772581f98c0c6d78fc39ad4c557f6f2e17e/pandas-3.0.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:db172144bb56422bd157812f3b021eacc255451470b31e2c633c349490a1cfee", size = 11989004, upload-time = "2026-07-22T22:18:42.208Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ba/18c4ec8a746e177da05a9e7a7963781d8ea195780724f854601b6ebd6b78/pandas-3.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:0d298e951f23016ce4699951d044ae6418dbc91bf68cefca0f77666fcbb4e5c6", size = 9826896, upload-time = "2026-07-22T22:18:44.539Z" }, + { url = "https://files.pythonhosted.org/packages/de/ec/28a57266b753799a87b8bc79e7887ac6fd981b8c6d2978a0b7e7b6bd708c/pandas-3.0.5-cp313-cp313-win_arm64.whl", hash = "sha256:66266d3442a5e8b3c90274c2b8b230bee42dd1c286bc822cc2f9f2c7e12b883e", size = 9094790, upload-time = "2026-07-22T22:18:47.468Z" }, + { url = "https://files.pythonhosted.org/packages/51/2f/cf6aae281264f4463f0875bcbb15fd2bb6d291cc535187dad1732475e4a9/pandas-3.0.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2f264fc46911cc8131a7322a16199bbf8e353d27c10bb211f5bd0c814324dc36", size = 10390034, upload-time = "2026-07-22T22:18:49.818Z" }, + { url = "https://files.pythonhosted.org/packages/06/ec/5189518c7a7659c4bdcc6b1eb32c46c6f3c86b0661ffd84143d1112c7732/pandas-3.0.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:53730687fcd161883b24e10411c06d6a4c0f2275d2faf3bb2bc25deb4ba8007c", size = 9980065, upload-time = "2026-07-22T22:18:52.249Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f1/598503ce8d7e3c35601e0747ba288c7864baae66380725bc12f13f884dfe/pandas-3.0.5-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:960d3ebcf249f75206899fcd2c6de53f736b7265759ced0d3e559df0b8b709b0", size = 10545532, upload-time = "2026-07-22T22:18:54.813Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/ceae2adf7034e07e9910299fe412e1819c4f0dd520700a888bcb03625448/pandas-3.0.5-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e94c2c5ca43bd3ca32bf64d32308887b65e5f9bfd8023ea52755107a999f93b", size = 10963120, upload-time = "2026-07-22T22:18:57.42Z" }, + { url = "https://files.pythonhosted.org/packages/66/25/86e0f4451874eb79e688deeebe3c451fec4557f8952005818d800ee8ac7e/pandas-3.0.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e819dd5f62966b481a8cb649d3299ebd886a1ea91ed5a99bf7ce77c98d18ab94", size = 11563178, upload-time = "2026-07-22T22:18:59.729Z" }, + { url = "https://files.pythonhosted.org/packages/f3/45/8643daa3b4147e433adfcccefdd0380d3aad79d86b15d8999730fe1944d5/pandas-3.0.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3c5ed2e7c06e91d340dfd091d7934f9bc82e4a36b95f647f090b9d1c9ac649da", size = 12028708, upload-time = "2026-07-22T22:19:02.164Z" }, + { url = "https://files.pythonhosted.org/packages/96/58/ad979ae617615576e8aafd569c9d4b62f1191d896e38f51d66ba06f3b89a/pandas-3.0.5-cp314-cp314-win_amd64.whl", hash = "sha256:cd8f7c6dc98527058ee6264219343f5392240a6f1bfa654fc5d79023020d0c92", size = 9951806, upload-time = "2026-07-22T22:19:04.596Z" }, + { url = "https://files.pythonhosted.org/packages/69/32/7ac03886b304049a9d2625ee88f59af760d8a93bd30ed9239bce7b9869a8/pandas-3.0.5-cp314-cp314-win_arm64.whl", hash = "sha256:5183427f5a8156d480f30333777bc978be93650a49a7c01db26adffe95b31e85", size = 9238297, upload-time = "2026-07-22T22:19:06.836Z" }, + { url = "https://files.pythonhosted.org/packages/be/ed/1d1f2ee5547d5167face2376d11c8b2a4c7bfff5a416ee7a9046891fab1e/pandas-3.0.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:303da736987d481074ca720ada325f8bd80c64ebc2d45ed79b29df3aaa4a26ca", size = 10849690, upload-time = "2026-07-22T22:19:09.391Z" }, + { url = "https://files.pythonhosted.org/packages/57/55/17e17152e98fbb0c4b1e562bc65387a2f20a80db0f4a86bf8d3a0e4248d4/pandas-3.0.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3b2801bbb049d0136f6c213eae02b5fca969384fc2064dd728d8620552aa49da", size = 10509945, upload-time = "2026-07-22T22:19:11.773Z" }, + { url = "https://files.pythonhosted.org/packages/88/90/817d44dbf83facf9556f33576d9af0a241981e7bb5c00606c0bcb5df8dda/pandas-3.0.5-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cce3a9d11d2b1f82c69a27ec1f4948a170e2c403c4bbfa8cca62e3fdebe2ef3a", size = 10392197, upload-time = "2026-07-22T22:19:14.024Z" }, + { url = "https://files.pythonhosted.org/packages/f1/da/889f00c0a6f5aa1545add70abbf01502dff87ab577adb855bd631c54d2f2/pandas-3.0.5-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef01af4d8dc6cd2c8d6c7736f149574ef93fe043811eeb5e445f2647154b5040", size = 10862726, upload-time = "2026-07-22T22:19:16.351Z" }, + { url = "https://files.pythonhosted.org/packages/bc/98/f1e934fb3c98fce859c6147c6785816c7b5b9ab7821115c5d8c4de9842b9/pandas-3.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e2759e890db96dfcffdbd9b86c3c2cb6afaf58def482820317e06163ec1066cd", size = 11414864, upload-time = "2026-07-22T22:19:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/fe/be/d448af7d657d82e1888dd8551f79c6d6fb161080b5b9752d84d910ec2319/pandas-3.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b58b1b39d46a5862e3fb18f50d1a201398619d16a0f9f73f57eea5583cf0e63c", size = 11925105, upload-time = "2026-07-22T22:19:21.515Z" }, + { url = "https://files.pythonhosted.org/packages/29/c1/ccb4238212c8c4f496c584f3044d94e0c030ed8e1d68999db46c91c2242f/pandas-3.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:1c10461f6eeb35d8f05b6184c65c8b9991663b66c46b1d559b682cb34ae7c6ea", size = 10387612, upload-time = "2026-07-22T22:19:24.257Z" }, + { url = "https://files.pythonhosted.org/packages/d2/cf/6a51b2c38980e04c279fd2fa908a1b0982064e860444acfca4ec2e2c8359/pandas-3.0.5-cp314-cp314t-win_arm64.whl", hash = "sha256:3c5015fd1730fbf883647e88068176c839c102cea883ba1769a6f4593bfc1f8c", size = 9509776, upload-time = "2026-07-22T22:19:26.694Z" }, +] + +[[package]] +name = "pathable" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/f3/5a20387de9bcd0607871bfc2198ee0e15836da7baa4592ccd7f24c27c986/pathable-0.6.0.tar.gz", hash = "sha256:6404b8b82aef5ff0fd478934137128b99b12212ba35afdde5525ca4f8388ea58", size = 18970, upload-time = "2026-05-19T18:15:11.911Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/e8/6d75ffd9784bce2e93d1ae4415649427e39a53bb172d4672b2b59c6f0a7b/pathable-0.6.0-py3-none-any.whl", hash = "sha256:82c4ca6c98c502ad12e0d4e9779b6210afee93c38990988c8c5d1b49bdcdf566", size = 18983, upload-time = "2026-05-19T18:15:10.728Z" }, +] + +[[package]] +name = "pillow" +version = "12.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, + { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" }, + { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" }, + { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" }, + { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" }, + { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" }, + { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" }, + { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" }, + { url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" }, + { url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" }, + { url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" }, + { url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" }, + { url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" }, + { url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" }, + { url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" }, + { url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" }, + { url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" }, + { url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/78/9b/560e4be8e26f6fd133a03630a8df0c663b9e8d61b4ade152b72005aec83b/platformdirs-4.11.0.tar.gz", hash = "sha256:0555d18370482847566ffabcaa53ad7c6c1c29f195989ae1ed634a05f76ea1e0", size = 31953, upload-time = "2026-07-21T13:09:36.565Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/68/d8d58938dfb1370b266a1a729e6d77a985be23689a0496498ee17b2cbf90/platformdirs-4.11.0-py3-none-any.whl", hash = "sha256:360ccded2b7fce0af0ff80cc8f5942a1c5d99b0e856033acb030bfc634709e74", size = 23247, upload-time = "2026-07-21T13:09:35.422Z" }, +] + [[package]] name = "pluggy" version = "1.6.0" @@ -966,6 +1969,40 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" }, ] +[[package]] +name = "py-key-value-aio" +version = "0.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beartype" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/e2/d689d922894a7ecde73b6daeaf9b13dab5aae06fe6aaaf7514722644d382/py_key_value_aio-0.4.5.tar.gz", hash = "sha256:c6563a2c6abe5da5e20f4f9e875c2a9b425a2244a54fadbf46cf140a9eea45d7", size = 107547, upload-time = "2026-05-27T16:37:08.107Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/95/b8ba862968712caa12a19666175334fa979e1f198b896a430adb3bacfe87/py_key_value_aio-0.4.5-py3-none-any.whl", hash = "sha256:ab862adbcb8c72547d1c57821f22cbbb71ab86509039c96f36e914e0336c8dd7", size = 170005, upload-time = "2026-05-27T16:37:06.629Z" }, +] + +[package.optional-dependencies] +filetree = [ + { name = "aiofile" }, + { name = "anyio" }, +] +keyring = [ + { name = "keyring" }, +] +memory = [ + { name = "cachetools" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + [[package]] name = "pydantic" version = "2.12.5" @@ -981,6 +2018,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, ] +[package.optional-dependencies] +email = [ + { name = "email-validator" }, +] + [[package]] name = "pydantic-core" version = "2.41.5" @@ -1052,6 +2094,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, ] +[[package]] +name = "pydantic-settings" +version = "2.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f", size = 237700, upload-time = "2026-06-19T13:44:56.324Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440", size = 61715, upload-time = "2026-06-19T13:44:55.02Z" }, +] + +[[package]] +name = "pydub" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/9a/e6bca0eed82db26562c73b5076539a4a08d3cffd19c3cc5913a3e61145fd/pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f", size = 38326, upload-time = "2021-03-10T02:09:54.659Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/53/d78dc063216e62fc55f6b2eebb447f6a4b0a59f55c8406376f76bf959b08/pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6", size = 32327, upload-time = "2021-03-10T02:09:53.503Z" }, +] + [[package]] name = "pygments" version = "2.20.0" @@ -1061,6 +2126,29 @@ 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 = "pyjwt" +version = "2.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" }, +] + +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, +] + +[[package]] +name = "pyperclip" +version = "1.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/52/d87eba7cb129b81563019d1679026e7a112ef76855d6159d24754dbd2a51/pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6", size = 12185, upload-time = "2025-09-26T14:40:37.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" }, +] + [[package]] name = "pytest" version = "9.0.3" @@ -1090,6 +2178,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, ] +[[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-dotenv" version = "1.2.2" @@ -1099,6 +2199,52 @@ 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 = "python-multipart" +version = "0.0.32" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" }, +] + +[[package]] +name = "pytz" +version = "2026.3.post1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/48/fb042503b6ca6cd271261dc559fd6432f7d8c713153e9ec5c591af4dfc1c/pytz-2026.3.post1.tar.gz", hash = "sha256:2211d3fcf9a797d3405cac96ac7f61d80e6a644f72a3309607282fe8a2010c5d", size = 319745, upload-time = "2026-07-25T15:12:07.385Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/7b/39c34ca613b0b198cb866466651b26b045e2009864c5183c979a3b83f383/pytz-2026.3.post1-py2.py3-none-any.whl", hash = "sha256:dd95840dd199baea12d9cc096a1d452caa6596a1c1e4b5f3dbd1541855d5e815", size = 508283, upload-time = "2026-07-25T15:12:05.782Z" }, +] + +[[package]] +name = "pywin32" +version = "312" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" }, + { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" }, + { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" }, + { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" }, + { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" }, + { url = "https://files.pythonhosted.org/packages/fc/2b/1f3cded5822fd49c02f40544cbb5f58c7cfd6b1694869fd476cb6170ee97/pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b", size = 6468928, upload-time = "2026-06-04T07:49:43.188Z" }, + { url = "https://files.pythonhosted.org/packages/21/82/3bf86d2e2808902013132e1ce905a7da0da53790f3836c64bf44d55e24f3/pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e", size = 7024157, upload-time = "2026-06-04T07:49:45.34Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0e/73f6d6800b4f27655abd9e9f6aaeaefcddb2b946e4674efa2bab184a7f7b/pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa", size = 6839598, upload-time = "2026-06-04T07:49:47.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/61/caa39686032d2ebdd04ff0ab5cbe163126c0066d98e00c9018646e42393b/pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed", size = 6471159, upload-time = "2026-06-04T07:49:50.035Z" }, + { url = "https://files.pythonhosted.org/packages/0f/cd/7e1de64a4a6f69c04214169657ccab0d93a670ea50e35eb8f489d7378249/pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5", size = 7025293, upload-time = "2026-06-04T07:49:54.857Z" }, + { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -1261,6 +2407,13 @@ dependencies = [ { name = "tomli-w" }, ] +[package.optional-dependencies] +openenv = [ + { name = "docker" }, + { name = "openenv" }, + { name = "uvicorn", extra = ["standard"] }, +] + [package.dev-dependencies] dev = [ { name = "pytest" }, @@ -1270,14 +2423,18 @@ dev = [ [package.metadata] requires-dist = [ + { name = "docker", marker = "extra == 'openenv'", specifier = ">=7.1.0" }, { name = "huggingface-hub", specifier = ">=1.13.0" }, { name = "litellm", specifier = ">=1.83.14" }, + { name = "openenv", marker = "extra == 'openenv'", specifier = ">=0.4.1" }, { name = "pydantic", specifier = ">=2.12.5" }, { name = "python-dotenv", specifier = ">=1.2.2" }, { name = "pyyaml", specifier = ">=6.0.3" }, { name = "rich", specifier = ">=15.0.0" }, { name = "tomli-w", specifier = ">=1.2.0" }, + { name = "uvicorn", extras = ["standard"], marker = "extra == 'openenv'", specifier = ">=0.30.0" }, ] +provides-extras = ["openenv"] [package.metadata.requires-dev] dev = [ @@ -1314,6 +2471,19 @@ 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 = "rich-rst" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, + { name = "rich" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/d6/d0b9fafc73b65767200da027acab1db1bdb1048f4fea5ebf659df01c700e/rich_rst-2.1.0.tar.gz", hash = "sha256:f4d117b49697f338769759fa5cacf5197da4888b347b9fda2e50aef5cd8d93bd", size = 302732, upload-time = "2026-07-05T02:59:44.308Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/68/1fc93dd759605b5d00fc98b50200739e41ed32bd22d6ba35ca6c3932371b/rich_rst-2.1.0-py3-none-any.whl", hash = "sha256:7ecd1343ee12c879d0e7ae74c3eb6d263b023d2929c6d114212eb1fd91057255", size = 272987, upload-time = "2026-07-05T02:59:42.792Z" }, +] + [[package]] name = "rpds-py" version = "0.30.0" @@ -1420,6 +2590,40 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c0/98/6beb4b351e472e5f4c4613f7c35a5290b8be2497e183825310c4c3a3984b/ruff-0.15.12-py3-none-win_arm64.whl", hash = "sha256:a538f7a82d061cee7be55542aca1d86d1393d55d81d4fcc314370f4340930d4f", size = 11120821, upload-time = "2026-04-24T18:16:57.979Z" }, ] +[[package]] +name = "safehttpx" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/89/d1/4282284d9cf1ee873607a46442da977fc3c985059315ab23610be31d5885/safehttpx-0.1.7.tar.gz", hash = "sha256:db201c0978c41eddb8bb480f3eee59dd67304fdd91646035e9d9a720049a9d23", size = 10385, upload-time = "2025-10-24T18:30:09.783Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/a3/0f0b7d78e2f1eb9e8e1afbff1d2bff8d60144aee17aca51c065b516743dd/safehttpx-0.1.7-py3-none-any.whl", hash = "sha256:c4f4a162db6993464d7ca3d7cc4af0ffc6515a606dfd220b9f82c6945d869cde", size = 8959, upload-time = "2025-10-24T18:30:08.733Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography", marker = "(python_full_version >= '3.13' and sys_platform == 'emscripten') or (sys_platform != 'emscripten' and sys_platform != 'win32')" }, + { name = "jeepney", marker = "(python_full_version >= '3.13' and sys_platform == 'emscripten') or (sys_platform != 'emscripten' and sys_platform != 'win32')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, +] + +[[package]] +name = "semantic-version" +version = "2.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/31/f2289ce78b9b473d582568c234e104d2a342fd658cc288a7553d83bb8595/semantic_version-2.10.0.tar.gz", hash = "sha256:bdabb6d336998cbb378d4b9db3a4b56a1e3235701dc05ea2690d9a997ed5041c", size = 52289, upload-time = "2022-05-26T13:35:23.454Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/23/8146aad7d88f4fcb3a6218f41a60f6c2d4e3a72de72da1825dc7c8f7877c/semantic_version-2.10.0-py2.py3-none-any.whl", hash = "sha256:de78a3b8e0feda74cabc54aab2da702113e33ac9d9eb9d2389bcf1f58b7d9177", size = 15552, upload-time = "2022-05-26T13:35:21.206Z" }, +] + [[package]] name = "shellingham" version = "1.5.4" @@ -1429,6 +2633,15 @@ 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 = "sniffio" version = "1.3.1" @@ -1438,6 +2651,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, ] +[[package]] +name = "sse-starlette" +version = "3.4.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "starlette" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/10/a34c656829ffc1c4b22ef36d70d9ebb6b99c020e2aeb17cee5485099f028/sse_starlette-3.4.6.tar.gz", hash = "sha256:725f8a1bd6d26ae1b2c9610c0ef5065dfdd496f3988d28adcf8c4b49dc25c627", size = 32542, upload-time = "2026-07-20T14:16:32.201Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/36/e10c1d1b7ca881d2625db2ec28508578499187bb1c389952c398474e1834/sse_starlette-3.4.6-py3-none-any.whl", hash = "sha256:56217ab4c9a9f9c5db7b21e08732d3e7c2b807f45231ad23de0551a24c4a41f6", size = 16516, upload-time = "2026-07-20T14:16:30.978Z" }, +] + +[[package]] +name = "starlette" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6", size = 73632, upload-time = "2026-06-12T09:23:10.017Z" }, +] + [[package]] name = "tiktoken" version = "0.12.0" @@ -1511,6 +2750,51 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" }, ] +[[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/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { 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 = "tomli-w" version = "1.2.0" @@ -1520,6 +2804,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" }, ] +[[package]] +name = "tomlkit" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/af/14b24e41977adb296d6bd1fb59402cf7d60ce364f90c890bd2ec65c43b5a/tomlkit-0.14.0.tar.gz", hash = "sha256:cf00efca415dbd57575befb1f6634c4f42d2d87dbba376128adb42c121b87064", size = 187167, upload-time = "2026-01-13T01:14:53.304Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/11/87d6d29fb5d237229d67973a6c9e06e048f01cf4994dee194ab0ea841814/tomlkit-0.14.0-py3-none-any.whl", hash = "sha256:592064ed85b40fa213469f81ac584f67a4f2992509a7c3ea2d632208623a3680", size = 39310, upload-time = "2026-01-13T01:14:51.965Z" }, +] + [[package]] name = "tqdm" version = "4.67.3" @@ -1568,6 +2861,24 @@ 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.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/ff/5a28bdfd8c3ebec42564ac7d0e54ca3db65044a9314a97f9564fa7a1e926/tzdata-2026.3.tar.gz", hash = "sha256:4a1518b8993086a7982523e071643f3c0e5f213e75b21318e78bcabfff9d1415", size = 198674, upload-time = "2026-07-10T08:50:37.887Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/6d/b53b99a9f2766d095985947a5782f1702cabb129a34f7a802d7197af832f/tzdata-2026.3-py2.py3-none-any.whl", hash = "sha256:dc096730c87af6cab1b171c9d532be840741ff5d459015e7f6947bd7d7e54931", size = 348168, upload-time = "2026-07-10T08:50:36.46Z" }, +] + +[[package]] +name = "uncalled-for" +version = "0.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/82/345cc927f7fbdae6065e7768759932fcc827fc20b29b45dfbafa2f1f7da4/uncalled_for-0.3.2.tar.gz", hash = "sha256:89f5dbcd71e2b8f47c030b1fa302e6cce2ec795d1ac565eeb6525c5fe55cb8a2", size = 50032, upload-time = "2026-05-06T13:38:25.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/25/2c87754f3a9e692315f7b811244090e68f362979fc8886b3fbd2985a1d8c/uncalled_for-0.3.2-py3-none-any.whl", hash = "sha256:0ff60b142c7d1f8070bde9d42afaa70aedc77dcc10998c227687e9c15713418e", size = 11444, upload-time = "2026-05-06T13:38:24.025Z" }, +] + [[package]] name = "urllib3" version = "2.6.3" @@ -1577,6 +2888,224 @@ 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 = "uvicorn" +version = "0.51.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a2/65/b7c6c443ccc58678c91e1e973bbe2a878591538655d6e1d47f24ba1c51f3/uvicorn-0.51.0.tar.gz", hash = "sha256:f6f4b69b657c312f516dd2d268ab9ae6f254b11e4bac504f37b2ab58b24dd0b0", size = 94412, upload-time = "2026-07-08T10:59:05.962Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/ec/dbb7e5a6b91f86bfb9eb7d2988a2730907b6a729875b949c7f022e8b88fa/uvicorn-0.51.0-py3-none-any.whl", hash = "sha256:5d38af6cd620f2ae3849fb44fd4879e0890aa1febe8d47eb355fb45d93fe6a5b", size = 73219, upload-time = "2026-07-08T10:59:04.44Z" }, +] + +[package.optional-dependencies] +standard = [ + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" }, + { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" }, + { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" }, + { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" }, + { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" }, + { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" }, + { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" }, + { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" }, + { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" }, + { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" }, + { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" }, + { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" }, + { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" }, + { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" }, + { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" }, + { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" }, + { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" }, + { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" }, + { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" }, + { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" }, + { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" }, + { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" }, + { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" }, + { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" }, + { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" }, + { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" }, + { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" }, + { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" }, + { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" }, + { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" }, + { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" }, + { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" }, + { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" }, + { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" }, + { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" }, + { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" }, + { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" }, + { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" }, + { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" }, + { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" }, + { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" }, + { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" }, + { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" }, + { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" }, + { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" }, + { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" }, + { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" }, + { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" }, + { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" }, + { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" }, + { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" }, + { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" }, + { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" }, + { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" }, + { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" }, + { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" }, + { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" }, + { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" }, + { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" }, + { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" }, + { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" }, + { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" }, + { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" }, + { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" }, + { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" }, + { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" }, + { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" }, + { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" }, + { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" }, + { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" }, + { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" }, + { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" }, + { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" }, + { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" }, + { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" }, +] + +[[package]] +name = "websockets" +version = "16.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/f7/bc3a25c5ec26ce62ce487690becc2f3710bbc7b33338f005ad390db0b986/websockets-16.1.1.tar.gz", hash = "sha256:db234eda965dcce15df96bb9709f587cd87d4d52aaf0e80e2f34ec04c7670c57", size = 182204, upload-time = "2026-07-17T22:51:05.858Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/9d/681cda21c9eee743203a6cb79b9d3d05adad9aa60ec660c6c9bf4dd619ca/websockets-16.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:cc97814dfb786a83b6e2dc2e79351e1b83e6d715647d6887fcabd83026417a00", size = 179600, upload-time = "2026-07-17T22:49:13.92Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8d/6195a88b45e8d2a8f745fc2046e36f885a3c9763e6767d2c46229bf9510c/websockets-16.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e047dc87ef7ca50f4d309bf775ad4a71711c58556d75d7bd0604b2317f43e94b", size = 177272, upload-time = "2026-07-17T22:49:15.453Z" }, + { url = "https://files.pythonhosted.org/packages/73/e3/fe2d498c64dea0095c9a9f9a351af4cd6eef31b618395582bc1f38ba45ff/websockets-16.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:01fbdcbac298efe19360b94bc0039c8f746f0220ba570f327577bfee81059175", size = 177542, upload-time = "2026-07-17T22:49:16.875Z" }, + { url = "https://files.pythonhosted.org/packages/fe/ed/f1831681fce0e3242346e5458486003c5f124ed69e5e0b847fd029db4973/websockets-16.1.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0f62863e8a00a6d33c3d6566ec0b89f23787b747ffe0c3bc71ec0e76b82c94b1", size = 187137, upload-time = "2026-07-17T22:49:18.323Z" }, + { url = "https://files.pythonhosted.org/packages/6f/79/4ff9dcc1bb46f6b4c536936dde1fd60f9b564f3304307274db97f4c9496d/websockets-16.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8087e82f842609734c9b5a1330464f8e94e346ba0e18c832c08bafa4b0d63c15", size = 188374, upload-time = "2026-07-17T22:49:19.65Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/5c49b6efb36cab733d23773f6de575e1dba65736ead17d5d2b2a1daef779/websockets-16.1.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2bb5d041a8307d2e18782e7ce777f6fdb1e8c2f5d09291484b18c294b789d9aa", size = 191155, upload-time = "2026-07-17T22:49:21.331Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f6/56ccceda3a4838d18f1d40821480da4775397e8b1eecf4031e20c50e2e90/websockets-16.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1db4de4a0e95673f7545d393c49eeb0c2f18ac1ef93073218c79d5cdb2ee75ab", size = 189011, upload-time = "2026-07-17T22:49:22.889Z" }, + { url = "https://files.pythonhosted.org/packages/86/d6/ad5286241a2bce1107e2798d3bfbd62cf79aee167bdb654f8cb1e9dbf949/websockets-16.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f17dbe07eb3ea7f99e4df9b7e0efefe80fbf30d37a8cc4d561a0aed310bc8847", size = 187766, upload-time = "2026-07-17T22:49:24.339Z" }, + { url = "https://files.pythonhosted.org/packages/bc/67/d65c970b7e347fdca69479beb7811c2060529956730a7a4e3ae7c66b0e31/websockets-16.1.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4b57693728576d84ede0a77987ab16881b783d2cd9f1dc180a8fbbc3f79c4428", size = 185173, upload-time = "2026-07-17T22:49:25.743Z" }, + { url = "https://files.pythonhosted.org/packages/1d/5b/14af3cd4ee69d8ea9baca58f3dc3cfb1ba78332a347fd478cb096549d60e/websockets-16.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2a636ff1e7a5c4edf71ef0e79adae7f25dba93b4fcbe3dc958733477ffeb0eaf", size = 187809, upload-time = "2026-07-17T22:49:27.147Z" }, + { url = "https://files.pythonhosted.org/packages/7b/11/be301710d70de97e3e7b3586e6d492c9c06d6a61bf1c2202c36cf0c75607/websockets-16.1.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d6bec75c290fe484a8ba4cacdf838501e17c06ecfbbf31eede81a9e431bd7751", size = 186412, upload-time = "2026-07-17T22:49:28.611Z" }, + { url = "https://files.pythonhosted.org/packages/db/07/fe1435bf6fe738a3d3b54dbe0c18dabf12cba4d909ac8b58b539ce27c1f4/websockets-16.1.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:54509b8e92fee4453e152b7558ddef37ce9705a044922f2095a6105e3f80c96f", size = 188290, upload-time = "2026-07-17T22:49:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/8a/0a/81f394aff8efcbb01208c1ced77df0a3c7fcce584a88c7273663697946c2/websockets-16.1.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:f0aa4aad3b1b69ad3fd85a0fd0952ec64331c762bd77ec51cc814170873890b2", size = 185844, upload-time = "2026-07-17T22:49:31.447Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/dd485b995473f415510251fe9bd708f2d24458f439fce958daf8d66dc7c6/websockets-16.1.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:42290eb6db4ccaca7012656738214f8514082fb6fa40cdeb61bb9a471b52e383", size = 186823, upload-time = "2026-07-17T22:49:33.104Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0b/f78de76ff446f1e66af12b43c48a35f31744de93cfdec2f4ea67d5d7bbf1/websockets-16.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:53260c8930da5771cec89439bff99c20c8cb03ddb9588b980697355a83cd4bd3", size = 187102, upload-time = "2026-07-17T22:49:34.616Z" }, + { url = "https://files.pythonhosted.org/packages/37/a1/4cf892007778eaf84ad162bfc98046e0ed89b63ac55949e3236626b2a23f/websockets-16.1.1-cp312-cp312-win32.whl", hash = "sha256:1d27fa8462ad6a1cb36206a3d0640b2333340def181fae11ed7f9adeaa5c0747", size = 179943, upload-time = "2026-07-17T22:49:36.213Z" }, + { url = "https://files.pythonhosted.org/packages/d9/de/6abe251d28c3a3f217096575400b27750b18e0b1d2fff3a2a239960fea07/websockets-16.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:b436f6ec4fc3a6b4237c84d3f83170ed2b40bb584222f0ac47a0c8a5921980c7", size = 180243, upload-time = "2026-07-17T22:49:37.626Z" }, + { url = "https://files.pythonhosted.org/packages/ce/fd/6ec6c6d2850aea25b1b2aa9901a016980bb87d01e89b3eb00470b1b5d471/websockets-16.1.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ab59169ace05dcb49a1d4118f0bde139557adf45091bd85747e36bf5de984dd1", size = 179587, upload-time = "2026-07-17T22:49:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/5f/d8/1d299d2dd34087db39831a34cc645ef8a6f89d78efada6983093513cd81c/websockets-16.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5e3b7d601f6f84156b08cc4a5e541c2b50ad7b36cfc302b657a12477c904a5df", size = 177272, upload-time = "2026-07-17T22:49:40.293Z" }, + { url = "https://files.pythonhosted.org/packages/3d/86/0a70d3ae2f0f2256bb41302d9804dbca65d4360281e7feb3e1f94102ac46/websockets-16.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cd2ca96a082a36964aca83e992f72abeb61b7306c1a6cba4c7d06a7b93750cac", size = 177530, upload-time = "2026-07-17T22:49:41.786Z" }, + { url = "https://files.pythonhosted.org/packages/b5/c2/c676c69444d9db448b3f0a55a98dcc534affce0bce961d9d2f0b8499b10a/websockets-16.1.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f5d497865f05bb222cab7016c6034542e84e5f29f49c6fd3f4939cda7197b5b8", size = 187197, upload-time = "2026-07-17T22:49:43.658Z" }, + { url = "https://files.pythonhosted.org/packages/0b/13/88137fbaf726ebe29d62c1117fa11fa2bbb6209dc79d4ad738efbe36a2aa/websockets-16.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bae954c382e013d5ea5b190d2830526bfa45ad121c326da0049b8c769f185db6", size = 188433, upload-time = "2026-07-17T22:49:45.147Z" }, + { url = "https://files.pythonhosted.org/packages/01/6d/46c2f2ce6751cb26f39293e1ecbf8544cb01321397cd476c2756b98c216d/websockets-16.1.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e09f753a169951eb4f28c2c774f71069304f66e7277e0f5a2892423599cfa854", size = 189868, upload-time = "2026-07-17T22:49:46.581Z" }, + { url = "https://files.pythonhosted.org/packages/29/2b/170a9e8097636cfde4dc3c592b6e00b18a44a2f5407606d96ca542dd5838/websockets-16.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:024193f8551a2b0eafbdd160911012c4e6c228c28430c84433253299a9e42d6a", size = 189059, upload-time = "2026-07-17T22:49:47.972Z" }, + { url = "https://files.pythonhosted.org/packages/a7/48/f0d4ebc9ab4b473b8861b9e20fdb663d515d42f7befdf62cdb60fee7a1ec/websockets-16.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:aabe464bfd13bd25f4821faf111da6fefdc389f870265a53105580e45b0a2e49", size = 187814, upload-time = "2026-07-17T22:49:49.344Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ba/39a41d3ae8e72696a9492581900611c5a91e2b07563b0bcd2523adea9854/websockets-16.1.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a28fcbc9b6baf54a2e23f8655f308e4ccc6afdd7266f8fe7954f320dcda0f785", size = 185229, upload-time = "2026-07-17T22:49:50.787Z" }, + { url = "https://files.pythonhosted.org/packages/3c/36/ac15b604f850d1907f0a85ed721cefe47cd45034b3620069b829746cccbe/websockets-16.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:79eace538c6a97e96d0d03d4f9d314f9677f5ed85a8a984992ffd90b13cb8a56", size = 187874, upload-time = "2026-07-17T22:49:52.228Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f3/3fbd5d71d59299c3770faa5884d4f45070236ca5a35ab3a61830812c409a/websockets-16.1.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:496af849a472b531f758dbd4d61338f5000538cb1a7b3d20d9d32a264517f509", size = 186469, upload-time = "2026-07-17T22:49:53.776Z" }, + { url = "https://files.pythonhosted.org/packages/b4/fc/dd90349bba58af2a53ef2ddd9c32716c81eb6d59a0687939fff561860878/websockets-16.1.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5283810d2646741a0d8da2aa733d6aefa0545809afccb2a5d105a26bc45125f1", size = 188347, upload-time = "2026-07-17T22:49:55.202Z" }, + { url = "https://files.pythonhosted.org/packages/4c/f3/f73ba86427682da59b78c11d77ba56d5b801c32e84afe79b274bbd6a9bb2/websockets-16.1.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4e3b680b1e0a27457e727a0d572fd81dffa87b6dbf8b228ab57da64f7d85aead", size = 185903, upload-time = "2026-07-17T22:49:56.75Z" }, + { url = "https://files.pythonhosted.org/packages/34/7c/f95eb20e80104173b3a0a092291f89ea4047ef6e608e0a57ca06eb14eecb/websockets-16.1.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:69159730a823dde3ea8d08783e8d47ef135a6d7e8d44eb127e32b321c9db8e3e", size = 186855, upload-time = "2026-07-17T22:49:58.467Z" }, + { url = "https://files.pythonhosted.org/packages/b0/35/dd875b3e050ff232d60fa377707f890e369f74d134f1be32e8f68879747c/websockets-16.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ed5bb271084b46530ee2ddc0410537a9961152c5ccba2fc98c5276d992ccba87", size = 187140, upload-time = "2026-07-17T22:50:00.016Z" }, + { url = "https://files.pythonhosted.org/packages/e8/dc/5cbfcb41824502f6af93b8f3943a4d06c67c23c7d2e31eb18748c4a5b2a7/websockets-16.1.1-cp313-cp313-win32.whl", hash = "sha256:cfb70b4eb56cac4da0a83588f3ad50d46beb0690391082f3d4e2d488c70b68ea", size = 179928, upload-time = "2026-07-17T22:50:01.685Z" }, + { url = "https://files.pythonhosted.org/packages/b0/c1/71e5deb5b7f8f226997ab64908c184ac3105c0155ce2d486f318e5dd08a8/websockets-16.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:d9531d9cbeac99af6f038fb1bc351403531f7d634a2c2e10e2f7c854c6ed5b68", size = 180242, upload-time = "2026-07-17T22:50:03.117Z" }, + { url = "https://files.pythonhosted.org/packages/73/a2/ba78a164eeea4620df4a4df4bd2ed6017438c4655cc0f36f2c0bc0432355/websockets-16.1.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:443aefe96b7fdb132e2a70806cca1f2af49bb3f28e47abcd7c2e9dcf4d8fa1b8", size = 179635, upload-time = "2026-07-17T22:50:05.001Z" }, + { url = "https://files.pythonhosted.org/packages/b9/08/d26d7a7628cd4ac34cbbdb63ac80914ca842ed8e42938c40a53567806df3/websockets-16.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6456ff333092d509127d75a638cb411afae8ff17f092635015d1902efec8a293", size = 177320, upload-time = "2026-07-17T22:50:06.427Z" }, + { url = "https://files.pythonhosted.org/packages/0f/45/ebec83e6269536aa5932533c67b0af5c781f3e73fdbcd68672dcf43f4f44/websockets-16.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fce6c48559c86d1ac3632ccb1bebc7d5442fbe79bd9bb0e40379ee54be2a4051", size = 177544, upload-time = "2026-07-17T22:50:07.834Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d5/abc614d2297f6c1c3e01e61260364457a47c25cc1cf6a879038902bc6aa8/websockets-16.1.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:92b820d345f7a3fc7b8163949ee92df910f290c3fc517b3d5301c78065adafe1", size = 187270, upload-time = "2026-07-17T22:50:09.275Z" }, + { url = "https://files.pythonhosted.org/packages/52/71/4c99af3b87dff1b2927981f6876607d4acb45338c665242168d3982f7758/websockets-16.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a606d9c24035242a3e256e9d5b77ed9cd6bccfcb7cf993e5ca3c0f6f68fb6a7", size = 188509, upload-time = "2026-07-17T22:50:10.722Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b4/5c8ca14b0df7eb84ed0524165c5359150210140817a3312aee57bf62a1cf/websockets-16.1.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:414e596c75f74e0994084694189d7dc9229fb278e33064d6784b73ffbba3ca31", size = 189882, upload-time = "2026-07-17T22:50:12.293Z" }, + { url = "https://files.pythonhosted.org/packages/25/c1/bedfba9e70557129cb8083748d167bdcc01483dedf0f0df143676df05cbe/websockets-16.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:536676848fc5961aca9d20389951f59169508f765637a172403dc5434d722fa0", size = 189114, upload-time = "2026-07-17T22:50:13.789Z" }, + { url = "https://files.pythonhosted.org/packages/df/09/aa835b2787835aebd839114be5de51b797cb480b63ba42b26d34dfe147cb/websockets-16.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:97fd3a0e8b53efa41970ac1dff3d8cf0d2884cadeb4caaf95db7ad1526926ee3", size = 187861, upload-time = "2026-07-17T22:50:15.179Z" }, + { url = "https://files.pythonhosted.org/packages/20/26/f6408330694dbc9830857d9d23bc14ac4f6875127a480cfdda8d5ca21198/websockets-16.1.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7b1b19636af86a3c7995d4d028dbe376f39b4bf31541146f9c123582a6c94562", size = 185286, upload-time = "2026-07-17T22:50:16.741Z" }, + { url = "https://files.pythonhosted.org/packages/17/9a/e0675e70dd8a80762cf35bb18799d3f290a4890ffe6439bc51d222796083/websockets-16.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:41c8e77f17294c0ac18008a7309b99b34ee72247ef10b6dff4c3f8b5ac29896b", size = 187935, upload-time = "2026-07-17T22:50:18.213Z" }, + { url = "https://files.pythonhosted.org/packages/33/c1/3234cfb86afde01b81e9bddcc6e534c440975d60a13991259e833069ab3e/websockets-16.1.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:9f63bcef7f4b02b06b35fc01c93b96c43b5e88e1e8868676caacf493d5a31f3a", size = 186444, upload-time = "2026-07-17T22:50:19.67Z" }, + { url = "https://files.pythonhosted.org/packages/89/87/9c15206e1d778923d8daa9657de07aa62ea815e13448319c98458c37b281/websockets-16.1.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dab9eb87869da2d6ed3af3f3adf28414baae6ec9d4df355ffc18889132f3436c", size = 188409, upload-time = "2026-07-17T22:50:21.28Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/cf5de5c67676de2d3eef8b2a518f168f6796595447a5b7161ba0d012915c/websockets-16.1.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:43e3a9fdd7cbf7ba6040c31fae0faf84ca1474fef777c4e37912f1540f854499", size = 185958, upload-time = "2026-07-17T22:50:22.719Z" }, + { url = "https://files.pythonhosted.org/packages/62/c0/731b6ddede2e4136912ec4cff2cffbda35af73546be4762c3d7bd3bd79af/websockets-16.1.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:056ae37939ed7e9974f364f5864e76e49182622d8f9751ac1903c0d09b013985", size = 186911, upload-time = "2026-07-17T22:50:24.108Z" }, + { url = "https://files.pythonhosted.org/packages/8c/7f/39c634472c4469a24a7c09cecddffb08fac6d0e74f73881a94ee8a40a196/websockets-16.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a0eadbbf2c30f01efa58e1f110eb6fa293261f6b0b1aa38f7f48707107690af9", size = 187204, upload-time = "2026-07-17T22:50:25.548Z" }, + { url = "https://files.pythonhosted.org/packages/26/89/9667c256c256dafcc62d21328ce7a40067da857969b68ee9af375b0aaf72/websockets-16.1.1-cp314-cp314-win32.whl", hash = "sha256:195c978b065fa40910582464f99d6b15c8b314c68e0546549a55ed83f4735328", size = 179603, upload-time = "2026-07-17T22:50:27.086Z" }, + { url = "https://files.pythonhosted.org/packages/bd/dd/1c099d6c0fc5deb6b46ccdbb6981fdb4b12c917869cb3952408409dc18db/websockets-16.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:4e8d01cc3bcae7bbf8167f944aeafefed590fae5693552bba9794a9df68371cc", size = 179948, upload-time = "2026-07-17T22:50:28.521Z" }, + { url = "https://files.pythonhosted.org/packages/35/25/9956b2d5e0529d5d23924f21bba1440d4c5c88a562e4f08550871ffa97a7/websockets-16.1.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0ffd3031ea8bda8d61762e84220186105ba3b748b3c8da2ae4f7816fac03e573", size = 179963, upload-time = "2026-07-17T22:50:29.982Z" }, + { url = "https://files.pythonhosted.org/packages/17/06/55ffc976c488b6aee9ea05761ff7c4e88e7c1fd82818c8ca7b556ad2f90c/websockets-16.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:84a2cef8deffbd9ab8ee0ea546a2a6a7030c28f44e6cdd4547dbfeb489eb8999", size = 177497, upload-time = "2026-07-17T22:50:31.396Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/f7dac2e980bacc92bdc26cebae4ae4d50cae5380732c50980598fc0bbae4/websockets-16.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3df13f73af9b3b38ab1195eb299ecb67a4330c911c97ae04043ff74085728abe", size = 177698, upload-time = "2026-07-17T22:50:32.829Z" }, + { url = "https://files.pythonhosted.org/packages/b2/39/26762f734113e22da2b942c3aca85798e0c0405d64c256549540ff31e5a1/websockets-16.1.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:23253dd5bcae3f9aaee0a1d30967a8dbd52e5d3cff93a2e5b84df57b77d4750d", size = 187561, upload-time = "2026-07-17T22:50:34.24Z" }, + { url = "https://files.pythonhosted.org/packages/11/94/c3f330851806b9b02138b774d593478323e73c99238681b4b93efe64e02d/websockets-16.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1c5705e314449e3308872fe084b8571ce078ee4fc55a98a769bdefe5917392", size = 188732, upload-time = "2026-07-17T22:50:36.088Z" }, + { url = "https://files.pythonhosted.org/packages/d1/f2/eb2c450f052de334ae33cf200ece6e87b0e14d186807074e4eb1cd2cdea2/websockets-16.1.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:69e52d175a0a7d1e13b4b67ad41c560b7d98e8c6f6126eb0bda496c784faf8c7", size = 190872, upload-time = "2026-07-17T22:50:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/70/31/2ac8cecf3a74f7fed9132129fc3d90b3998a1554570c11a69b2a8c20332d/websockets-16.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1f79c89b5eb034d1722938a891916582f8f7f503f58ca22518a63c3f2cd18499", size = 189305, upload-time = "2026-07-17T22:50:39.53Z" }, + { url = "https://files.pythonhosted.org/packages/6a/cf/8ab19650d3c0d4562c92e70ab47c257c4aa5c6a713ed87fe63766b31fefc/websockets-16.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:39f2a024af5c345ffe8fcf1ee18c049c024c94df393bb09b044a6917c77bde43", size = 188033, upload-time = "2026-07-17T22:50:40.912Z" }, + { url = "https://files.pythonhosted.org/packages/66/d7/a49a38a6127a4acb134fb1912b215d900cc657605cff32445bf519f3acc4/websockets-16.1.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:952303a7318d4cbe1011400839bb2051c9f84fa0a35923267f5daba34b15d458", size = 185748, upload-time = "2026-07-17T22:50:42.559Z" }, + { url = "https://files.pythonhosted.org/packages/95/3e/ad1fa40388c7f2e0bb2c7930d0090b6c5498594bd1cdaec18864df3d9e97/websockets-16.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:249116b4a76063d930a46391ad56e135c286e4562a18309029fc2c73f4ed4c62", size = 188285, upload-time = "2026-07-17T22:50:43.974Z" }, + { url = "https://files.pythonhosted.org/packages/35/b8/d5db28ca264b9104f82196f92dc8843e35fd391f763d42e4ad358f5bc97e/websockets-16.1.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:61922544a0587a13fd3f53e4c0e5e606510c7b0d9d22c8444e5fae22a06b38cb", size = 186777, upload-time = "2026-07-17T22:50:45.474Z" }, + { url = "https://files.pythonhosted.org/packages/42/9c/726cb39d0cc43ae848dce4aa2acb04eecc6738b1264ec6d700bf6bcfb9f8/websockets-16.1.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:46dcaa042cd1de6c59e7d9269fa63ff7572b6df40510600b678f0826b3c7af51", size = 188682, upload-time = "2026-07-17T22:50:46.973Z" }, + { url = "https://files.pythonhosted.org/packages/be/c7/1168704de8c2dd483edabe4a22cbe4465dd8be8dd95561d214f9fe092871/websockets-16.1.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:38565aca3e01ea8734e578fb2118dade0ecb0250533f29e22b8d1a7a196cf4d0", size = 186377, upload-time = "2026-07-17T22:50:48.413Z" }, + { url = "https://files.pythonhosted.org/packages/ca/40/f9ff2d630ffce4e7dfea0b2288e1caf9ebbf9ff8a9ec9396136ce8b94935/websockets-16.1.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:42f599f4d48c7e1a3338fdaac3acd075be3b3cf02d4b274f3bf2767aedd3d217", size = 187148, upload-time = "2026-07-17T22:50:49.845Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/e177c8299f78d7cbe2d14df228643c10c70c0e86e108e092056bbcc16e46/websockets-16.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dcc04fedf83effaeb9cce98abc9469bb1b42ef85f03e01c8c1f4438ef7555737", size = 187578, upload-time = "2026-07-17T22:50:51.619Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/b6987faf330f5af5c787a2610124c2e8403d51724f9001ec4fff6311fe7a/websockets-16.1.1-cp314-cp314t-win32.whl", hash = "sha256:8483c2096363120eea8b07c06ae7304d520f686665fffd4811fad423930a65d7", size = 179729, upload-time = "2026-07-17T22:50:53.269Z" }, + { url = "https://files.pythonhosted.org/packages/a2/6e/fbac6ed878dd362fbad7d415fa4f84d38e3e33fed8cde45c64e783acf826/websockets-16.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:bcce07e23e5769375158f5efdcdafa8d5cd014b93c6683865b840ed65b96f231", size = 180072, upload-time = "2026-07-17T22:50:54.969Z" }, + { url = "https://files.pythonhosted.org/packages/be/4d/2d0d67834092e354d2b0498f014a41249a89556bc406cf86f3e1557bb463/websockets-16.1.1-py3-none-any.whl", hash = "sha256:6abbd3e82c731c8e531714466acd5d87b5e88ac3243465337ba71d68e23ae7e3", size = 173814, upload-time = "2026-07-17T22:51:04.184Z" }, +] + [[package]] name = "yarl" version = "1.23.0" From c998d761bc9f6ea7be433c8b4e86ce3cd7d2368b Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Tue, 28 Jul 2026 06:39:54 -0700 Subject: [PATCH 4/9] docs: note the exported environment was verified as a built container The Verified table now says what was actually run: docker build on the emitted Dockerfile, run with the host Docker socket mounted, then driven over the WebSocket API from 0.0 to 1.0 through an agent edit. --- docs/reference/OPENENV.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/docs/reference/OPENENV.md b/docs/reference/OPENENV.md index a768d476..dc9b8af5 100644 --- a/docs/reference/OPENENV.md +++ b/docs/reference/OPENENV.md @@ -199,9 +199,13 @@ three runtimes. They agree: On the OpenEnv side the working directory resolves to `/workspace` from the image, the scalar is read from `reward.txt`, and `reward-details.json` arrives intact as `observation.info["reward_details"]` (F2P/P2P counts, `resolved`, -`parse_status`). The exported environment was additionally driven end to end -over the WebSocket API — `reset` → `write_file` → `evaluate` — taking the same -task from 0.0 to 1.0 through an agent edit rather than the oracle. +`parse_status`). + +The exported environment was verified as a *built container*, not just in +process: `docker build` on the emitted Dockerfile, run with the host Docker +socket mounted, then driven over the WebSocket API — `reset` → `write_file` → +`evaluate` — taking the same task from 0.0 to 1.0 through an agent edit rather +than the oracle. ## Where the code lives From 869da874f8c3ebe892906f9ee0d7a3563fc9733c Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Tue, 28 Jul 2026 08:22:19 -0700 Subject: [PATCH 5/9] fix(openenv): port four defects found by bot review of the sibling OpenEnv PR MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Automated reviewers went over huggingface/OpenEnv#1018, which carries a structurally parallel runtime. All four findings applied here too — this repo just had no bot looking at it. 1. reset() left the previous episode in state close() tears the container down first, but _state was only replaced after tasks.get() and sandbox.start(), either of which can raise. A failed reset reported a task_id, workdir and reward for an episode that was gone. Now drops to a clean Repo2RLEnvState before the fallible work. 2. DockerSandbox.upload_dir() archived nested files twice rglob("*") yields directories as well as files and tarfile.add() recurses by default, so anything nested was added once via its parent and again on its own iteration. Passes recursive=False; directory entries are still emitted, so nested staging (e.g. the tests/verifier.py + tests/*.json layout our pipelines emit as aux_files) keeps working. 3. Degenerate paths resolved to the checkout itself Repo2RLEnvAction.path defaults to "", and resolve_within() resolved "", ".", " " and "a/.." to the working directory. For read that meant catting a directory; for write it was destructive — the target split into ("/", "workspace"), so an empty path would have dropped a regular file over the entire checkout. Rejected in resolve_within(), the single chokepoint every agent-supplied path passes through. 4. AGENT_ACTIONS / CONTROL_ACTIONS were decorative Exported but never referenced, and the test asserting them merely restated the same literals, so it would have passed no matter what the server handled. ActionType is now composed from AgentActionType | ControlActionType rather than restating the five strings, and the test asserts the two sets are a partition of the environment's actual handler table. Verification: each regression test was confirmed to fail against the unfixed code before being kept. Also re-ran the Docker end-to-end with a task whose tests/ has a nested subdirectory — the verifier reads tests/helpers/score.py, proving recursive=False did not break nested staging — and confirmed an empty write is now rejected with the checkout left intact. Tests: 39 (6 added). Full suite 739 passed. --- src/repo2rlenv/openenv/environment.py | 6 ++ src/repo2rlenv/openenv/models.py | 24 ++++--- src/repo2rlenv/openenv/sandbox.py | 24 ++++++- tests/test_openenv_export.py | 92 ++++++++++++++++++++++++++- 4 files changed, 133 insertions(+), 13 deletions(-) diff --git a/src/repo2rlenv/openenv/environment.py b/src/repo2rlenv/openenv/environment.py index a6370fcd..ba2d387d 100644 --- a/src/repo2rlenv/openenv/environment.py +++ b/src/repo2rlenv/openenv/environment.py @@ -98,6 +98,12 @@ def reset( del seed self.close() + # A failed reset must not leave the previous episode in state: close() + # has already torn the container down, so anything read from `state` + # after a raise below would describe a task that is not running. + self._state = Repo2RLEnvState() + self._refresh_dataset_state() + task = self.tasks.get(self._select_task_id(kwargs.get("task_id"))) sandbox = self._sandbox_factory() try: diff --git a/src/repo2rlenv/openenv/models.py b/src/repo2rlenv/openenv/models.py index 8671e489..b7e3f45d 100644 --- a/src/repo2rlenv/openenv/models.py +++ b/src/repo2rlenv/openenv/models.py @@ -8,21 +8,27 @@ from __future__ import annotations -from typing import Any, Literal +from typing import Any, Literal, get_args from openenv.core.env_server.types import Action, Observation, State from pydantic import Field -#: What an agent may do while solving the task. -AGENT_ACTIONS: frozenset[str] = frozenset({"exec", "read", "write"}) +#: Actions an agent may take while solving the task. +AgentActionType = Literal["exec", "read", "write"] -#: Reserved for training orchestration. `evaluate` grades the episode and ends -#: it; `solve` applies the task's own oracle patch. Neither belongs to the -#: agent's action space — an agent that could grade or solve on demand would be -#: able to end its own episode or read out the answer. -CONTROL_ACTIONS: frozenset[str] = frozenset({"evaluate", "solve"}) +#: Actions reserved for training orchestration. `evaluate` grades the episode +#: and ends it; `solve` applies the task's own oracle patch. Neither belongs to +#: the agent's action space — an agent that could grade or solve on demand +#: would be able to end its own episode or read out the answer. +ControlActionType = Literal["evaluate", "solve"] -ActionType = Literal["exec", "read", "write", "evaluate", "solve"] +AGENT_ACTIONS: frozenset[str] = frozenset(get_args(AgentActionType)) +CONTROL_ACTIONS: frozenset[str] = frozenset(get_args(ControlActionType)) + +#: Every action the server accepts. Composed from the two above rather than +#: restated, so the wire schema and the agent/orchestration split cannot drift: +#: a new action has to be classified as one or the other to exist at all. +ActionType = AgentActionType | ControlActionType class Repo2RLEnvAction(Action): diff --git a/src/repo2rlenv/openenv/sandbox.py b/src/repo2rlenv/openenv/sandbox.py index f5abb274..68c79078 100644 --- a/src/repo2rlenv/openenv/sandbox.py +++ b/src/repo2rlenv/openenv/sandbox.py @@ -180,7 +180,14 @@ def upload_dir(self, source: Path, destination: str) -> None: stream = io.BytesIO() with tarfile.open(fileobj=stream, mode="w") as archive: for entry in sorted(source.rglob("*")): - archive.add(entry, arcname=entry.relative_to(source).as_posix()) + # rglob yields directories as well as files, and `add` recurses + # by default — leaving it on archives every nested file once + # via its parent and again on its own iteration. + archive.add( + entry, + arcname=entry.relative_to(source).as_posix(), + recursive=False, + ) container.put_archive(destination, stream.getvalue()) def mkdirs(self, *paths: str) -> None: @@ -308,13 +315,24 @@ def resolve_within(base: str, relative: str) -> str: outside the checkout — in particular it cannot reach /tests or /solution. Raises: - ValueError: if `relative` is absolute or escapes `base`. + ValueError: if `relative` is empty, is absolute, names the checkout + itself, or escapes `base`. """ + if not relative.strip(): + raise ValueError("path must name a file relative to the working directory") if posixpath.isabs(relative): raise ValueError(f"path must be relative to the working directory: {relative!r}") base_norm = posixpath.normpath(base) target = posixpath.normpath(posixpath.join(base_norm, relative)) - if target != base_norm and not target.startswith(base_norm.rstrip("/") + "/"): + if target == base_norm: + # "", "." and "a/.." all land here. A read would try to cat a + # directory; a write is worse — the target splits into ("/", + # "workspace"), dropping a regular file over the whole checkout. + raise ValueError( + f"path must name a file inside the working directory, not the " + f"directory itself: {relative!r}" + ) + if not target.startswith(base_norm.rstrip("/") + "/"): raise ValueError(f"path escapes the working directory: {relative!r}") return target diff --git a/tests/test_openenv_export.py b/tests/test_openenv_export.py index 6b32a216..fa9ca47e 100644 --- a/tests/test_openenv_export.py +++ b/tests/test_openenv_export.py @@ -358,14 +358,104 @@ def test_agent_paths_inside_the_workspace_resolve(relative: str): assert resolve_within("/workspace", relative).startswith("/workspace") +@pytest.mark.parametrize("relative", ["", " ", ".", "a/.."]) +def test_agent_paths_cannot_name_the_workspace_itself(relative: str): + """A degenerate path must not resolve to the checkout directory. + + `Repo2RLEnvAction.path` defaults to "", so this is reachable by simply + omitting the field. A read would try to cat a directory; a write is worse — + the target splits into ("/", "workspace"), dropping a regular file over the + entire checkout. + """ + pytest.importorskip("openenv") + from repo2rlenv.openenv.sandbox import resolve_within + + with pytest.raises(ValueError): + resolve_within("/workspace", relative) + + +def test_docker_upload_dir_archives_each_entry_once(tmp_path: Path, monkeypatch): + """`rglob` yields directories too, and `tarfile.add` recurses by default. + + Left alone, every nested file is archived once through its parent directory + and again on its own iteration. + """ + pytest.importorskip("openenv") + import io + import tarfile + + from repo2rlenv.openenv.sandbox import DockerSandbox + + source = tmp_path / "tests" + (source / "nested").mkdir(parents=True) + (source / "test.sh").write_text("#!/bin/bash\n", encoding="utf-8") + (source / "nested" / "verifier.py").write_text("x = 1\n", encoding="utf-8") + + captured: dict[str, bytes] = {} + + class _FakeContainer: + def put_archive(self, path: str, data: bytes) -> bool: + captured["data"] = data + return True + + sandbox = DockerSandbox() + monkeypatch.setattr(sandbox, "_require_container", lambda: _FakeContainer()) + monkeypatch.setattr(sandbox, "mkdirs", lambda *args, **kwargs: None) + + sandbox.upload_dir(source, "/tests") + + with tarfile.open(fileobj=io.BytesIO(captured["data"])) as archive: + names = archive.getnames() + + assert sorted(names) == ["nested", "nested/verifier.py", "test.sh"] + assert len(names) == len(set(names)) + + +def test_failed_reset_does_not_leave_the_previous_episode_in_state(tmp_path: Path): + """reset() tears the container down before it can fail. + + Reporting the previous task afterwards would tell a trainer an episode is + running when nothing is. + """ + pytest.importorskip("openenv") + from repo2rlenv.openenv.environment import Repo2RLEnvEnvironment + + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + env = Repo2RLEnvEnvironment(dataset=str(dataset)) + + # Hand-populate state as a completed episode would leave it, without + # needing Docker to run one. + env._state.task_id = "demo__task-1" + env._state.workdir = "/workspace" + env._state.reward = 1.0 + env._state.evaluated = True + + with pytest.raises(KeyError): + env.reset(task_id="no-such-task") + + assert env._state.task_id == "" + assert env._state.workdir == "" + assert env._state.reward is None + assert not env._state.evaluated + # The dataset listing survives — it belongs to no single episode. + assert env._state.task_count == 1 + + def test_grading_and_solving_are_not_agent_actions(): - """An agent that could grade or solve on demand would break the boundary.""" + """An agent that could grade or solve on demand would break the boundary. + + The two sets must stay a partition of what the server actually handles: a + new action type nobody classified would silently read as agent-reachable. + """ pytest.importorskip("openenv") + from repo2rlenv.openenv.environment import Repo2RLEnvEnvironment from repo2rlenv.openenv.models import AGENT_ACTIONS, CONTROL_ACTIONS assert {"exec", "read", "write"} == AGENT_ACTIONS assert {"evaluate", "solve"} == CONTROL_ACTIONS assert not (AGENT_ACTIONS & CONTROL_ACTIONS) + assert set(Repo2RLEnvEnvironment()._handlers) == AGENT_ACTIONS | CONTROL_ACTIONS def test_action_schema_rejects_unknown_action_types(): From b28a5b4323ccc6216549bc45e0ba819df3bd853d Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Wed, 29 Jul 2026 06:48:59 -0700 Subject: [PATCH 6/9] fix(openenv): port the security hardening from the sibling OpenEnv PR MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A maintainer reviewed huggingface/OpenEnv#1018, which carries a structurally parallel runtime, and raised three issues. Two apply here in full; the third (local-mode escapes) does not, since this runtime is Docker-only. ## Task policies were ignored `dataset.py` now parses `[environment].network_mode` / `cpus` / `memory_mb` / `gpus` / `workdir` and `[agent].user` / `[verifier].user`, including the deprecated `allow_internet` spelling. `_container_limits()` translates them into `containers.run` kwargs: no-network becomes an isolated network, cpus/memory become real container limits, and each phase runs as its declared user. What cannot be enforced faithfully is refused rather than approximated — `allowlist` needs a filtering proxy and `gpus` needs accelerators, so both point the caller at `harbor run`. An unrecognized network_mode is a parse error, never a silent downgrade to `public`: quietly granting a sandboxed task the internet is the exact failure this prevents. Our pipelines do not emit these fields today, but the format allows them and a task that declares one was being run unconstrained and scored anyway. ## The episode never terminated, and the action split was decorative - After `evaluate`, `step()` refused nothing: a later `exec` returned `done=False`, contradicting a terminal state already reported to the caller. The episode is now terminal until `reset()`. - `allow_control_actions` (env `REPO2RLENV_ALLOW_CONTROL_ACTIONS=0`) makes the server refuse `evaluate`/`solve`, so the agent/orchestration split is enforced rather than left to the caller's wiring. ## Two leaks found while verifying the above - `HARBOR_TESTS_DIR` / `HARBOR_SOLUTION_DIR` / `HARBOR_LOGS_DIR` were exported into agent commands, handing a policy the location of the grading logic and the answer. `SandboxPaths.as_env(agent_visible=True)` withholds them; the verifier and oracle still receive the full set. - `stage_tests` / `stage_solution` now wipe the destination first. The agent shares the container and can pre-create `/tests`; anything planted there previously survived staging and was read by the verifier. Tests: 6 added (45 total). Full suite 740 passed. `tests/test_e2e_public.py:: test_e2e_public_trl` fails on a clean tree too — it queries live GitHub and TRL's two most recent PRs are currently docs-only. --- src/repo2rlenv/openenv/dataset.py | 56 +++++++++++++ src/repo2rlenv/openenv/environment.py | 55 ++++++++++++- src/repo2rlenv/openenv/sandbox.py | 99 ++++++++++++++++++++--- tests/test_openenv_export.py | 109 ++++++++++++++++++++++++++ 4 files changed, 304 insertions(+), 15 deletions(-) diff --git a/src/repo2rlenv/openenv/dataset.py b/src/repo2rlenv/openenv/dataset.py index f28b690f..c564ff45 100644 --- a/src/repo2rlenv/openenv/dataset.py +++ b/src/repo2rlenv/openenv/dataset.py @@ -39,6 +39,14 @@ class TaskFormatError(ValueError): """Raised when a directory is not a well-formed Repo2RLEnv task.""" +#: Harbor's network policies, from `[environment].network_mode`. +NETWORK_NONE = "no-network" +NETWORK_PUBLIC = "public" +NETWORK_ALLOWLIST = "allowlist" + +_NETWORK_MODES = frozenset({NETWORK_NONE, NETWORK_PUBLIC, NETWORK_ALLOWLIST}) + + @dataclass(frozen=True) class Repo2RLEnvTask: """One emitted task directory, parsed. @@ -74,6 +82,13 @@ class Repo2RLEnvTask: metadata: dict[str, Any] = field(default_factory=dict) agent_timeout_s: float = DEFAULT_AGENT_TIMEOUT_S verifier_timeout_s: float = DEFAULT_VERIFIER_TIMEOUT_S + network_mode: str = NETWORK_PUBLIC + cpus: int | None = None + memory_mb: int | None = None + gpus: int | None = None + agent_user: str | None = None + verifier_user: str | None = None + declared_workdir: str | None = None # --- layout ------------------------------------------------------------- @@ -175,6 +190,7 @@ def load(cls, path: str | Path, task_id: str | None = None) -> Repo2RLEnvTask: metadata = _table(config, "metadata") repo2env = _table(metadata, "repo2env") repro = _table(repo2env, "reproducibility") + environment = _table(config, "environment") instruction_path = task_dir / INSTRUCTION_FILE instruction = ( @@ -202,6 +218,13 @@ def load(cls, path: str | Path, task_id: str | None = None) -> Repo2RLEnvTask: metadata=repo2env, agent_timeout_s=_timeout(config, "agent", DEFAULT_AGENT_TIMEOUT_S), verifier_timeout_s=_timeout(config, "verifier", DEFAULT_VERIFIER_TIMEOUT_S), + network_mode=_network_mode(environment), + cpus=_positive_int(environment.get("cpus")), + memory_mb=_positive_int(environment.get("memory_mb")), + gpus=_positive_int(environment.get("gpus")), + agent_user=_user(_table(config, "agent").get("user")), + verifier_user=_user(_table(config, "verifier").get("user")), + declared_workdir=str(environment["workdir"]) if environment.get("workdir") else None, ) @@ -274,6 +297,39 @@ def _scan(self) -> dict[str, Path]: return found +def _network_mode(environment: dict[str, Any]) -> str: + """Read `[environment].network_mode`, honouring the deprecated spelling. + + An unrecognized value is a parse error rather than a silent downgrade to + `public` — quietly granting a sandboxed task the internet is exactly the + failure this parsing exists to prevent. + """ + raw = environment.get("network_mode") + if raw is None: + return NETWORK_NONE if environment.get("allow_internet") is False else NETWORK_PUBLIC + mode = str(raw).strip().lower() + if mode not in _NETWORK_MODES: + raise TaskFormatError( + f"unknown network_mode {raw!r}; expected one of {sorted(_NETWORK_MODES)}" + ) + return mode + + +def _user(value: Any) -> str | None: + """`[agent].user` / `[verifier].user`, which Harbor allows as a name or UID.""" + if value is None or (isinstance(value, str) and not value.strip()): + return None + return str(value).strip() + + +def _positive_int(value: Any) -> int | None: + try: + parsed = int(value) # type: ignore[arg-type] + except (TypeError, ValueError): + return None + return parsed if parsed > 0 else None + + def _table(config: dict[str, Any], key: str) -> dict[str, Any]: value = config.get(key) return dict(value) if isinstance(value, dict) else {} diff --git a/src/repo2rlenv/openenv/environment.py b/src/repo2rlenv/openenv/environment.py index ba2d387d..d7af3802 100644 --- a/src/repo2rlenv/openenv/environment.py +++ b/src/repo2rlenv/openenv/environment.py @@ -21,7 +21,12 @@ from openenv.core.env_server.interfaces import Environment from repo2rlenv.openenv.dataset import Repo2RLEnvTask, TaskSet -from repo2rlenv.openenv.models import Repo2RLEnvAction, Repo2RLEnvObservation, Repo2RLEnvState +from repo2rlenv.openenv.models import ( + CONTROL_ACTIONS, + Repo2RLEnvAction, + Repo2RLEnvObservation, + Repo2RLEnvState, +) from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult, SandboxError, resolve_within logger = logging.getLogger(__name__) @@ -61,10 +66,19 @@ def __init__( dataset: str | None = None, default_task_id: str | None = None, command_timeout_s: float = DEFAULT_COMMAND_TIMEOUT_S, + allow_control_actions: bool | None = None, sandbox_factory: Callable[[], DockerSandbox] | None = None, ) -> None: super().__init__() self.command_timeout_s = command_timeout_s + self.allow_control_actions = ( + allow_control_actions + if allow_control_actions is not None + else ( + os.getenv("REPO2RLENV_ALLOW_CONTROL_ACTIONS", "1").strip().lower() + not in {"0", "false", "no", "off"} + ) + ) self.default_task_id = default_task_id or os.getenv("REPO2RLENV_DEFAULT_TASK_ID") or None self._sandbox_factory = sandbox_factory or DockerSandbox self.tasks = TaskSet(_resolve_dataset(dataset)) @@ -125,7 +139,15 @@ def reset( ) self._refresh_dataset_state() - return self._observe("reset", output="", info={"task": task.summary()}) + return self._observe( + "reset", + output="", + info={ + "task": task.summary(), + # Agent-visible paths only — the observation reaches the policy. + "paths": sandbox.paths.as_env(agent_visible=True), + }, + ) def step( self, @@ -143,13 +165,33 @@ def step( self._state.last_action_type = action.action_type try: + if self._state.evaluated: + # `evaluate` ends the episode. Serving further actions would let + # a caller step past a terminal state and, worse, report + # done=False after already reporting done=True. + raise SandboxError( + "the episode ended when the verifier ran; call reset() to start another" + ) + if action.action_type in CONTROL_ACTIONS and not self.allow_control_actions: + raise PermissionError( + f"{action.action_type!r} is a training-orchestration control, not an " + "agent action; the server was started with " + "REPO2RLENV_ALLOW_CONTROL_ACTIONS=0" + ) sandbox, task = self._require_episode() return self._handlers[action.action_type](action, sandbox, task) except Exception as exc: # Invalid actions and sandbox failures come back in the observation # so a policy can recover; only server faults propagate. logger.info("action %s failed: %s", action.action_type, exc) - return self._observe(action.action_type, output="", success=False, error=str(exc)) + return self._observe( + action.action_type, + output="", + success=False, + error=str(exc), + # A terminated episode stays terminated — never walk done back. + done=self._state.evaluated, + ) @property def state(self) -> Repo2RLEnvState: @@ -171,7 +213,12 @@ def _do_exec( del task if not action.command.strip(): raise ValueError("exec requires a non-empty command") - result = sandbox.exec(action.command, timeout_s=action.timeout_s or self.command_timeout_s) + result = sandbox.exec( + action.command, + timeout_s=action.timeout_s or self.command_timeout_s, + user=sandbox.agent_user, + agent_visible=True, + ) return self._from_exec("exec", result) def _do_read( diff --git a/src/repo2rlenv/openenv/sandbox.py b/src/repo2rlenv/openenv/sandbox.py index 68c79078..3838c944 100644 --- a/src/repo2rlenv/openenv/sandbox.py +++ b/src/repo2rlenv/openenv/sandbox.py @@ -27,7 +27,11 @@ from dataclasses import dataclass from pathlib import Path -from repo2rlenv.openenv.dataset import Repo2RLEnvTask +from repo2rlenv.openenv.dataset import ( + NETWORK_ALLOWLIST, + NETWORK_NONE, + Repo2RLEnvTask, +) from repo2rlenv.openenv.reward import RewardReport, read_reward logger = logging.getLogger(__name__) @@ -74,18 +78,29 @@ def logs_verifier(self) -> str: def logs_agent(self) -> str: return posixpath.join(self.logs, "agent") - def as_env(self) -> dict[str, str]: + def as_env(self, *, agent_visible: bool = False) -> dict[str, str]: """Path layout exported to task scripts. Harbor-lineage scripts read `TEST_DIR`; ours use absolute paths, but exporting both keeps third-party tasks working unchanged. + + Args: + agent_visible: return only the paths an agent legitimately needs. + The verifier and oracle directories are withheld — that is where + the grading logic and the answer live, and only the verifier and + oracle themselves need to be told where they are. """ - return { + agent_paths = { "HARBOR_WORKDIR": self.workdir, + "HARBOR_AGENT_LOGS_DIR": self.logs_agent, + } + if agent_visible: + return agent_paths + return { + **agent_paths, "HARBOR_TESTS_DIR": self.tests, "HARBOR_SOLUTION_DIR": self.solution, "HARBOR_LOGS_DIR": self.logs_verifier, - "HARBOR_AGENT_LOGS_DIR": self.logs_agent, "TEST_DIR": self.tests, } @@ -98,6 +113,7 @@ class DockerSandbox: """ def __init__(self, keep_container: bool = False) -> None: + self.agent_user: str | None = None self.paths = SandboxPaths() self.keep_container = keep_container self._client = None @@ -122,8 +138,10 @@ def start(self, task: Repo2RLEnvTask) -> None: detach=True, labels={"repo2rlenv.task": task.task_id}, auto_remove=False, + **_container_limits(task), ) - self.paths = SandboxPaths(workdir=self._image_workdir(client)) + self.agent_user = task.agent_user + self.paths = SandboxPaths(workdir=task.declared_workdir or self._image_workdir(client)) self.mkdirs(self.paths.workdir, self.paths.logs_verifier, self.paths.logs_agent) def close(self) -> None: @@ -145,15 +163,24 @@ def exec( timeout_s: float, env: dict[str, str] | None = None, workdir: str | None = None, + user: str | None = None, + agent_visible: bool = False, ) -> ExecResult: - """Run `command` through bash and return its merged output.""" + """Run `command` through bash and return its merged output. + + Args: + user: account to run as, from `[agent].user` / `[verifier].user`. + agent_visible: whether this is the agent's own command. Agent + commands are not told where the verifier and oracle live. + """ container = self._require_container() - process_env = dict(self.paths.as_env()) + process_env = dict(self.paths.as_env(agent_visible=agent_visible)) process_env.update(env or {}) exit_code, output = container.exec_run( cmd=["bash", "-c", self._with_timeout(command, timeout_s)], workdir=workdir or self.paths.workdir, environment=process_env, + user=user or "", demux=False, ) text = output.decode("utf-8", errors="replace") if output else "" @@ -220,9 +247,13 @@ def run_verifier(self, task: Repo2RLEnvTask) -> ExecResult: # reward file that outlives a verifier which fails before writing one. self.exec(f"rm -rf {_quote(self.paths.logs_verifier)}", timeout_s=60.0, workdir="/") self.mkdirs(self.paths.logs_verifier) - self.upload_dir(task.tests_dir, self.paths.tests) + self._replace_dir(task.tests_dir, self.paths.tests) script = posixpath.join(self.paths.tests, task.test_script.name) - return self.exec(f"bash {_quote(script)}", timeout_s=task.verifier_timeout_s) + return self.exec( + f"bash {_quote(script)}", + timeout_s=task.verifier_timeout_s, + user=task.verifier_user, + ) def run_solution(self, task: Repo2RLEnvTask) -> ExecResult: """Stage `solution/` and run `solution/solve.sh` — the oracle. @@ -234,9 +265,22 @@ def run_solution(self, task: Repo2RLEnvTask) -> ExecResult: raise SandboxError( f"task {task.task_id!r} has no solution/solve.sh, so it has no oracle" ) - self.upload_dir(task.solution_dir, self.paths.solution) + self._replace_dir(task.solution_dir, self.paths.solution) script = posixpath.join(self.paths.solution, task.solve_script.name) - return self.exec(f"bash {_quote(script)}", timeout_s=task.agent_timeout_s) + return self.exec( + f"bash {_quote(script)}", + timeout_s=task.agent_timeout_s, + user=task.agent_user, + ) + + def _replace_dir(self, source: Path, destination: str) -> None: + """Upload `source` over a freshly emptied `destination`. + + The agent shares the container and can pre-create these paths; anything + it leaves behind must not survive into the verifier's view. + """ + self.exec(f"rm -rf {_quote(destination)}", timeout_s=60.0, workdir="/") + self.upload_dir(source, destination) def reward_report(self) -> RewardReport: """Read the verifier's verdict out of `/logs/verifier`.""" @@ -308,6 +352,39 @@ def _require_container(self): return self._container +def _container_limits(task: Repo2RLEnvTask) -> dict[str, object]: + """Translate a task's declared policies into `containers.run` kwargs. + + Raises: + SandboxError: if the task asks for something this backend cannot enforce + faithfully. Failing closed matters more than breadth: silently + granting a `no-network` task the daemon's default bridge would both + corrupt the result and hand a sandboxed process the internet. + """ + kwargs: dict[str, object] = {} + + if task.network_mode == NETWORK_ALLOWLIST: + raise SandboxError( + f"task {task.task_id!r} declares network_mode='allowlist', which needs a " + "filtering proxy this backend does not run. Grade it with `harbor run`." + ) + if task.network_mode == NETWORK_NONE: + kwargs["network_mode"] = "none" + + if task.cpus is not None: + # Docker expresses CPU count as a quota against a 100ms period. + kwargs["cpu_period"] = 100_000 + kwargs["cpu_quota"] = int(task.cpus * 100_000) + if task.memory_mb is not None: + kwargs["mem_limit"] = f"{task.memory_mb}m" + if task.gpus is not None: + raise SandboxError( + f"task {task.task_id!r} requests {task.gpus} GPU(s); this backend does not " + "allocate accelerators. Grade it with `harbor run`." + ) + return kwargs + + def resolve_within(base: str, relative: str) -> str: """Resolve `relative` under `base`, rejecting anything that escapes it. diff --git a/tests/test_openenv_export.py b/tests/test_openenv_export.py index fa9ca47e..85c7dd91 100644 --- a/tests/test_openenv_export.py +++ b/tests/test_openenv_export.py @@ -17,6 +17,7 @@ from repo2rlenv.emitter.openenv import EmitError, write_openenv_env from repo2rlenv.openenv.dataset import Repo2RLEnvTask, TaskFormatError, TaskSet from repo2rlenv.openenv.reward import read_reward +from repo2rlenv.openenv.sandbox import SandboxError # --------------------------------------------------------------------------- # helpers @@ -493,3 +494,111 @@ def test_client_round_trips_what_the_server_serializes(): action = Repo2RLEnvAction(action_type="write", path="a.py", content="x = 1\n") assert Repo2RLEnvAction.model_validate(client._step_payload(action)) == action + + +# --------------------------------------------------------------------------- +# task policies and episode termination +# --------------------------------------------------------------------------- + + +def test_network_and_resource_policies_are_parsed(tmp_path: Path): + path = _emit(tmp_path) + toml_path = path / "task.toml" + data = tomllib.loads(toml_path.read_text()) + data["environment"] = { + "network_mode": "no-network", + "cpus": 2, + "memory_mb": 512, + "workdir": "/srv/app", + } + data["agent"] = {"user": "agent", "timeout_sec": 1800.0} + toml_path.write_text(_dumps(data)) + + task = Repo2RLEnvTask.load(path) + + assert task.network_mode == "no-network" + assert task.cpus == 2 + assert task.memory_mb == 512 + assert task.agent_user == "agent" + assert task.declared_workdir == "/srv/app" + + +def test_unknown_network_mode_is_rejected_not_downgraded(tmp_path: Path): + """Treating an unrecognized mode as `public` is the bug to avoid.""" + path = _emit(tmp_path) + toml_path = path / "task.toml" + data = tomllib.loads(toml_path.read_text()) + data["environment"] = {"network_mode": "vpn"} + toml_path.write_text(_dumps(data)) + + with pytest.raises(TaskFormatError, match="network_mode"): + Repo2RLEnvTask.load(path) + + +def test_container_limits_translate_declared_policies(tmp_path: Path): + pytest.importorskip("openenv") + from dataclasses import replace + + from repo2rlenv.openenv.sandbox import _container_limits + + task = Repo2RLEnvTask.load(_emit(tmp_path)) + + assert _container_limits(task) == {} + limits = _container_limits(replace(task, network_mode="no-network", cpus=2, memory_mb=512)) + assert limits["network_mode"] == "none" + assert limits["cpu_quota"] == 200_000 + assert limits["mem_limit"] == "512m" + + with pytest.raises(SandboxError, match="allowlist"): + _container_limits(replace(task, network_mode="allowlist")) + with pytest.raises(SandboxError, match="GPU"): + _container_limits(replace(task, gpus=1)) + + +def test_agent_is_not_told_where_the_verifier_lives(): + """`/tests` holds the grading logic and `/solution` holds the answer.""" + pytest.importorskip("openenv") + from repo2rlenv.openenv.sandbox import SandboxPaths + + paths = SandboxPaths() + + agent_view = paths.as_env(agent_visible=True) + assert set(agent_view) == {"HARBOR_WORKDIR", "HARBOR_AGENT_LOGS_DIR"} + # The verifier and oracle still get the full set. + assert "HARBOR_TESTS_DIR" in paths.as_env() + assert "HARBOR_LOGS_DIR" in paths.as_env() + + +def test_episode_stays_terminal_after_evaluate(tmp_path: Path): + """`done` must never walk back from True to False.""" + pytest.importorskip("openenv") + from repo2rlenv.openenv.environment import Repo2RLEnvEnvironment + from repo2rlenv.openenv.models import Repo2RLEnvAction + + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + env = Repo2RLEnvEnvironment(dataset=str(dataset)) + # Mark the episode graded without needing Docker to run one. + env._state.evaluated = True + + observation = env.step(Repo2RLEnvAction(action_type="exec", command="ls")) + + assert observation.done + assert not observation.success + assert "episode ended" in observation.error + + +def test_control_actions_can_be_refused_server_side(tmp_path: Path): + """The agent/orchestration split, enforced rather than documented.""" + pytest.importorskip("openenv") + from repo2rlenv.openenv.environment import Repo2RLEnvEnvironment + from repo2rlenv.openenv.models import CONTROL_ACTIONS, Repo2RLEnvAction + + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + env = Repo2RLEnvEnvironment(dataset=str(dataset), allow_control_actions=False) + + for action_type in sorted(CONTROL_ACTIONS): + observation = env.step(Repo2RLEnvAction(action_type=action_type)) + assert not observation.success + assert "orchestration control" in observation.error From 3a92ab76ed9155f3b1b42a881aa414c9d9cecd33 Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Wed, 29 Jul 2026 06:58:39 -0700 Subject: [PATCH 7/9] fix(openenv): give a declared user ownership of what it must write Follow-up to the policy work: honouring [agent].user broke every task that declares one. The Harbor directories are created by the image's default account, so an agent running as a non-root user inherited a working directory it could not write to. The same applied to [verifier].user and /logs/verifier, which would have left those tasks unscorable. DockerSandbox.chown() now hands the working directory and agent log dir to the agent user at start, and the verifier log and tests dirs to the verifier user before the verifier runs. Confirmed against a live container in the sibling OpenEnv PR, where the identical bug was found first. Tests: 46 (1 added). Full suite 740 passed. --- src/repo2rlenv/openenv/sandbox.py | 23 +++++++++++++++++++++++ tests/test_openenv_export.py | 31 +++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/src/repo2rlenv/openenv/sandbox.py b/src/repo2rlenv/openenv/sandbox.py index 3838c944..e0f728e8 100644 --- a/src/repo2rlenv/openenv/sandbox.py +++ b/src/repo2rlenv/openenv/sandbox.py @@ -143,6 +143,10 @@ def start(self, task: Repo2RLEnvTask) -> None: self.agent_user = task.agent_user self.paths = SandboxPaths(workdir=task.declared_workdir or self._image_workdir(client)) self.mkdirs(self.paths.workdir, self.paths.logs_verifier, self.paths.logs_agent) + # Those directories belong to the image's default account. A task that + # asks for [agent].user would otherwise get a working directory it + # cannot write to, breaking every edit the agent makes. + self.chown(task.agent_user, self.paths.workdir, self.paths.logs_agent) def close(self) -> None: """Remove the container.""" @@ -217,6 +221,21 @@ def upload_dir(self, source: Path, destination: str) -> None: ) container.put_archive(destination, stream.getvalue()) + def chown(self, user: str | None, *paths: str) -> None: + """Hand `paths` to `user`, so a non-root phase can write to them. + + A no-op when the task declares no user. Runs as the image's default + account, the only one able to change ownership. + """ + if not user or not paths: + return + quoted = " ".join(_quote(path) for path in paths) + result = self.exec(f"chown -R {_quote(user)} {quoted}", timeout_s=120.0, workdir="/") + if not result.ok: + raise SandboxError( + f"could not give {user!r} ownership of {list(paths)}: {result.output.strip()}" + ) + def mkdirs(self, *paths: str) -> None: """Create directories inside the container. @@ -248,6 +267,9 @@ def run_verifier(self, task: Repo2RLEnvTask) -> ExecResult: self.exec(f"rm -rf {_quote(self.paths.logs_verifier)}", timeout_s=60.0, workdir="/") self.mkdirs(self.paths.logs_verifier) self._replace_dir(task.tests_dir, self.paths.tests) + # Same reason as the working directory: a [verifier].user that cannot + # write its reward file would make every such task unscorable. + self.chown(task.verifier_user, self.paths.logs_verifier, self.paths.tests) script = posixpath.join(self.paths.tests, task.test_script.name) return self.exec( f"bash {_quote(script)}", @@ -266,6 +288,7 @@ def run_solution(self, task: Repo2RLEnvTask) -> ExecResult: f"task {task.task_id!r} has no solution/solve.sh, so it has no oracle" ) self._replace_dir(task.solution_dir, self.paths.solution) + self.chown(task.agent_user, self.paths.solution) script = posixpath.join(self.paths.solution, task.solve_script.name) return self.exec( f"bash {_quote(script)}", diff --git a/tests/test_openenv_export.py b/tests/test_openenv_export.py index 85c7dd91..5cca564c 100644 --- a/tests/test_openenv_export.py +++ b/tests/test_openenv_export.py @@ -602,3 +602,34 @@ def test_control_actions_can_be_refused_server_side(tmp_path: Path): observation = env.step(Repo2RLEnvAction(action_type=action_type)) assert not observation.success assert "orchestration control" in observation.error + + +def test_declared_user_gets_ownership_of_what_it_must_write(tmp_path: Path): + """`[agent].user` is useless if the agent cannot write its own workdir. + + The Harbor directories are created by the image's default account, so a + non-root phase inherits a tree it cannot touch. + """ + pytest.importorskip("openenv") + from dataclasses import replace + + from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult + + task = replace( + Repo2RLEnvTask.load(_emit(tmp_path)), + agent_user="nobody", + verifier_user="nobody", + ) + chowned: list[str] = [] + sandbox = DockerSandbox() + + def _fake_exec(command, *, timeout_s, env=None, workdir=None, user=None, **kw): + if command.startswith("chown"): + chowned.append(command) + return ExecResult(0, "") + + sandbox.exec = _fake_exec # type: ignore[method-assign] + sandbox.upload_dir = lambda *a, **k: None # type: ignore[method-assign] + sandbox.run_verifier(task) + + assert any("nobody" in c and "verifier" in c for c in chowned), chowned From a155bac846f5bae461b2a5c4606e5445d12abb75 Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Wed, 29 Jul 2026 07:32:08 -0700 Subject: [PATCH 8/9] fix(openenv): port the second round of review findings An independent review of the sibling OpenEnv PR found that several of the earlier hardening fixes were incomplete. The same gaps existed here. - `Repo2RLEnvState.task_path` carried the host path to the task directory, and `state` rides the same socket as `step`. A caller that could act could read the path and reach `solution/patch.diff`. The field is gone. - `read_text()` ran `cat` as the image's default account and `write_text()` extracted a root-owned tar through the archive API, so `[agent].user` was bypassed by both actions. In the sibling PR this was demonstrated with a symlink out of the working directory: `read` returned `/etc/shadow` and `write` created a root-owned file under `/root`. Both now run as the declared user, with writes going through the shell so the kernel applies permissions. - `evaluated` was set only after the verifier ran, so a failure during staging left `/tests` readable with the episode still running. The episode now terminates before anything that can fail. - Agent-supplied `timeout_s` is capped at the configured ceiling instead of overriding it; it arrives on the wire and was unbounded. Tests: 48 (2 added). Full suite 740 passed. --- src/repo2rlenv/openenv/environment.py | 16 +++++---- src/repo2rlenv/openenv/models.py | 2 -- src/repo2rlenv/openenv/sandbox.py | 35 +++++++++++++++++--- tests/test_openenv_export.py | 47 +++++++++++++++++++++++++++ 4 files changed, 87 insertions(+), 13 deletions(-) diff --git a/src/repo2rlenv/openenv/environment.py b/src/repo2rlenv/openenv/environment.py index d7af3802..1da5f82d 100644 --- a/src/repo2rlenv/openenv/environment.py +++ b/src/repo2rlenv/openenv/environment.py @@ -132,7 +132,6 @@ def reset( episode_id=episode_id or str(uuid4()), task_id=task.task_id, task_name=task.name, - task_path=str(task.path), pipeline=task.pipeline, image=sandbox.image, workdir=sandbox.paths.workdir, @@ -213,9 +212,11 @@ def _do_exec( del task if not action.command.strip(): raise ValueError("exec requires a non-empty command") + # `timeout_s` arrives on the wire, so it is policy-controlled. Treat + # the configured value as a ceiling rather than a default. result = sandbox.exec( action.command, - timeout_s=action.timeout_s or self.command_timeout_s, + timeout_s=min(action.timeout_s or self.command_timeout_s, self.command_timeout_s), user=sandbox.agent_user, agent_visible=True, ) @@ -226,7 +227,7 @@ def _do_read( ) -> Repo2RLEnvObservation: del task target = resolve_within(sandbox.paths.workdir, action.path) - content = sandbox.read_text(target) + content = sandbox.read_text(target, user=sandbox.agent_user) if content is None: raise FileNotFoundError(f"no such file: {action.path}") return self._observe("read", output=content) @@ -236,7 +237,7 @@ def _do_write( ) -> Repo2RLEnvObservation: del task target = resolve_within(sandbox.paths.workdir, action.path) - sandbox.write_text(target, action.content) + sandbox.write_text(target, action.content, user=sandbox.agent_user) return self._observe("write", output=f"wrote {len(action.content)} bytes to {action.path}") def _do_evaluate( @@ -244,10 +245,13 @@ def _do_evaluate( ) -> Repo2RLEnvObservation: """Run the task's verifier and forward its reward. Ends the episode.""" del action + # Terminate first: staging puts the verifier's files in the sandbox, so + # a failure anywhere below must still end the episode rather than leave + # /tests readable with the episode running. + self._state.evaluated = True + result = sandbox.run_verifier(task) report = sandbox.reward_report() - - self._state.evaluated = True self._state.reward = report.value self._state.last_exit_code = result.exit_code diff --git a/src/repo2rlenv/openenv/models.py b/src/repo2rlenv/openenv/models.py index b7e3f45d..b903a975 100644 --- a/src/repo2rlenv/openenv/models.py +++ b/src/repo2rlenv/openenv/models.py @@ -92,7 +92,6 @@ class Repo2RLEnvState(State): Attributes: task_id: identifier of the running task, empty before the first reset(). task_name: the task's qualified name. - task_path: task directory on the server. pipeline: which synthesis pipeline produced the task. image: the image backing the sandbox. workdir: working directory inside the sandbox. @@ -107,7 +106,6 @@ class Repo2RLEnvState(State): task_id: str = Field(default="") task_name: str = Field(default="") - task_path: str = Field(default="") pipeline: str = Field(default="") image: str = Field(default="") workdir: str = Field(default="") diff --git a/src/repo2rlenv/openenv/sandbox.py b/src/repo2rlenv/openenv/sandbox.py index e0f728e8..059a2588 100644 --- a/src/repo2rlenv/openenv/sandbox.py +++ b/src/repo2rlenv/openenv/sandbox.py @@ -19,6 +19,7 @@ from __future__ import annotations +import base64 import io import logging import posixpath @@ -192,13 +193,37 @@ def exec( status = int(exit_code) if exit_code is not None else 1 return ExecResult(status, text, timed_out=status == TIMEOUT_EXIT_CODE) - def read_text(self, path: str) -> str | None: - """Read a text file, returning None when it does not exist.""" - result = self.exec(f"cat {_quote(path)}", timeout_s=60.0) + def read_text(self, path: str, user: str | None = None) -> str | None: + """Read a text file, returning None when it does not exist. + + Args: + user: read as this account. Agent reads must pass the task's + `[agent].user`, or a task that declared an unprivileged agent + would still read root-only files through this path. + """ + result = self.exec(f"cat {_quote(path)}", timeout_s=60.0, user=user) return result.output if result.ok else None - def write_text(self, path: str, content: str) -> None: - """Write a text file, creating parent directories as needed.""" + def write_text(self, path: str, content: str, user: str | None = None) -> None: + """Write a text file, creating parent directories as needed. + + Args: + user: write as this account. `put_archive` extracts as root, which + would let an unprivileged agent create root-owned files — and, + through a symlink out of the working directory, create them + anywhere. Writing through the shell makes the kernel apply the + declared user's permissions instead. + """ + if user: + payload = base64.b64encode(content.encode("utf-8")).decode("ascii") + result = self.exec( + f"printf %s {_quote(payload)} | base64 -d > {_quote(path)}", + timeout_s=120.0, + user=user, + ) + if not result.ok: + raise SandboxError(f"could not write {path} as {user!r}: {result.output.strip()}") + return container = self._require_container() directory, name = posixpath.split(path) self.mkdirs(directory) diff --git a/tests/test_openenv_export.py b/tests/test_openenv_export.py index 5cca564c..1b4eba39 100644 --- a/tests/test_openenv_export.py +++ b/tests/test_openenv_export.py @@ -633,3 +633,50 @@ def _fake_exec(command, *, timeout_s, env=None, workdir=None, user=None, **kw): sandbox.run_verifier(task) assert any("nobody" in c and "verifier" in c for c in chowned), chowned + + +def test_state_does_not_carry_the_host_task_path(tmp_path: Path): + """`state` rides the same socket as `step`, so it must not name the oracle.""" + pytest.importorskip("openenv") + from repo2rlenv.openenv.environment import Repo2RLEnvEnvironment + + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + env = Repo2RLEnvEnvironment(dataset=str(dataset)) + + assert "task_path" not in env.state.model_dump() + + +def test_agent_reads_and_writes_run_as_the_declared_user(tmp_path: Path): + """`read` used `cat` as root and `write` extracted a root-owned tar. + + Either would let a task that declared an unprivileged agent reach files + that agent could never have touched with `exec`. + """ + pytest.importorskip("openenv") + from repo2rlenv.openenv.environment import Repo2RLEnvEnvironment + from repo2rlenv.openenv.models import Repo2RLEnvAction + from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult + + seen: dict[str, str | None] = {} + sandbox = DockerSandbox() + sandbox.agent_user = "nobody" + sandbox.start = lambda task: None # type: ignore[method-assign] + + def _fake_exec(command, *, timeout_s, env=None, workdir=None, user=None, **kw): + seen[command.split()[0]] = user + return ExecResult(0, "contents") + + sandbox.exec = _fake_exec # type: ignore[method-assign] + + dataset = tmp_path / "ds" + _emit(dataset, "demo__task-1") + env = Repo2RLEnvEnvironment(dataset=str(dataset), sandbox_factory=lambda: sandbox) + env.reset(task_id="demo__task-1") + sandbox.agent_user = "nobody" + + env.step(Repo2RLEnvAction(action_type="read", path="a.py")) + env.step(Repo2RLEnvAction(action_type="write", path="a.py", content="x = 1\n")) + + assert seen["cat"] == "nobody" + assert seen["printf"] == "nobody" From f4ad471dc994868ce6c645c4a2a545ffb64b367d Mon Sep 17 00:00:00 2001 From: Govind Kamtamneni Date: Wed, 29 Jul 2026 07:50:53 -0700 Subject: [PATCH 9/9] fix(openenv): close the symlink escape from read/write confinement MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cursor and Copilot both flagged this independently on the sibling OpenEnv PR, and the same hole existed here. `resolve_within()` is a purely lexical check, so it cannot see a symlink the agent planted with `exec`: exec ln -s /tests link read path="link/test.sh" -> the grader's source That defeats the documented confinement of `read`/`write` — the agent could read the grading logic, and `write` could plant files the verifier then executes. Agent paths now go through `DockerSandbox.resolve_agent_path()`, which keeps the lexical check and then canonicalizes inside the container with `readlink -m`. `-m` rather than `-f` because a `write` may legitimately create directories that do not exist yet, while symlinks that *do* exist are still resolved — the only part confinement depends on. The base is canonicalized too, since the working directory may itself sit behind a link. Tests: 49 (1 added). Full suite 740 passed. --- src/repo2rlenv/openenv/environment.py | 6 ++--- src/repo2rlenv/openenv/sandbox.py | 39 +++++++++++++++++++++++++++ tests/test_openenv_export.py | 28 +++++++++++++++++++ 3 files changed, 70 insertions(+), 3 deletions(-) diff --git a/src/repo2rlenv/openenv/environment.py b/src/repo2rlenv/openenv/environment.py index 1da5f82d..922bb8a2 100644 --- a/src/repo2rlenv/openenv/environment.py +++ b/src/repo2rlenv/openenv/environment.py @@ -27,7 +27,7 @@ Repo2RLEnvObservation, Repo2RLEnvState, ) -from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult, SandboxError, resolve_within +from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult, SandboxError logger = logging.getLogger(__name__) @@ -226,7 +226,7 @@ def _do_read( self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask ) -> Repo2RLEnvObservation: del task - target = resolve_within(sandbox.paths.workdir, action.path) + target = sandbox.resolve_agent_path(action.path) content = sandbox.read_text(target, user=sandbox.agent_user) if content is None: raise FileNotFoundError(f"no such file: {action.path}") @@ -236,7 +236,7 @@ def _do_write( self, action: Repo2RLEnvAction, sandbox: DockerSandbox, task: Repo2RLEnvTask ) -> Repo2RLEnvObservation: del task - target = resolve_within(sandbox.paths.workdir, action.path) + target = sandbox.resolve_agent_path(action.path) sandbox.write_text(target, action.content, user=sandbox.agent_user) return self._observe("write", output=f"wrote {len(action.content)} bytes to {action.path}") diff --git a/src/repo2rlenv/openenv/sandbox.py b/src/repo2rlenv/openenv/sandbox.py index 059a2588..b1cad7ca 100644 --- a/src/repo2rlenv/openenv/sandbox.py +++ b/src/repo2rlenv/openenv/sandbox.py @@ -261,6 +261,45 @@ def chown(self, user: str | None, *paths: str) -> None: f"could not give {user!r} ownership of {list(paths)}: {result.output.strip()}" ) + def resolve_agent_path(self, relative: str) -> str: + """Resolve an agent-supplied path, refusing anything outside the workdir. + + Two checks, because either alone is insufficient: + + 1. `resolve_within` rejects absolute paths and lexical `..` escapes. + 2. The result is canonicalized inside the container, which is the only + way to catch a symlink the agent planted with `exec`. Without it, + `ln -s /tests t` then `read path="t/test.sh"` walks straight out of + the working directory and reads the grader. + + Raises: + ValueError: if the path escapes the working directory, before or + after symlink resolution. + """ + target = resolve_within(self.paths.workdir, relative) + real = self.real_path(target) + # Canonicalize the base too — the workdir itself may sit behind a link. + base = self.real_path(self.paths.workdir) + if real != base and not real.startswith(base.rstrip("/") + "/"): + raise ValueError(f"path escapes the working directory through a link: {relative!r}") + return real + + def real_path(self, path: str) -> str: + """Canonicalize `path` inside the container, resolving symlinks. + + `readlink -m` rather than `-f`: a `write` may legitimately create + directories that do not exist yet, while symlinks that *do* exist are + still resolved, which is the only part confinement depends on. + """ + result = self.exec(f"readlink -m {_quote(path)}", timeout_s=60.0) + canonical = result.output.strip() + if not result.ok or not canonical: + raise SandboxError( + f"could not canonicalize {path!r} inside the sandbox; refusing the " + "action rather than trusting an unresolved path" + ) + return canonical + def mkdirs(self, *paths: str) -> None: """Create directories inside the container. diff --git a/tests/test_openenv_export.py b/tests/test_openenv_export.py index 1b4eba39..8a198c49 100644 --- a/tests/test_openenv_export.py +++ b/tests/test_openenv_export.py @@ -680,3 +680,31 @@ def _fake_exec(command, *, timeout_s, env=None, workdir=None, user=None, **kw): assert seen["cat"] == "nobody" assert seen["printf"] == "nobody" + + +def test_symlinks_cannot_walk_read_write_out_of_the_workdir(tmp_path: Path): + """`resolve_within` is lexical, so it cannot see a link the agent planted. + + `exec ln -s /tests t` then `read path="t/test.sh"` would otherwise walk + straight out of the working directory and read the grader. + """ + pytest.importorskip("openenv") + from repo2rlenv.openenv.sandbox import DockerSandbox, ExecResult + + sandbox = DockerSandbox() + + def _fake_exec(command, *, timeout_s, env=None, workdir=None, user=None, **kw): + # Model a container where `link` points at /tests. + if command.startswith("readlink -m"): + target = command.split("'")[1] + resolved = target.replace("/workspace/link", "/tests") + return ExecResult(0, resolved + "\n") + return ExecResult(0, "") + + sandbox.exec = _fake_exec # type: ignore[method-assign] + + with pytest.raises(ValueError, match="escapes"): + sandbox.resolve_agent_path("link/test.sh") + + # A path that stays inside resolves normally. + assert sandbox.resolve_agent_path("calc.py") == "/workspace/calc.py"