Merge upstream main into fix/tabular-mixed-tool-result-4215

This commit is contained in:
JerrettDavis
2026-10-21 18:38:44 -05:00
52 changed files with 4194 additions and 566 deletions
+7 -6
View File
@@ -443,8 +443,6 @@ jobs:
if: needs.changes.outputs.code == 'true'
runs-on: ubuntu-latest
timeout-minutes: 30
env:
FASTEMBED_CACHE_PATH: ${{ github.workspace }}/.fastembed-cache
steps:
- uses: actions/checkout@v7
- uses: actions/setup-python@v7
@@ -459,8 +457,11 @@ jobs:
- name: Cache fastembed model
uses: actions/cache@v6
with:
path: ${{ github.workspace }}/.fastembed-cache
key: ${{ runner.os }}-fastembed-bge-small-v1
# The default relevance model loads from its pinned snapshot in the
# HuggingFace hub cache (headroom/onnx_runtime.py _PINNED_REVISIONS);
# the key carries the pinned SHA so a bump re-fetches.
path: ~/.cache/huggingface/hub/models--Qdrant--bge-small-en-v1.5-onnx-Q
key: ${{ runner.os }}-hf-bge-small-en-v1.5-onnx-Q-52398278842e
- name: Download prebuilt wheel
uses: actions/download-artifact@v8
with:
@@ -481,7 +482,7 @@ jobs:
HF_HUB_DISABLE_TELEMETRY: "1"
run: |
for i in 1 2 3 4 5; do
if python -c "from fastembed import TextEmbedding; TextEmbedding('BAAI/bge-small-en-v1.5')"; then exit 0; fi
if python -c "from headroom.relevance.embedding import _resolve_default_model_snapshot as r; print(r())"; then exit 0; fi
echo "::warning::fastembed fetch attempt $i failed; backing off"; sleep $((i * 20))
done
echo "::error::could not fetch fastembed model from HuggingFace"; exit 1
@@ -491,7 +492,7 @@ jobs:
env:
HF_HUB_OFFLINE: "1"
TRANSFORMERS_OFFLINE: "1"
run: pytest tests/test_relevance.py -v
run: pytest tests/test_relevance.py tests/test_fastembed_pinned_snapshot.py -v
- name: Run HTML extraction and tool reversibility tests
run: |
@@ -0,0 +1,40 @@
# ADR 0001: Main and release branch semantics
- Status: Accepted
- Date: 2026-08-13
## Context
Headroom currently develops and releases from `main`. The target lifecycle needs
`main` to continue moving while an exact source revision is qualified. A branch
name alone is not evidence, and creating a `release` branch before qualification
is authoritative would make unqualified code appear publishable.
## Decision
`main` remains the default integration branch and the target for ordinary pull
requests. The future protected `release` branch represents qualified source. It
may receive only an ancestry-preserving promotion of an exact Gate-A-qualified
`main` SHA, a verified metadata-only Release Please change, an authorized hotfix,
or release-control maintenance.
Promotion must leave the qualified candidate SHA reachable from `release`.
Squash and rebase merges are therefore forbidden for promotion pull requests.
Normal pull requests into `main` may retain the repository's usual merge policy.
The first `release` branch must be created from an exact SHA with a passing,
unrevoked qualification manifest. Branch creation, protection, lifecycle
activation, and publication credentials remain explicit administrator actions.
They are not performed by this contract-only change.
Gate A admits source to `release`. Gate B independently authorizes publication
of final distribution bytes. Neither branch membership nor a tag or GitHub
Release substitutes for either gate.
## Consequences
Release Please will eventually watch `release`, but only after the qualification
controller and migration guard are operational. Promotion automation must use an
ancestry-preserving merge. A hotfix made on `release` requires qualification and
forward synchronization to `main`; `release` must not become a second development
branch.
@@ -0,0 +1,35 @@
# ADR 0002: Release artifact identity and provenance
- Status: Accepted
- Date: 2026-08-13
## Context
Rebuilding a moving source reference can produce different bytes. Source identity
alone cannot prove what qualification tested or what publication shipped.
## Decision
Every candidate is bound to an exact full Git commit SHA and an immutable artifact
identified by SHA-256, filename, package name, version, size, and build-run
identity. When runtime behavior comes from a payload that can differ from package
bytes, its SHA-256 is recorded separately.
Evidence documents are themselves immutable bytes with a SHA-256 and an opaque
URI. A producer identity records repository, workflow, run ID, attempt, and the
producer commit. Cross-repository consumers verify the digest before processing
the artifact or evidence. Secrets and credentials are never evidence fields.
The candidate artifact is built once. Downstream deterministic, integration, and
benchmark lanes consume those exact bytes; they do not rebuild `main` and reuse
the candidate identity. Final Gate B compares published bytes with the qualified
artifact or applies an explicitly approved, policy-versioned runtime-payload
equivalence rule.
## Consequences
Artifact stores and workflow runs require immutable retention sufficient for
audit. A digest, source SHA, schema version, or producer mismatch makes evidence
`inconclusive` or `fail` according to policy; it can never pass silently. Future
controllers must enforce equality across documents in addition to validating
each document's JSON Schema.
+37
View File
@@ -0,0 +1,37 @@
# ADR 0003: A1 versus B is the release benchmark claim
- Status: Accepted
- Date: 2026-08-13
## Context
Comparing Headroom against a direct provider path changes more than compression
and cannot isolate Headroom's effect. Release evidence needs a paired comparison
whose intended difference is only optimization state.
## Decision
The headline release comparison is:
- A1 (`a1_passthrough`): the Headroom proxy and candidate artifact with
optimization disabled.
- B (`b_headroom`): the same Headroom proxy and candidate artifact with
optimization enabled.
A1 and B must have equal candidate source SHA, artifact digest, rollout registry
and snapshot digests, model, agent, taskset, environment image, and resource
limits. Tasks are paired, arm order is randomized, and the versioned policy sets
repeat count and statistical decision rules. A direct-provider A0 arm may be
recorded for diagnosis but is not the headline comparator.
The benchmark producer reports an explicit identity-verification verdict. Any
identity mismatch makes the experiment and release evidence inconclusive. JSON
Schema constrains the arm shapes and intended optimization states; the benchmark
worker and qualification controller must enforce equality between arms.
## Consequences
A single noisy run is not hard release evidence. Missing telemetry, provider
outages, unequal environments, or identity drift remain visible and cannot be
coerced into `pass`. Accuracy, savings, latency, reliability, and missing-data
rules live in versioned policy rather than workflow shell code.
@@ -0,0 +1,38 @@
# ADR 0004: Black-box release benchmark boundary
- Status: Accepted
- Date: 2026-08-13
## Context
Internal unit and compression tests are necessary but do not prove that the
packaged proxy preserves real agent, streaming, and tool-use behavior. Conversely,
benchmark infrastructure must not gain release credentials or execute arbitrary
release commands.
## Decision
Release benchmarks exercise Headroom through its supported public protocol and
observable provenance surfaces, using the immutable candidate artifact. They
record taskset revision and digest, model and agent identities, environment,
resource limits, rollout snapshot, artifact digest, attempts, telemetry
completeness, and raw-result identity.
The benchmark repository receives only the minimum candidate and experiment
identities needed to run. It verifies artifact digests before installation and
returns an immutable result reference with authenticated producer identity. It
does not receive provider secrets through release evidence, package-publish
credentials, or permission to mutate the Headroom repository.
Failures and cancellations preserve terminal evidence. A provider or
infrastructure failure is `inconclusive`, not a candidate pass and not necessarily
a candidate-caused failure. The qualification controller applies the registered
policy to the returned reference; callback identity alone does not establish a
passing result.
## Consequences
Hermetic PR simulators, scheduled live smoke tests, and release-candidate lanes
can share one result shape while retaining their execution depth. Cross-repository
authentication, artifact transport, callback authorization, and retention need
separate implementation and security review in later PRs.
@@ -0,0 +1,40 @@
# ADR 0005: Release overrides and fail-closed policy
- Status: Accepted
- Date: 2026-08-13
## Context
Headroom product transforms may fail open to preserve requests, but release
control makes a different safety decision: publication must not proceed without
complete, matching, current evidence. Operational exceptions still need an
auditable representation.
## Decision
Release evidence uses exactly four policy statuses: `pass`, `fail`,
`inconclusive`, and `skipped_by_policy`. Missing, stale, invalid, mismatched,
revoked, unauthorized, or schema-incompatible required evidence cannot produce
`pass`. `skipped_by_policy` is allowed only when the selected policy version does
not require that evidence.
Policy is versioned data. It maps risk classes to required Gate A and Gate B
evidence and deterministic rules. Missing-data behavior is `inconclusive`.
Thresholds and exceptions are not embedded as ad hoc workflow conditions.
An override records a unique ID, narrow scope, reason, human approver, approval
time, expiry, and optional ticket URI. It never contains credentials. Controllers
authenticate the approver, reject expired or unauthorized overrides, and include
accepted overrides in the gate result. An unsafe runtime rollout override makes
the rollout qualification-ineligible and cannot be overridden into a release
pass by this mechanism.
Qualification revocation is explicit, immutable evidence linked to the original
qualification. A revoked qualification cannot authorize promotion or publication.
## Consequences
The stable GitHub check will be named `release-policy` even when risk-specific
evidence varies. Workflow code remains a thin adapter around a tested policy
evaluator. Operational urgency stays visible to reviewers instead of silently
weakening the evidence chain.
+1
View File
@@ -401,6 +401,7 @@ headroom proxy --learn --min-evidence 3
| `HEADROOM_THINKING_COMPACT` | Compact plain-text reasoning that models re-send every turn (Kimi/GLM/DeepSeek `reasoning_content` / inline `<think>`): Kompress it on warm turns, drop it on cold turns. No-op for Claude/Codex/OpenAI (encrypted reasoning). See [Cold-prefix hook](#cold-prefix-hook--reasoning-compaction). | `off` |
| `HEADROOM_THINKING_COMPACT_KEEP_LAST` | Most-recent assistant turns whose reasoning is left intact (the active reasoning the model still uses). Only applies with `HEADROOM_THINKING_COMPACT`. | `1` |
| `HEADROOM_COLD_RECOMPACT` | On a confirmed-cold turn (idle past the real cache TTL), recompact the whole prefix — cross-turn dedupe + superseded-read drop + lossless folds — instead of forwarding a byte-identical prefix to a dead cache. Warm turns unchanged. Pair with `HEADROOM_DEDUPE`. See [Cold-prefix hook](#cold-prefix-hook--reasoning-compaction). | `off` |
| `HEADROOM_PREFIX_STATE_FILE` | Path where the proxy saves its prefix-cache trackers on a graceful shutdown and restores them on the next start (then deletes the file), so warm conversations replay the exact prefix the provider cached instead of re-writing it. The file holds conversation content: it is written `0600`, capped at the 256 newest conversations and 64 MB, and only trackers still inside their cache lifetime are restored, with the retrieval (CCR) entries their markers point at, so those markers resolve even with `HEADROOM_CCR_BACKEND=memory`. Not supported with multiple workers; ignored in stateless mode (neither read nor written). | -- |
| `HEADROOM_DEDUPE` | Whole-conversation verbatim cross-turn dedup in the router (cache-safe, information-preserving via retrieval markers). Superseded-read drop + lossless folds run without it; this adds verbatim dedup. | `off` |
| `HEADROOM_CACHE_TTL_LEARN` | Append per-turn cache-outcome observations (provider, model, idle, hit/miss) to `cache_ttl_observations.jsonl` for the offline `headroom-cache-ttl` learner. Observation-only (no request-behavior change); respects `HEADROOM_STATELESS`; the log is size-bounded. | `off` |
| `HEADROOM_KOMPRESS_ENDPOINT` / `HEADROOM_KOMPRESS_ENDPOINT_TOKEN` | Offload ML compression (Kompress) to a remote endpoint instead of the local ONNX model — used by reasoning compaction and the router when set. | -- |
+14 -9
View File
@@ -528,16 +528,21 @@ headroom wrap antigravity # Start proxy + print Antigravity setup instr
headroom mcp install --agent antigravity # Register the Headroom MCP server in Antigravity
```
`wrap antigravity` prints a custom OpenAI-compatible model-provider base URL
to add in Antigravity's model-provider settings; Antigravity fetches the model
list from `GET /v1/models` on its own. Native Cloud Code Assist traffic
(`google-antigravity` clients) is accepted on
[`POST /v1internal:streamGenerateContent`](#post-v1internalstreamgeneratecontent)
and routed upstream like any other Cloud Code request.
The Antigravity IDE does not support third-party model providers — its
agent models are Google-managed, so there is no settings panel to point
at the proxy. What the proxy does offer Antigravity users:
MCP registration writes to Antigravity's global `mcp_config.json` under
`~/.gemini/` (preferring the install's current location when one already
exists) and refuses to overwrite a config file that does not parse as JSON.
- MCP tools: `mcp install` writes the Headroom server into Antigravity's
global `mcp_config.json` under `~/.gemini/` (preferring the install's
current location when one already exists) and refuses to overwrite a
config file that does not parse as JSON.
- Native traffic: `google-antigravity` clients are accepted on
[`POST /v1internal:streamGenerateContent`](#post-v1internalstreamgeneratecontent)
and routed upstream like any other Cloud Code request.
The Antigravity CLI (`agy`), unlike the IDE, accepts a custom endpoint
via its `GOOGLE_GEMINI_BASE_URL` setting — the one Antigravity surface
where a custom model endpoint is supported.
### `POST /v1/compress`
@@ -0,0 +1,283 @@
# HEAOSS-6 Pull Request Split Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Replace PR #3382 with six focused draft pull requests whose cumulative tip preserves its reviewed HEAOSS-6 behavior.
**Architecture:** Build a linear Git branch stack from current upstream `main`. Each branch introduces one independently useful layer: decisions, policy contracts, evidence contracts, manifest tooling, reusable release builds, then candidate orchestration.
**Tech Stack:** Git, GitHub CLI, Python 3.13, pytest, JSON Schema 2020-12, GitHub Actions, Ruff, mypy, actionlint
**Spec:** `docs/superpowers/specs/2026-09-17-heaoss-6-pr-split-design.md`
## Global Constraints
- The first branch is based on current upstream `main`; each later branch is based on its immediate predecessor.
- Every pull request is opened as a draft and targets the preceding branch.
- The original PR #3382 stays unchanged until all six drafts and the cumulative-equivalence audit exist.
- No unrelated merge-commit changes from PR #3382 may enter the new stack.
- Release publishing behavior remains intact after every executable slice.
- Every PR body states `Part of HEAOSS-6; split from #3382.` and identifies its stack position.
---
### Task 1: Release Qualification Decisions
**Files:**
- Create: `docs/adr/0001-main-release-branch-semantics.md`
- Create: `docs/adr/0002-release-artifact-identity.md`
- Create: `docs/adr/0003-a1-b-release-benchmark.md`
- Create: `docs/adr/0004-black-box-release-benchmarks.md`
- Create: `docs/adr/0005-release-overrides-and-fail-closed-policy.md`
- Existing: `docs/superpowers/specs/2026-09-17-heaoss-6-pr-split-design.md`
- Existing: `docs/superpowers/plans/2026-09-17-heaoss-6-pr-split.md`
**Interfaces:**
- Consumes: HEAOSS-6 decisions preserved on `upstream/pr-3382`.
- Produces: Stable terminology for source, artifact, rollout, policy, benchmark, and override identity used by later PRs.
- [ ] **Step 1: Restore the five reviewed ADRs**
```powershell
git checkout upstream/pr-3382 -- docs/adr/0001-main-release-branch-semantics.md docs/adr/0002-release-artifact-identity.md docs/adr/0003-a1-b-release-benchmark.md docs/adr/0004-black-box-release-benchmarks.md docs/adr/0005-release-overrides-and-fail-closed-policy.md
```
- [ ] **Step 2: Verify documentation integrity**
Run both `git diff --check` and `git diff --cached --check`; stop if either exits nonzero. The restore command stages the ADRs, so the cached check is required to inspect those files.
Run `rg -n 'TB[D]|TO[D]O'` against the five restored ADRs and this split's specification and plan. Exit 1 means no placeholders; exit 0 reports unresolved markers, and exit 2 is a scan error.
Expected: both whitespace checks exit 0 and no unresolved placeholder is present in these seven documents. Unrelated plans and ADRs are outside this slice's placeholder check.
- [ ] **Step 3: Commit the documentation slice**
```powershell
git add docs/adr docs/superpowers
git commit -m "docs(release): define qualification decisions"
```
- [ ] **Step 4: Push and open draft PR 1**
```powershell
git push -u origin jd/heaoss-6-01-release-qualification-decisions
gh pr create --repo headroomlabs-ai/headroom --draft --base main --head JerrettDavis:jd/heaoss-6-01-release-qualification-decisions --title "docs(release): define qualification decisions" --body-file <body-file>
```
### Task 2: Shared Policy Contracts
**Files:**
- Create: `release/contracts/common.schema.json`
- Create: `release/contracts/policy.schema.json`
- Create: `release/contracts/examples/policy.valid.json`
- Create: `release/contracts/README.md`
- Modify: `pyproject.toml`
- Modify: `uv.lock`
- Create: `tests/test_release_contracts.py`
**Interfaces:**
- Consumes: ADR terminology from Task 1.
- Produces: JSON Schema definitions referenced as `common.schema.json#/$defs/...` and a complete `policy.schema.json` consumer.
- [ ] **Step 1: Create the stacked branch and restore contract sources**
```powershell
git switch -c jd/heaoss-6-02-release-policy-contracts
git checkout upstream/pr-3382 -- release/contracts/common.schema.json release/contracts/policy.schema.json release/contracts/examples/policy.valid.json release/contracts/README.md pyproject.toml uv.lock
```
- [ ] **Step 2: Add focused policy contract tests**
Extract the schema-registry helpers and policy-specific cases from PR #3382's
`tests/test_release_contracts.py`. The resulting test file must load local
schemas through `referencing.Registry`, validate `policy.valid.json`, reject an
unknown schema version, and enforce policy pass/fail invariants.
- [ ] **Step 3: Validate and commit**
Run: `uv lock --check`
Run: `uv run --extra dev pytest tests/test_release_contracts.py -q`
Run: `uv run --extra dev ruff check tests/test_release_contracts.py`
Expected: all commands exit 0.
```powershell
git add release/contracts tests/test_release_contracts.py pyproject.toml uv.lock
git commit -m "feat(release): define versioned policy contracts"
```
- [ ] **Step 4: Push and open draft PR 2 targeting PR 1's branch**
Use title `feat(release): define versioned policy contracts` and base
`jd/heaoss-6-01-release-qualification-decisions`.
### Task 3: Qualification Evidence Contracts
**Files:**
- Create: `release/contracts/benchmark-result-ref.schema.json`
- Create: `release/contracts/candidate-manifest.schema.json`
- Create: `release/contracts/gate-result.schema.json`
- Create: `release/contracts/integration-result.schema.json`
- Create: `release/contracts/qualification-manifest.schema.json`
- Create: matching files under `release/contracts/examples/`
- Modify: `tests/test_release_contracts.py`
**Interfaces:**
- Consumes: `common.schema.json` definitions and the release policy contract.
- Produces: Complete evidence formats used by candidate tooling and future qualification lanes.
- [ ] **Step 1: Create the branch and restore all remaining schemas/examples**
Create `jd/heaoss-6-03-qualification-evidence-contracts` from Task 2, then
restore the declared files from `upstream/pr-3382`.
- [ ] **Step 2: Restore the complete reviewed contract test suite**
```powershell
git checkout upstream/pr-3382 -- tests/test_release_contracts.py
```
- [ ] **Step 3: Validate and commit**
Run: `uv run --extra dev pytest tests/test_release_contracts.py -q`
Run: `uv run --extra dev ruff check tests/test_release_contracts.py`
Expected: all contract examples and negative invariants pass.
Commit as `feat(release): add qualification evidence contracts`.
- [ ] **Step 4: Push and open draft PR 3 targeting PR 2's branch**
### Task 4: Candidate Manifest CLI
**Files:**
- Create: `scripts/candidate_manifest.py`
- Create: `tests/test_candidate_manifest.py`
- Modify: `.gitignore`
**Interfaces:**
- Consumes: `release/contracts/candidate-manifest.schema.json` and common definitions.
- Produces: `inventory`, `create`, and `verify` CLI commands used by Task 6.
- [ ] **Step 1: Create the branch and restore reviewed CLI files**
Create `jd/heaoss-6-04-candidate-manifest-cli`, then restore the three declared
paths from `upstream/pr-3382`.
- [ ] **Step 2: Validate behavior and types**
Run: `uv run --extra dev pytest tests/test_candidate_manifest.py tests/test_release_contracts.py -q`
Run: `uv run --extra dev ruff check scripts/candidate_manifest.py tests/test_candidate_manifest.py`
Run: `uv run --extra dev mypy scripts/candidate_manifest.py`
Expected: all commands exit 0.
- [ ] **Step 3: Commit, push, and open draft PR 4 targeting PR 3's branch**
Commit as `feat(release): add immutable candidate manifest verifier`.
### Task 5: Read-Only Release Build Workflow
**Files:**
- Create: `.github/workflows/release-build.yml`
- Modify: `.github/workflows/release.yml`
- Modify: `tests/test_release_workflows.py`
- Modify: `docs/content/docs/releases.mdx`
**Interfaces:**
- Consumes: Existing release build and smoke jobs.
- Produces: Reusable `workflow_call` accepting `source_sha`, `manual_version`, and `release_tag`, with version/npm/canonical outputs and retained artifacts.
- [ ] **Step 1: Create the branch and restore the reviewed extraction**
Create `jd/heaoss-6-05-read-only-release-build`, then restore the four declared
paths from `upstream/pr-3382`.
- [ ] **Step 2: Validate workflow structure and release invariants**
Run: `uv run --extra dev pytest tests/test_release_workflows.py -q`
Run: `actionlint .github/workflows/release.yml .github/workflows/release-build.yml`
Expected: 50 or more release workflow tests pass and actionlint emits no findings.
- [ ] **Step 3: Commit, push, and open draft PR 5 targeting PR 4's branch**
Commit as `refactor(release): extract read-only build workflow`.
### Task 6: Immutable Candidate Workflow
**Files:**
- Create: `.github/workflows/candidate-artifact.yml`
- Create: `tests/test_candidate_workflow.py`
- Modify: `docs/content/docs/releases.mdx`
**Interfaces:**
- Consumes: Task 4 CLI and Task 5 reusable workflow.
- Produces: A manual exact-main-SHA candidate artifact and independently verified retained bytes.
- [ ] **Step 1: Create the branch and restore candidate orchestration**
Create `jd/heaoss-6-06-immutable-candidate-workflow`, then restore the workflow
and test from `upstream/pr-3382`. Reconcile the release documentation so only
candidate-specific additions remain in this branch.
- [ ] **Step 2: Run cumulative focused validation**
Run: `uv run --extra dev pytest tests/test_candidate_workflow.py tests/test_candidate_manifest.py tests/test_release_contracts.py tests/test_release_workflows.py -q`
Run: `uv run --extra dev ruff check scripts/candidate_manifest.py tests/test_candidate_manifest.py tests/test_candidate_workflow.py tests/test_release_contracts.py tests/test_release_workflows.py`
Run: `uv run --extra dev mypy scripts/candidate_manifest.py`
Run: `actionlint .github/workflows/candidate-artifact.yml .github/workflows/release-build.yml .github/workflows/release.yml`
Expected: 96 focused tests or the current-main-adjusted equivalent pass; lint,
types, and workflow validation exit 0.
- [ ] **Step 3: Audit cumulative equivalence**
```powershell
git diff --stat upstream/pr-3382...HEAD
git diff upstream/pr-3382 HEAD -- .github docs/adr docs/content/docs/releases.mdx release scripts tests/test_candidate_manifest.py tests/test_candidate_workflow.py tests/test_release_contracts.py tests/test_release_workflows.py pyproject.toml uv.lock .gitignore
```
Expected: only the approved split documents and intentional current-main
reconciliation differ. Investigate and document every other difference.
- [ ] **Step 4: Commit, push, and open draft PR 6 targeting PR 5's branch**
Commit as `feat(release): build immutable exact-SHA candidates`.
### Task 7: Link the Stack and Supersede PR #3382
**Files:**
- Modify: GitHub draft PR bodies only.
**Interfaces:**
- Consumes: URLs and exact head/base SHAs for all six draft PRs.
- Produces: Navigable stack metadata and a non-destructive supersession notice on #3382.
- [ ] **Step 1: Update each draft body with complete previous/next links**
Use `gh pr edit` and verify the rendered bodies with `gh pr view --json body`.
- [ ] **Step 2: Convert #3382 to draft and prepend the supersession notice**
The notice must link all six drafts and retain the prior validation history
below it. Do not close #3382.
- [ ] **Step 3: Verify authoritative GitHub state**
Run `gh pr view` for all seven PRs and verify draft status, base branch, head
branch, mergeability, and URLs. Confirm every new PR head SHA matches the pushed
local branch.
- [ ] **Step 4: Report hosted-check status without claiming unobserved success**
List terminal, pending, or failing checks for each exact head. Hosted checks may
continue after handoff; local validation and PR creation are required before
the task is reported complete.
@@ -0,0 +1,243 @@
# HEAOSS-6 Pull Request Split Design
## Purpose
Replace the 3,279-line change in PR #3382 with a reviewable stack of six draft
pull requests. Every pull request must have one coherent deliverable, pass its
own focused validation, and leave the repository in a useful state if the stack
stops there.
The final stack must preserve the behavior and safety properties already
reviewed on PR #3382: versioned qualification evidence contracts, fail-closed
candidate manifest verification, exact-main-SHA builds, a read-only build call
tree, deterministic artifact inventory, and independent verification of the
retained candidate bytes.
## Constraints
- Base the first branch on the current upstream `main`.
- Stack every later branch on its immediate predecessor.
- Keep each pull request draft until the whole stack is reconstructed and its
cumulative tip is equivalent to PR #3382, except for deliberate documentation
and history changes described here.
- Do not modify or delete the original PR #3382 branch while constructing the
stack.
- Do not include unrelated changes from merge commits or the dirty primary
checkout.
- Preserve the release workflow's existing publish behavior at every executable
step of the stack.
- Use conventional commit messages and include the HEAOSS-6 context and stack
position in every pull request body.
## Stack Topology
| Position | Branch | Base | Deliverable |
| --- | --- | --- | --- |
| 1 | `jd/heaoss-6-01-release-qualification-decisions` | `main` | Release qualification ADRs and this split specification |
| 2 | `jd/heaoss-6-02-release-policy-contracts` | PR 1 branch | Shared evidence vocabulary and versioned release policy contract |
| 3 | `jd/heaoss-6-03-qualification-evidence-contracts` | PR 2 branch | Candidate, benchmark, integration, gate, and qualification evidence schemas |
| 4 | `jd/heaoss-6-04-candidate-manifest-cli` | PR 3 branch | Local candidate inventory, manifest creation, and fail-closed verification CLI |
| 5 | `jd/heaoss-6-05-read-only-release-build` | PR 4 branch | Reusable read-only build/smoke workflow used by the existing release pipeline |
| 6 | `jd/heaoss-6-06-immutable-candidate-workflow` | PR 5 branch | Manual exact-SHA candidate build, bundling, retention, and independent verification |
GitHub draft PRs use the preceding branch as their base. This makes each diff
show only its own deliverable while retaining an executable cumulative tip.
## PR 1: Release Qualification Decisions
### Scope
- Add ADR 0001 defining authoritative-main release semantics.
- Add ADR 0002 defining artifact and runtime-payload identity.
- Add ADR 0003 defining the A1/B benchmark comparison.
- Add ADR 0004 defining black-box release benchmarks.
- Add ADR 0005 defining overrides and fail-closed policy.
- Add this stack design document.
### Value at Merge
The repository gains an explicit, reviewable release-qualification model before
automation encodes it. No runtime or workflow behavior changes.
### Validation
- Markdown and formatting checks applicable to documentation.
- Confirm the ADRs contain no unresolved placeholders and agree on identity,
policy, and override terminology.
## PR 2: Shared Policy Contracts
### Scope
- Add `release/contracts/common.schema.json` with shared identity, status,
rollout, producer, environment, override, and equivalence definitions.
- Add `release/contracts/policy.schema.json` and its valid example.
- Add `release/contracts/README.md` covering schema versioning and validation.
- Add `jsonschema>=4.23.0,<5.0` to the development dependencies and refresh
`uv.lock`.
- Introduce the reusable schema loading and validation test helpers in
`tests/test_release_contracts.py`, with positive and negative policy tests.
### Value at Merge
Policy authors can publish and validate a complete versioned release policy.
The shared vocabulary is exercised by a real consumer in the same pull request;
it is not unused scaffolding.
### Validation
- `uv lock --check`
- `uv run --extra dev pytest tests/test_release_contracts.py -q`
- `uv run --extra dev ruff check tests/test_release_contracts.py`
## PR 3: Qualification Evidence Contracts
### Scope
- Add candidate-manifest, benchmark-result-reference, integration-result,
gate-result, and qualification-manifest schemas.
- Add one valid example for every schema.
- Extend contract tests to validate every example, reject malformed identities,
enforce pass/fail invariants, enforce Gate B runtime-payload equivalence, and
reject unsupported schema versions.
### Value at Merge
Qualification producers and consumers have a complete, machine-validated
evidence interchange format. The contracts are independently useful without
the candidate workflow and can be adopted by later qualification lanes.
### Validation
- `uv run --extra dev pytest tests/test_release_contracts.py -q`
- `uv run --extra dev ruff check tests/test_release_contracts.py`
- Validate that all relative `$ref` targets resolve from the checked-in schema
registry.
## PR 4: Candidate Manifest CLI
### Scope
- Add `scripts/candidate_manifest.py` with `inventory`, `create`, and `verify`
commands.
- Add `.candidate/` to `.gitignore` for local command output.
- Add focused tests for deterministic ordering, hashes, sizes, package/version
identity, source SHA, producer repository/workflow/run identity, rollout
identity, safe qualification eligibility, schema versions, missing files,
changed bytes, and unsupported embedded schemas.
### Value at Merge
Maintainers can create and independently verify immutable candidate manifests
locally or from any later CI workflow. The CLI is fully functional before it is
wired into GitHub Actions.
### Validation
- `uv run --extra dev pytest tests/test_candidate_manifest.py tests/test_release_contracts.py -q`
- `uv run --extra dev ruff check scripts/candidate_manifest.py tests/test_candidate_manifest.py`
- `uv run --extra dev mypy scripts/candidate_manifest.py`
## PR 5: Read-Only Release Build Workflow
### Scope
- Extract version resolution, package construction, the cross-platform wheel
matrix, distribution collection, and smoke imports from `release.yml` into
the reusable `release-build.yml` workflow.
- Make `release.yml` call the reusable workflow, then retain all publishing and
release creation in `release.yml`.
- Ensure every publisher waits for the complete build/smoke group.
- Preserve the release workflow entry points and published outputs.
- Update release workflow tests and release documentation to describe the new
boundary.
### Value at Merge
The production release uses a reusable, contents-read-only build boundary with
no publishing job in its call tree. This is immediately useful even without the
candidate workflow and removes duplicated future build logic.
### Validation
- `uv run --extra dev pytest tests/test_release_workflows.py -q`
- `actionlint .github/workflows/release.yml .github/workflows/release-build.yml`
- Hosted PR dry-run must complete all platform builds and smoke-import jobs;
publishing jobs must remain skipped.
## PR 6: Immutable Candidate Workflow
### Scope
- Add `candidate-artifact.yml` as a manual workflow accepting only a full SHA
reachable from authoritative `main`.
- Call `release-build.yml` directly under `contents: read` permissions.
- Produce a deterministic artifact inventory and X-001A candidate manifest.
- Verify the manifest before upload, download the retained artifact in a
separate job, and verify the exact bytes again.
- Reject wrong source, repository, producer, workflow, run, attempt,
package/version, filename, size, digest, rollout identity, unsafe rollout,
qualification-ineligible rollout, or unsupported schema.
- Add focused structural workflow tests and document the candidate workflow.
### Value at Merge
Maintainers can build and retain an immutable release candidate from an exact
commit on authoritative `main` without exposing publishing permissions. The
same bytes are verified independently after artifact retention.
### Validation
- `uv run --extra dev pytest tests/test_candidate_workflow.py tests/test_candidate_manifest.py tests/test_release_contracts.py tests/test_release_workflows.py -q`
- `uv run --extra dev ruff check scripts/candidate_manifest.py tests/test_candidate_manifest.py tests/test_candidate_workflow.py tests/test_release_contracts.py tests/test_release_workflows.py`
- `uv run --extra dev mypy scripts/candidate_manifest.py`
- `actionlint .github/workflows/candidate-artifact.yml .github/workflows/release-build.yml .github/workflows/release.yml`
- Hosted fork validation must build all five platform targets, run all smoke
jobs, emit the candidate, download it independently, and verify its bytes.
No publishing job may run.
## Reconstruction Method
For each branch, restore only the files or coherent hunks assigned to that pull
request from PR #3382's reviewed tip. Where one original test file spans two
stack positions, split its tests by the behavior introduced at that position.
Commit and validate each branch before creating the next branch from it.
After PR 6, compare its cumulative tree to PR #3382 with `git diff`, allowing
only this specification and any necessary stack metadata. Review every
remaining difference rather than assuming equivalence from file counts.
## Draft Pull Request Format
Each draft body must include:
- `Stack: N of 6` and links to adjacent draft PRs when available.
- The branch/base relationship.
- A concise statement of the independently deliverable value.
- Exact local validation results for that branch.
- A note that hosted validation is pending or a link to its exact run.
- `Part of HEAOSS-6; split from #3382.`
- Runtime rollout safety and rollback notes appropriate to the slice.
## Original PR Transition
Keep #3382 unchanged until all six draft heads exist and the cumulative tip has
passed local equivalence and validation checks. Then convert #3382 to draft and
replace its leading status section with a supersession notice linking the six
drafts. Do not close it until the stack is confirmed visible and complete; its
existing discussion and hosted validation remain useful review evidence.
## Completion Criteria
The split is complete only when:
1. Six draft PRs exist with the topology above.
2. Every PR diff contains only its declared slice and has passing focused local
validation.
3. PR 5 demonstrates unchanged release build/smoke behavior with publication
skipped on PR validation.
4. PR 6 demonstrates candidate creation and independent byte verification with
no publishing permissions or publishing jobs in its call tree.
5. The cumulative PR 6 tree is reconciled against PR #3382 and every difference
is documented and intentional.
6. PR #3382 is a draft with a supersession notice linking the complete stack.
+43 -1
View File
@@ -40,7 +40,7 @@ import threading
import time
from collections import deque
from contextvars import ContextVar
from dataclasses import dataclass, field, replace
from dataclasses import asdict, dataclass, field, replace
from typing import TYPE_CHECKING, Any
from ..log_safety import describe_exception, safe_id
@@ -737,6 +737,48 @@ class CompressionStore:
return list(reversed(events_copy[-limit:]))
def export_entries(self, hashes: list[str]) -> list[dict[str, Any]]:
"""The live entries for ``hashes`` as JSON-safe dicts, without counting
a retrieval. ``SessionTrackerStore.save_state`` carries them across a
restart so the markers it replays still resolve (:meth:`import_entries`)."""
with self._lock:
found = [self._backend.get(hash_key) for hash_key in hashes]
return [asdict(e) for e in found if e is not None and not e.is_expired()]
def import_entries(self, entries: list[CompressionEntry]) -> int:
"""Re-store :meth:`export_entries` output, each with its original expiry.
An entry the backend still holds (a persistent backend kept it) is left
as it is. Raises on a malformed entry. Returns the entries stored.
"""
now = time.time()
stored = 0
for e in entries:
if not all(
isinstance(v, str) for v in (e.hash, e.original_content, e.compressed_content)
):
raise ValueError(f"malformed CCR entry {e.hash!r}")
ttl = int(e.created_at + e.ttl - now)
if ttl <= 0 or self.exists(e.hash):
continue
self.store(
e.original_content,
e.compressed_content,
original_tokens=e.original_tokens,
compressed_tokens=e.compressed_tokens,
original_item_count=e.original_item_count,
compressed_item_count=e.compressed_item_count,
tool_name=e.tool_name,
tool_call_id=e.tool_call_id,
query_context=e.query_context,
tool_signature_hash=e.tool_signature_hash,
compression_strategy=e.compression_strategy,
ttl=ttl,
explicit_hash=e.hash,
)
stored += 1
return stored
def clear(self) -> None:
"""Clear all entries. Mainly for testing."""
with self._lock:
+277
View File
@@ -16,16 +16,19 @@ pipeline skips them entirely.
from __future__ import annotations
import contextlib
import copy
import hashlib
import itertools
import json
import logging
import os
import re
import time
from collections import OrderedDict, deque
from contextvars import ContextVar
from dataclasses import dataclass
from pathlib import Path
from typing import Any
logger = logging.getLogger(__name__)
@@ -71,6 +74,23 @@ _CACHE_TTL_CLEANUP_MARGIN_SECONDS = 60
# of forks off one turn leaves that turn resumable.
_LINEAGE_HISTORY = 3
# Opt-in file for SessionTrackerStore state across a graceful restart. It holds
# conversation content, so nothing is written unless an operator sets it.
PREFIX_STATE_FILE_ENV = "HEADROOM_PREFIX_STATE_FILE"
_PREFIX_STATE_VERSION = 1
# Newest trackers first; whatever does not fit starts cold, as all did before.
_PREFIX_STATE_MAX_TRACKERS = 256
_PREFIX_STATE_MAX_BYTES = 64 * 1024 * 1024
# Any CCR reference in saved messages: ``hash=<hex>`` markers (Retrieve
# more/original, compressed-item counts) and SmartCrusher's ``<<ccr:<hex>``.
_CCR_HASH_RE = re.compile(r"(?:hash=|<<ccr:)([0-9a-f]{12,24})")
def prefix_state_file() -> str | None:
"""The configured tracker state file, or None when persistence is off."""
return os.environ.get(PREFIX_STATE_FILE_ENV, "").strip() or None
# (tracker, turn, resumed state) the current request resolved to. Each proxied
# request runs in its own asyncio task, so it reads the state it resumed and
# ``update_from_response`` records its response against its own turn, even
@@ -1180,6 +1200,12 @@ class PrefixCacheTracker:
# lazily by the handler when read maturation is enabled. Rides
# here so it shares the session's affinity and TTL cleanup.
self.read_maturation_manager: Any = None
# Set by SessionTrackerStore.load_state: this process has no
# CompressionCache entries behind the restored prefix yet, and the
# handler adopts the saved maturation state (validated at load) when it
# builds the manager.
self.restored_from_disk = False
self.restored_maturation_state: dict[str, Any] | None = None
# Stats
self._busts_avoided: int = 0
@@ -1609,6 +1635,42 @@ def _lineage_snapshot(obj: Any) -> Any:
return obj
def _deref(table: list[Any], refs: list[int]) -> list[Any]:
"""Rebuild a saved message list. Restored lists share message objects,
which is safe: tracker and lineage lists are never mutated in place."""
if not all(type(i) is int and 0 <= i < len(table) for i in refs):
raise ValueError("message reference out of range")
return [table[i] for i in refs]
def _decode_turn_state(table: list[Any], state: list[Any]) -> tuple[Any, ...]:
turn, cached_tokens, cached_messages, original, forwarded = state
return (
int(turn),
int(cached_tokens),
int(cached_messages),
_deref(table, original),
_deref(table, forwarded),
)
def seed_restored_compression_cache(tracker: Any, comp_cache: Any) -> None:
"""Seed a token-mode CompressionCache on a tracker's first request after
:meth:`SessionTrackerStore.load_state`.
The new process has no cache entries behind the restored prefix, so the
freeze computed from that cache freezes nothing: the pipeline recompresses
(and read maturation rewrites) messages the provider cached, and beyond the
provider-confirmed floor the overlay declines a larger replay. Seeding with
what was forwarded gives the freeze the pre-restart count.
"""
if getattr(tracker, "restored_from_disk", False):
tracker.restored_from_disk = False
comp_cache.update_from_result(
tracker.get_last_original_messages(), tracker.get_last_forwarded_messages()
)
class SessionTrackerStore:
"""Manages PrefixCacheTracker instances across sessions.
@@ -2007,3 +2069,218 @@ class SessionTrackerStore:
def active_sessions(self) -> int:
"""Number of active session trackers (one per conversation lineage)."""
return len(self._trackers)
def save_state(self, path: str) -> int:
"""Write the live trackers to ``path`` for the next process to resume.
Called on graceful shutdown when ``HEADROOM_PREFIX_STATE_FILE`` is set.
Without it, a restart leaves every warm conversation with no tracker:
its next request recompresses the whole history into bytes that differ
from the prefix the provider cached, and the cache is re-written from
the first changed message. Newest trackers first, capped at
``_PREFIX_STATE_MAX_TRACKERS`` and ``_PREFIX_STATE_MAX_BYTES``; a
tracker whose messages are not JSON is skipped. Each tracker carries
the CCR entries its messages reference, so its replayed markers still
resolve when the CCR backend does not survive the restart (memory).
Never raises; returns the number of trackers written.
"""
from headroom.cache.compression_store import get_compression_store
from headroom.fsutil import write_text
from headroom.paths import persistence_allowed
if not persistence_allowed("prefix-cache tracker state"):
return 0
sessions = {key: sid for sid, family in self._lineages.items() for key in family}
live = sorted(
(item for item in self._trackers.items() if not item[1].is_expired),
key=lambda item: item[1]._last_activity,
reverse=True,
)
entries: list[str] = []
ccr: dict[str, str] = {}
size = 0
for key, tracker in live[:_PREFIX_STATE_MAX_TRACKERS]:
try:
entry = self._encode_tracker(key, tracker, sessions.get(key))
refs = [h for h in dict.fromkeys(_CCR_HASH_RE.findall(entry)) if h not in ccr]
records = get_compression_store().export_entries(refs) if refs else []
payloads = {r["hash"]: json.dumps(r) for r in records}
except Exception: # an unsaveable tracker starts cold, as all did before
continue
grow = len(entry) + sum(len(p) + 1 for p in payloads.values())
if size + grow > _PREFIX_STATE_MAX_BYTES:
continue
size += grow + 1
entries.append(entry)
ccr.update(payloads)
try:
target = Path(path)
target.parent.mkdir(parents=True, exist_ok=True)
# write_text keeps the target's mode, so tighten it in place rather
# than unlinking: a failed write must leave the last snapshot.
with contextlib.suppress(FileNotFoundError):
target.chmod(0o600)
write_text(
target,
f'{{"version":{_PREFIX_STATE_VERSION},"trackers":[{",".join(entries)}],'
f'"ccr":[{",".join(ccr.values())}]}}',
)
except OSError as exc:
logger.warning("SessionTrackerStore: prefix state not saved to %s: %s", path, exc)
return 0
logger.info(
"SessionTrackerStore: saved %d of %d prefix trackers (%d bytes) to %s",
len(entries),
len(self._trackers),
size,
path,
)
return len(entries)
def _encode_tracker(self, key: str, tracker: PrefixCacheTracker, session_id: str | None) -> str:
"""One tracker as JSON, each distinct message stored once.
Successive turns, the lineage snapshots and the original/forwarded
pairs mostly repeat the same messages, so this keeps the file near one
copy of each conversation instead of up to eleven.
"""
index: dict[str, int] = {}
memo: dict[int, list[int]] = {}
def ref(messages: list[Any]) -> list[int]:
if id(messages) not in memo:
refs = []
for message in messages:
blob = json.dumps(message)
refs.append(index.setdefault(blob, len(index)))
memo[id(messages)] = refs
return memo[id(messages)]
def state(s: tuple[Any, ...]) -> list[Any]:
return [s[0], s[1], s[2], ref(s[3]), ref(s[4])]
maturation = tracker.read_maturation_manager
meta = {
"key": key,
"session": session_id,
"affinity": self._lineage_affinities.get(key),
"provider": tracker.provider,
"last_activity": tracker._last_activity,
"cache_ttl": tracker._cache_ttl_seconds,
"state": state(tracker._turn_state()),
"turns": [[t, state(s)] for t, s in tracker._turn_states.items() if s is not None],
"history": [[ref(snap), t] for snap, t in self._lineage_history.get(key, ())],
"maturation": None if maturation is None else maturation.export_state(),
}
return f'{{"meta":{json.dumps(meta)},"messages":[{",".join(index)}]}}'
def load_state(self, path: str) -> int:
"""Resume the trackers :meth:`save_state` wrote, before serving.
Trackers past their retention are dropped. The file is removed once
loaded, so a later crash cannot bring back state older than what it
lost. A missing file is normal; an unreadable or invalid one is logged
and leaves the store empty. Never raises; returns trackers restored.
"""
from headroom.paths import persistence_allowed
# Loading deletes the file, so stateless mode leaves it for a later run.
if not persistence_allowed("prefix-cache tracker state"):
return 0
try:
with open(path, encoding="utf-8") as f:
data = json.load(f)
restored = self._decode_state(data)
except FileNotFoundError:
return 0
except Exception as exc: # any bad file must leave boot unaffected
logger.warning(
"SessionTrackerStore: ignoring prefix state %s (%s: %s)",
path,
type(exc).__name__,
exc,
)
return 0
try:
os.remove(path)
except OSError as exc:
logger.warning("SessionTrackerStore: could not remove %s: %s", path, exc)
logger.info(
"SessionTrackerStore: restored %d of %d prefix trackers from %s",
restored,
len(data["trackers"]),
path,
)
return restored
def _decode_state(self, data: Any) -> int:
"""Validate the whole file first, then install it; a bad file installs nothing."""
from headroom.cache.compression_store import CompressionEntry, get_compression_store
if data.get("version") != _PREFIX_STATE_VERSION:
raise ValueError(f"unsupported version {data.get('version')!r}")
ccr = [CompressionEntry(**record) for record in data["ccr"]]
trackers: dict[str, PrefixCacheTracker] = {}
families: dict[str, OrderedDict[str, list[Any]]] = {}
affinities: dict[str, str | None] = {}
histories: dict[str, deque[tuple[list[Any], int]]] = {}
now = time.time()
# Oldest first, so each family keeps its lineages in creation order.
for entry in reversed(data["trackers"]):
meta, table = entry["meta"], entry["messages"]
tracker = PrefixCacheTracker(str(meta["provider"]), self._default_config)
tracker._last_activity = float(meta["last_activity"])
tracker.observe_cache_ttl(meta["cache_ttl"])
# NaN or a future stamp would never expire.
if tracker.is_expired or not tracker._last_activity <= now:
continue
(
tracker._turn_number,
tracker._cached_token_count,
tracker._cached_message_count,
tracker._last_original_messages,
tracker._last_forwarded_messages,
) = _decode_turn_state(table, meta["state"])
tracker._turn_states = {int(t): _decode_turn_state(table, s) for t, s in meta["turns"]}
tracker.restored_from_disk = True
if meta["maturation"] is not None:
from headroom.transforms.read_maturation import ReadMaturationManager
tracker.restored_maturation_state = ReadMaturationManager.validate_state(
meta["maturation"]
)
key = str(meta["key"])
trackers[key] = tracker
history = deque(
((_deref(table, snap), int(t)) for snap, t in meta["history"]),
maxlen=_LINEAGE_HISTORY,
)
if not history:
continue
histories[key] = history
if meta["session"] is not None:
families.setdefault(str(meta["session"]), OrderedDict())[key] = history[0][0]
affinity = meta["affinity"]
affinities[key] = None if affinity is None else str(affinity)
if ccr and trackers:
# First, so a marker a restored tracker replays resolves from its
# first request; a failure here still installs no tracker.
get_compression_store().import_entries(ccr)
# New turns and lineages must not reuse a restored id.
turns = [t for h in histories.values() for _, t in h]
turns += [t for tracker in trackers.values() for t in tracker._turn_states]
lineage_ns = [
int(n)
for _, sep, n in (key.rpartition("\x00") for key in trackers)
if sep and n.isdecimal()
]
self._turn_counter = itertools.count(max([next(self._turn_counter), *turns]) + 1)
self._lineage_counter = itertools.count(max([next(self._lineage_counter), *lineage_ns]) + 1)
self._trackers.update(trackers)
self._lineage_history.update(histories)
self._lineage_affinities.update(affinities)
for session_id, family in families.items():
self._lineages.setdefault(session_id, OrderedDict()).update(family)
return len(trackers)
+8 -10
View File
@@ -7905,21 +7905,19 @@ def antigravity(
verbose: bool,
prepare_only: bool,
) -> None:
"""Start Headroom proxy for use with Antigravity IDE.
"""Start Headroom proxy for use with the Antigravity IDE.
\b
Antigravity reads its model endpoints from its model-provider settings,
not from environment variables. This command starts the proxy and prints
the settings to add as a custom OpenAI-compatible model provider.
\b
After running this command, open Antigravity and add a custom model
provider with the printed base URL. Antigravity fetches the model list
from GET /v1/models automatically.
The Antigravity IDE does not support third-party model providers —
its agent models are Google-managed. This command starts the proxy
and prints what the integration actually covers: MCP server
registration (`headroom mcp install --agent antigravity`) and the
native `POST /v1internal:streamGenerateContent` endpoint for
`google-antigravity` clients.
\b
Example:
headroom wrap antigravity # Start proxy + Antigravity settings
headroom wrap antigravity # Start proxy + Antigravity setup
headroom wrap antigravity --port 9999 # Custom proxy port
"""
if prepare_only:
+55 -32
View File
@@ -336,8 +336,9 @@ def _is_prompt_too_long(exc: Exception) -> bool:
Matches the known phrasings across backends: claude CLI ("Prompt is too
long"), Anthropic via LiteLLM ("prompt is too long: N tokens > M maximum"),
OpenAI ("context_length_exceeded" / "maximum context length"), and Gemini
("input token count exceeds the maximum").
OpenAI ("context_length_exceeded" / "maximum context length"), Gemini
("input token count exceeds the maximum"), and the codex CLI ("Input exceeds
the maximum length of 1048576 characters").
"""
msg = str(exc).lower()
return any(
@@ -348,6 +349,7 @@ def _is_prompt_too_long(exc: Exception) -> bool:
"maximum context length",
"context window",
"token count exceeds",
"input exceeds the maximum length",
)
)
@@ -392,30 +394,42 @@ def _build_digest(
lines.append(f"Tokens used: {total_tokens_in:,} in / {total_tokens_out:,} out")
lines.append("")
# Detected loops first — the most expensive waste pattern, so the LLM sees
# it before the (budget-truncatable) per-session event stream.
loop_section = format_loops_for_digest(loops)
if loop_section:
lines.append(loop_section)
# Prior learned patterns (if any) — gives the LLM the current baseline so
# it can produce complete updated sections instead of condensed deltas.
prior_section = _build_prior_patterns_section(project)
if prior_section:
lines.append(prior_section)
# Budget tracking — stop adding events when we approach the limit
# Rough estimate: 4 chars per token
char_budget = max_tokens * 4
chars_used = sum(len(ln) for ln in lines)
# Every line costs its length plus the newline joining it, and goes in only
# if it leaves this room for the truncation markers that can follow it (an
# events line, a blank, a sessions line), so the digest stays inside
# char_budget. Only a prior-patterns section that leaves no such room on
# its own (never cut, see below) can push it past.
room = char_budget - 100
# Prior learned patterns (if any) — gives the LLM the current baseline so
# it can produce complete updated sections instead of condensed deltas.
# Never cut: a re-emitted section replaces its prior one wholesale, so a
# partial baseline would drop the missing bullets from the written file.
prior_section = _build_prior_patterns_section(project)
# Detected loops first — the most expensive waste pattern, so the LLM sees
# it before the (budget-truncatable) per-session event stream. The event
# stream cannot trim a section placed ahead of it, so the loops get their
# own cap: a quarter of the budget, less whatever the header and prior
# patterns leave short. Rendered whole, every loop with every index, the
# section alone outgrew the digest on a machine with years of Codex
# sessions, which learn scans as one project.
pre_event_chars = sum(len(ln) + 1 for ln in lines) + len(prior_section) + 2
loop_section = format_loops_for_digest(
loops, max_chars=min(char_budget // 4, room - pre_event_chars)
)
if loop_section:
lines.append(loop_section)
if prior_section:
lines.append(prior_section)
chars_used = sum(len(ln) + 1 for ln in lines)
full = False
for session in sessions:
if chars_used > char_budget:
lines.append(
f"... (remaining {len(sessions) - sessions.index(session)} sessions truncated)"
)
break
session_header = (
f"=== Session {session.session_id[:12]} "
f"({len(session.tool_calls)} calls, {session.failure_count} failures"
@@ -423,29 +437,38 @@ def _build_digest(
if session.total_input_tokens:
session_header += f", {session.total_input_tokens:,} input tokens"
session_header += ") ==="
if full or chars_used + len(session_header) + 1 > room:
lines.append(
f"... (remaining {len(sessions) - sessions.index(session)} sessions truncated)"
)
break
lines.append(session_header)
chars_used += len(session_header)
chars_used += len(session_header) + 1
# Use events if available (richer context), fall back to tool_calls
if session.events:
for event in session.events:
if chars_used > char_budget:
lines.append(" ... (remaining events truncated)")
break
event_line = _format_event(event)
if event_line:
lines.append(event_line)
chars_used += len(event_line)
if not event_line:
continue
if chars_used + len(event_line) + 1 > room:
lines.append(" ... (remaining events truncated)")
full = True
break
lines.append(event_line)
chars_used += len(event_line) + 1
else:
for tc in session.tool_calls:
if chars_used > char_budget:
lines.append(" ... (remaining calls truncated)")
break
tc_line = _format_tool_call(tc)
if chars_used + len(tc_line) + 1 > room:
lines.append(" ... (remaining calls truncated)")
full = True
break
lines.append(tc_line)
chars_used += len(tc_line)
chars_used += len(tc_line) + 1
lines.append("")
chars_used += 1
return "\n".join(lines)
+26 -10
View File
@@ -69,6 +69,11 @@ _PAGINATION_RE = re.compile("|".join(_PAGINATION_PATTERNS), re.IGNORECASE)
# otherwise identical commands do not split a loop into singletons.
_INT_RE = re.compile(r"\b\d+\b")
# A loop's digest line shows its sample input cut to this many chars and its
# first _DIGEST_MAX_INDICES message indices beside its full repeat count.
_SAMPLE_INPUT_CHARS = 120
_DIGEST_MAX_INDICES = 20
@dataclass
class LoopPattern:
@@ -290,7 +295,7 @@ def detect_loops(
LoopPattern(
tool=calls[0].name,
signature=_fuzzy_signature(signatures[key]),
sample_input=calls[0].input_summary[:120],
sample_input=calls[0].input_summary[:_SAMPLE_INPUT_CHARS],
count=count,
is_error_loop=is_error_loop,
wasted_tokens=wasted,
@@ -302,15 +307,19 @@ def detect_loops(
return loops
def format_loops_for_digest(loops: list[LoopPattern]) -> str:
def format_loops_for_digest(loops: list[LoopPattern], max_chars: int | None = None) -> str:
"""Render detected loops as a high-priority digest section for the LLM.
Returns "" when there are no loops so the digest is unchanged in the
common case.
Loops are rendered in the given order (detect_loops sorts them costliest
first). With *max_chars*, rendering stops at the first loop that would
take the section past that many chars, so the costliest ones are kept.
Returns "" when there are no loops, or none fits, so the digest is
unchanged in the common case.
"""
if not loops:
return ""
lines = [
header = [
"=== Detected Loops (HIGHEST PRIORITY) ===",
(
"These tool-call patterns REPEATED within a session — the most "
@@ -321,14 +330,21 @@ def format_loops_for_digest(loops: list[LoopPattern]) -> str:
),
"",
]
used = sum(len(ln) + 1 for ln in header) # each line plus its newline
entries: list[str] = []
for lp in loops:
lines.append(
f'- [{lp.kind}] {lp.tool}: "{lp.sample_input}" '
entry = (
f'- [{lp.kind}] {lp.tool}: "{lp.sample_input[:_SAMPLE_INPUT_CHARS]}" '
f"repeated {lp.count}x, ~{lp.wasted_tokens:,} tokens wasted "
f"(messages {lp.msg_indices})"
f"(messages {lp.msg_indices[:_DIGEST_MAX_INDICES]})"
)
lines.append("")
return "\n".join(lines)
used += len(entry) + 1
if max_chars is not None and used > max_chars:
break
entries.append(entry)
if not entries:
return ""
return "\n".join([*header, *entries, ""])
def _signature_tokens(signature: str) -> set[str]:
+2 -1
View File
@@ -14,6 +14,7 @@ from opentelemetry.metrics import CallbackOptions, Observation
from headroom._version import get_version
from headroom.offline import guard_egress
from headroom.proxy.savings_attribution import event_count
logger = logging.getLogger(__name__)
@@ -558,7 +559,7 @@ class HeadroomOtelMetrics:
realized=bool(item.get("realized", True)),
estimated=bool(item.get("estimated", False)),
)
self._savings_attribution_events.add(1, attrs)
self._savings_attribution_events.add(event_count(item), attrs)
saved = max(0, int(item.get("tokens", 0) or 0))
if saved:
self._savings_attributed_tokens.add(saved, attrs)
+3
View File
@@ -81,6 +81,9 @@ _PINNED_REVISIONS: dict[str, str] = {
"chopratejas/siglip-image-encoder-onnx": "d0a9fbd66d4bd8c761bff592d44831f7c2ae184e",
# Third-party repo — pinning matters most here.
"Qdrant/all-MiniLM-L6-v2-onnx": "5f1b8cd78bc4fb444dd171e59b18f3a3af89a079",
# Default relevance embedder (BAAI/bge-small-en-v1.5), third-party too.
# relevance/embedding.py downloads each of its files at this SHA.
"Qdrant/bge-small-en-v1.5-onnx-Q": "52398278842ec682c6f32300af41344b1c0b0bb2",
}
+6 -2
View File
@@ -813,13 +813,15 @@ def format_report(report: PerfReport) -> str:
# exactly zero tokens; every token-savings channel in the proxy would record
# it as nothing. Showing `$` beside a `0 tokens` row is the honest rendering
# of that, and collapsing them into one number would be an invented saving.
from headroom.proxy.savings_attribution import event_count
by_source: dict[tuple[str, bool], dict[str, float]] = {}
for record in report.perf_records:
for item in getattr(record, "savings_breakdown", ()) or ():
source = str(item.get("source") or "other")
realized = bool(item.get("realized", True))
row = by_source.setdefault((source, realized), {"events": 0, "tokens": 0, "usd": 0.0})
row["events"] += 1
row["events"] += event_count(item)
row["tokens"] += max(0, _as_number(item.get("tokens"), int))
row["usd"] += _as_number(item.get("usd"), float)
if by_source:
@@ -1356,6 +1358,8 @@ def build_perf_summary(report: PerfReport) -> dict:
}
)
from headroom.proxy.savings_attribution import event_count
by_source_groups: dict[tuple[str, bool], dict[str, int | float | str | bool]] = {}
for record in records:
for item in record.savings_breakdown:
@@ -1372,7 +1376,7 @@ def build_perf_summary(report: PerfReport) -> dict:
"usd": 0.0,
},
)
row["events"] = int(row["events"]) + 1
row["events"] = int(row["events"]) + event_count(item)
raw_tokens = item.get("tokens", 0)
raw_usd = item.get("usd", 0.0)
tokens = int(raw_tokens) if isinstance(raw_tokens, (str, int, float)) else 0
+25 -10
View File
@@ -22,9 +22,9 @@ def build_proxy_targets(port: int, project: str | None = None) -> AntigravityPro
"""Build the local proxy URLs shown to Antigravity users.
``project`` (the wrap launch directory) is encoded as a ``/p/<name>``
base-URL prefix because Antigravity's custom model-provider settings
cannot send custom headers; the proxy strips it and attributes savings
per project.
base-URL prefix because clients pointing at these URLs cannot be
counted on to send custom headers; the proxy strips it and attributes
savings per project.
"""
return AntigravityProxyTargets(
openai_base_url=with_project_prefix(codex_proxy_base_url(port), project),
@@ -35,17 +35,32 @@ def build_proxy_targets(port: int, project: str | None = None) -> AntigravityPro
def render_setup_lines(port: int, project: str | None = None) -> list[str]:
"""Render the Antigravity setup instructions for the local proxy."""
targets = build_proxy_targets(port, project)
# The Gemini-compatible base URL (scheme://host; Gemini clients append
# /v1beta/...) — the one agy expects for GOOGLE_GEMINI_BASE_URL.
gemini_base_url = with_project_prefix(f"http://127.0.0.1:{port}", project)
lines = [
" Headroom proxy is running. Configure Antigravity:",
" Headroom proxy is running. Antigravity setup:",
"",
" Antigravity reads model endpoints from its model-provider settings,",
" not from environment variables. Add a custom OpenAI-compatible",
" model provider pointing at the proxy:",
" The Antigravity IDE does not support third-party model providers —",
" its agent models are Google-managed, so there is no settings panel",
" to point at the proxy. What the proxy does offer Antigravity users:",
"",
" - MCP tools: `headroom mcp install --agent antigravity` registers",
" the Headroom MCP server in Antigravity's global mcp_config.json.",
" - Native traffic: the proxy accepts `google-antigravity` client",
" traffic on POST /v1internal:streamGenerateContent, routed",
" upstream like any other Cloud Code request.",
"",
" The Antigravity CLI (agy), unlike the IDE, accepts a custom",
" endpoint via its GOOGLE_GEMINI_BASE_URL setting — point it at",
" the proxy's Gemini-compatible base URL:",
"",
f" GOOGLE_GEMINI_BASE_URL={gemini_base_url}",
"",
" For OpenAI-speaking clients, the proxy's OpenAI-compatible",
" base URL is:",
"",
f" Base URL: {targets.openai_base_url}",
" API Key: your-openai-api-key",
"",
" Antigravity fetches the model list from GET /v1/models automatically,",
" so there is nothing else to register.",
]
return lines + project_attribution_lines(project)
+13
View File
@@ -2029,6 +2029,15 @@ class AnthropicHandlerMixin:
compression_policy = resolve_policy(getattr(request.state, "auth_mode", None))
if is_token_mode(self.config.mode):
comp_cache = self._get_compression_cache(session_id)
from headroom.cache.prefix_tracker import (
seed_restored_compression_cache,
)
# Seeds the empty cache after a restart
# (HEADROOM_PREFIX_STATE_FILE); without it the clamp below
# freezes nothing and read maturation rewrites Reads
# inside the cached prefix.
seed_restored_compression_cache(prefix_tracker, comp_cache)
# Freeze + stable marking + Zone-1 swap now live in the
# shared session engine (PROXY policy: clamp by BOTH the
@@ -2609,6 +2618,10 @@ class AnthropicHandlerMixin:
compression_store=get_compression_store(),
)
prefix_tracker.read_maturation_manager = maturation_mgr
state = getattr(prefix_tracker, "restored_maturation_state", None)
if state is not None:
prefix_tracker.restored_maturation_state = None
maturation_mgr.restore_state(state)
_maturation_mgr = maturation_mgr
maturation = maturation_mgr.apply(
optimized_messages,
+88 -13
View File
@@ -22,6 +22,7 @@ from collections import OrderedDict
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import replace
from datetime import datetime
from types import MappingProxyType
from typing import TYPE_CHECKING, Any
from urllib.parse import quote, unquote, urlparse
@@ -46,12 +47,16 @@ from headroom.proxy.provider_usage import (
)
from headroom.proxy.rate_limit_identity import rate_limit_identity
from headroom.proxy.savings import ItemMeasure, get_item_ledger, prefix_key, responses_items
from headroom.proxy.savings_attribution import SAVINGS_ATTRIBUTION_TAG
from headroom.proxy.savings_attribution import accumulate as accumulate_savings
from headroom.proxy.savings_attribution import from_tags as savings_from_tags
from headroom.proxy.semantic_cache_key_policy import compute_request_cache_partition
from headroom.proxy.stage_timer import StageTimer, emit_stage_timings_log
from headroom.proxy.tool_schema_savings_policy import (
net_hook_tool_saving,
without_deferral_flags,
)
from headroom.proxy.turn_hooks import run_responses_create_hooks
from headroom.proxy.upstream_guard import is_safe_upstream_url
from headroom.proxy.ws_headers import WS_HOP_BY_HOP_HEADERS
from headroom.proxy.ws_session_registry import (
@@ -1959,6 +1964,24 @@ class OpenAIHandlerMixin:
except Exception as exc:
logger.debug("[%s] Traffic learner (ws): %s", request_id, exc)
@staticmethod
async def _run_ws_create_hooks(
frame: Any, ws_headers: dict[str, str], connection_id: str
) -> bool:
"""Run ``on_responses_create`` on a WS create frame's inner payload.
True when a hook changed it, so the caller re-serializes the frame.
"""
inner = frame.get("response", frame) if isinstance(frame, dict) else None
if not isinstance(inner, dict):
return False
return await run_responses_create_hooks(
inner,
headers=MappingProxyType(ws_headers),
transport="websocket",
connection_id=connection_id,
)
@staticmethod
def _headroom_bypass_enabled(headers: Any) -> bool:
"""Return True when inbound headers request full passthrough."""
@@ -3798,6 +3821,12 @@ class OpenAIHandlerMixin:
if is_token_mode(self.config.mode):
comp_cache = self._get_compression_cache(openai_session_id)
from headroom.cache.prefix_tracker import seed_restored_compression_cache
# Seeds the empty cache after a restart
# (HEADROOM_PREFIX_STATE_FILE); without it the freeze below
# freezes nothing.
seed_restored_compression_cache(openai_prefix_tracker, comp_cache)
if not is_cache_mode(self.config.mode):
# Token mode: shared engine, REPLAYABLE policy — its
@@ -5669,8 +5698,6 @@ class OpenAIHandlerMixin:
},
)
model = body.get("model", "unknown")
stream = body.get("stream", False)
body_mutation_tracker = BodyMutationTracker()
_bypass = self._headroom_bypass_enabled(request.headers)
if _bypass:
@@ -5690,8 +5717,17 @@ class OpenAIHandlerMixin:
url=str(request.url),
headers=dict(request.headers.items()),
body=body,
metadata={"path": request.url.path, "stream": stream},
metadata={"path": request.url.path, "stream": body.get("stream", False)},
)
# Before every stage that reads the body, so a hook's replacement is
# what compression, deferral, token counting, pricing and the
# stream/buffered dispatch all see.
if not _bypass and await run_responses_create_hooks(
body, headers=request.headers, transport="http"
):
body_mutation_tracker.mark_mutated("responses_create_hook")
model = body.get("model", "unknown")
stream = body.get("stream", False)
# /v1/responses uses provider-specific CompressionUnit extraction
# below, then routes mutable text through ContentRouter. The
@@ -7182,6 +7218,12 @@ class OpenAIHandlerMixin:
# handshake. Returns `{}` when no tags are present.
_extract_ws_tags = getattr(self, "_extract_tags", None)
ws_tags = _extract_ws_tags(ws_headers) if callable(_extract_ws_tags) else {}
# Savings attribution rows (turn hooks, tool-search deferral) from frames
# that were rewritten and sent, waiting for the next turn's outcome. Each
# frame compresses into its own dict: a timed-out compression thread
# keeps running and must not book rows for a frame sent uncompressed.
# Coalesced per source by ``accumulate_savings``, so it stays small.
ws_turn_savings: list[dict[str, Any]] = []
# Extract subprotocol from client — this is an application-level negotiation
# that MUST be forwarded end-to-end (unlike sec-websocket-key which is per-connection).
@@ -7653,6 +7695,19 @@ class OpenAIHandlerMixin:
except json.JSONDecodeError:
# Not JSON — pass through as-is
pass
first_frame_is_create = isinstance(body, dict) and (
body.get("type") == "response.create" or ("type" not in body and "input" in body)
)
_ws_bypass = self._headroom_bypass_enabled(ws_headers)
if _ws_bypass:
logger.info(
"[%s] WS /v1/responses passthrough reason=bypass_header mutation=disabled",
request_id,
)
elif first_frame_is_create and await self._run_ws_create_hooks(
body, ws_headers, session_id
):
first_msg_raw = json.dumps(body)
if isinstance(body, dict) and body:
ws_response_body_for_store = (
body["response"] if isinstance(body.get("response"), dict) else body
@@ -7698,12 +7753,6 @@ class OpenAIHandlerMixin:
ws_recorded_compression_timing_totals: dict[str, float] = {}
ws_ttfb_ms: float | None = None
ws_recorded_ttfb_ms = False
_ws_bypass = self._headroom_bypass_enabled(ws_headers)
if _ws_bypass:
logger.info(
"[%s] WS /v1/responses passthrough reason=bypass_header mutation=disabled",
request_id,
)
capture_codex_wire_debug(
"ws_inbound_first_frame",
@@ -8135,9 +8184,7 @@ class OpenAIHandlerMixin:
logger.warning(f"[{request_id}] WS Memory injection failed: {e}")
return frame_raw
if isinstance(body, dict) and (
body.get("type") == "response.create" or ("type" not in body and "input" in body)
):
if first_frame_is_create:
first_msg_raw = await _prepare_memory_frame(body, first_msg_raw)
first_response_body = body.get("response", body)
current_response_input = _responses_input_to_items(
@@ -8193,6 +8240,7 @@ class OpenAIHandlerMixin:
)
_record_ws_compression_overhead(_preflight_ms)
_compression_started = time.perf_counter()
_frame_savings: dict[str, Any] = {}
try:
(
_new_inner,
@@ -8212,6 +8260,7 @@ class OpenAIHandlerMixin:
if client == "codex"
else COMPRESSION_TIMEOUT_SECONDS,
client=client,
savings_tags=_frame_savings,
)
for _timing_name, _timing_ms in _ws_compression_timing.items():
_record_ws_compression_timing(_timing_name, _timing_ms)
@@ -8260,6 +8309,9 @@ class OpenAIHandlerMixin:
)
_record_ws_compression_overhead(_rewrite_ms)
tokens_saved += int(_ws_saved)
accumulate_savings(
ws_turn_savings, savings_from_tags(_frame_savings)
)
ws_conversation_tokens_saved = int(_ws_saved)
ws_conversation_key = savings_conversation_key(
_send_body, session_id=f"ws:{session_id}"
@@ -8586,6 +8638,7 @@ class OpenAIHandlerMixin:
)
_record_ws_compression_overhead(_preflight_ms)
_compression_started = time.perf_counter()
frame_savings: dict[str, Any] = {}
try:
(
new_inner,
@@ -8605,6 +8658,7 @@ class OpenAIHandlerMixin:
if client == "codex"
else COMPRESSION_TIMEOUT_SECONDS,
client=client,
savings_tags=frame_savings,
)
for _timing_name, _timing_ms in frame_compression_timing.items():
_record_ws_compression_timing(_timing_name, _timing_ms)
@@ -8754,6 +8808,7 @@ class OpenAIHandlerMixin:
)
_record_ws_compression_overhead(_rewrite_ms)
tokens_saved += int(frame_saved)
accumulate_savings(ws_turn_savings, savings_from_tags(frame_savings))
ws_conversation_tokens_saved = int(frame_saved)
ws_conversation_key = savings_conversation_key(
new_inner, session_id=f"ws:{session_id}"
@@ -8855,6 +8910,10 @@ class OpenAIHandlerMixin:
inbound_response = _inbound_frame_body.get(
"response", _inbound_frame_body
)
if not _ws_bypass and await self._run_ws_create_hooks(
_inbound_frame_body, ws_headers, session_id
):
msg = json.dumps(_inbound_frame_body)
current_response_input = _responses_input_to_items(
inbound_response.get("input")
if isinstance(inbound_response, dict)
@@ -9110,6 +9169,15 @@ class OpenAIHandlerMixin:
# at the WS upgrade) so dashboards can
# slice WS turns by tag — same surface
# as HTTP turns.
# Same gate as ``saved_delta``: a usage-less turn
# leaves its rows pending for a usage-carrying one.
turn_tags = ws_tags
if ws_turn_savings and input_delta > 0:
turn_tags = {
**ws_tags,
SAVINGS_ATTRIBUTION_TAG: list(ws_turn_savings),
}
ws_turn_savings.clear()
await self._record_request_outcome(
RequestOutcome(
# Per-emission ids keep dashboard request-log keys unique.
@@ -9140,7 +9208,7 @@ class OpenAIHandlerMixin:
)
if isinstance(body, dict)
else 0,
tags=ws_tags,
tags=turn_tags,
conversation_key=ws_conversation_key,
conversation_tokens_saved=ws_conversation_tokens_saved,
client=client,
@@ -9755,6 +9823,10 @@ class OpenAIHandlerMixin:
"cache_write_tokens": str(ws_cache_write_tokens_total),
"uncached_input_tokens": str(ws_uncached_input_tokens_total),
}
if ws_turn_savings and residual_input_tokens > 0:
# Rows no per-turn record claimed ride with the residual, under
# the same input-usage gate as ``residual_tokens_saved``.
ws_session_tags[SAVINGS_ATTRIBUTION_TAG] = list(ws_turn_savings)
if (
residual_input_tokens > 0
or residual_output_tokens > 0
@@ -10629,6 +10701,9 @@ class OpenAIHandlerMixin:
session_tracker = self.session_tracker_store.get_or_create(
_session_key, _tracker_provider
)
from headroom.cache.prefix_tracker import seed_restored_compression_cache
seed_restored_compression_cache(session_tracker, comp_cache)
# A claimed turn prepares its executor-side work here (tokenizer,
# hooks, scope binding) — CPU-bound parts run inside the closures
+76 -20
View File
@@ -20,6 +20,7 @@ from headroom.proxy.helpers import (
RETRYABLE_OVERLOAD_STATUSES,
jitter_delay_ms,
overload_retry_is_futile,
parse_sse_events_from_byte_buffer,
retry_after_ms,
)
from headroom.proxy.provider_usage import (
@@ -1652,6 +1653,13 @@ class StreamingMixin:
full_sse_bytes = bytearray()
parsed_response = None # Set by memory block; used by CCR + prefix tracker
completed_normally = False
# Set when the client hangs up after the terminal event; it marks
# the outcome only, so pending messages are not drained into a
# stream nobody reads.
client_left_after_terminal = False
# A terminal event the client was handed, not just one parsed from
# upstream: the memory filter holds message_stop until the end.
client_got_terminal = False
pending_messages: list[dict] = []
# Proxy-injected memory tools are invisible to the client, so their
# tool_use blocks must never reach it (GH #2195).
@@ -1661,6 +1669,23 @@ class StreamingMixin:
else None
)
def _client_frame(frame: bytes) -> bytes:
"""``_guard_client_bytes``, noting when the terminal event goes out."""
nonlocal client_got_terminal
guarded = _guard_client_bytes(frame)
if guarded and not client_got_terminal:
if memory_filter is None:
# Unfiltered, the client gets each whole chunk once it
# is parsed, so every event the parser has seen.
client_got_terminal = stream_state["stream_terminal"]
else:
# Filtered frames are complete events the filter decoded.
client_got_terminal = any(
_sse_event_outcome(name, data, stream_state["sse_dialect"])[1]
for name, data in parse_sse_events_from_byte_buffer(bytearray(frame))
)
return guarded
try:
async with contextlib.aclosing(upstream_response) as response:
sse_chunk_index = 0
@@ -1690,19 +1715,6 @@ class StreamingMixin:
tail = bytes(stream_state["sse_buffer"][-MAX_SSE_BUFFER_SIZE // 2 :])
stream_state["sse_buffer"] = bytearray(tail)
# Always stream immediately — buffering breaks
# real-time clients (LangGraph, LangChain, etc.)
# The context guard runs last, on exactly what the
# client receives (after the memory filter), and may
# hold back bytes only until the first complete event.
client_frames = (
[chunk] if memory_filter is None else memory_filter.feed(chunk)
)
for frame in client_frames:
guarded_frame = _guard_client_bytes(frame)
if guarded_frame:
yield guarded_frame
if _codex_wire_debug:
capture_codex_wire_debug(
"http_stream_upstream_chunk",
@@ -1735,8 +1747,14 @@ class StreamingMixin:
)
memory_enabled = False
# Parse complete SSE events from buffer
usage = self._parse_sse_usage_from_buffer(stream_state, provider)
# Parse complete SSE events from buffer. A failure (e.g.
# invalid UTF-8) is raised once the chunk is forwarded:
# malformed upstream content still reaches the client.
parse_error: Exception | None = None
try:
usage = self._parse_sse_usage_from_buffer(stream_state, provider)
except Exception as e:
usage, parse_error = None, e
if usage:
if "input_tokens" in usage:
stream_state["input_tokens"] = usage["input_tokens"]
@@ -1759,6 +1777,24 @@ class StreamingMixin:
"cache_creation_ephemeral_1h_input_tokens"
]
# Always stream immediately — buffering breaks
# real-time clients (LangGraph, LangChain, etc.)
# The context guard runs last, on exactly what the
# client receives (after the memory filter), and may
# hold back bytes only until the first complete event.
# Yielded only after the chunk is parsed: a client may
# hang up on the terminal event (Codex does), closing
# this generator at the yield.
client_frames = (
[chunk] if memory_filter is None else memory_filter.feed(chunk)
)
for frame in client_frames:
guarded_frame = _client_frame(frame)
if guarded_frame:
yield guarded_frame
if parse_error is not None:
raise parse_error
# Memory tool handling after stream completes
# Chunks were already yielded in real-time above, so we only
# do silent background processing here — no yielding.
@@ -1780,7 +1816,7 @@ class StreamingMixin:
)
if memory_filter is not None:
for frame in memory_filter.closing_frames():
guarded_frame = _guard_client_bytes(frame)
guarded_frame = _client_frame(frame)
if guarded_frame:
yield guarded_frame
guarded_tail = _drain_context_guard()
@@ -1804,7 +1840,7 @@ class StreamingMixin:
stream_state=stream_state,
request_id=request_id,
):
guarded_frame = _guard_client_bytes(frame)
guarded_frame = _client_frame(frame)
if guarded_frame:
yield guarded_frame
memory_filter = None
@@ -1849,7 +1885,7 @@ class StreamingMixin:
stream_state=stream_state,
request_id=request_id,
):
guarded_frame = _guard_client_bytes(frame)
guarded_frame = _client_frame(frame)
if guarded_frame:
yield guarded_frame
@@ -1900,6 +1936,13 @@ class StreamingMixin:
stream_state["stream_terminal"] and not stream_state["stream_failed"]
)
except (GeneratorExit, asyncio.CancelledError):
# Codex closes the connection as soon as it reads
# response.completed, before the upstream EOF ends the loop.
client_left_after_terminal = (
client_got_terminal and not stream_state["stream_failed"]
)
raise
except (httpx.ConnectError, httpx.ConnectTimeout, httpx.PoolTimeout) as e:
logger.error(f"[{request_id}] Connection error to upstream API: {e}")
guarded_tail = _drain_context_guard()
@@ -1985,7 +2028,8 @@ class StreamingMixin:
client=client,
waste_signals=waste_signals,
status_code=_stream_outcome_status(
upstream_response.status_code, completed_normally
upstream_response.status_code,
completed_normally or client_left_after_terminal,
),
conversation_key=conversation_key,
conversation_tokens_saved=conversation_tokens_saved,
@@ -2143,7 +2187,6 @@ class StreamingMixin:
chunk_bytes = sse_line.encode()
if prefix_tracker is not None:
full_sse_bytes.extend(chunk_bytes)
yield chunk_bytes
# Track usage from message_start event
if event.event_type == "message_start":
@@ -2188,9 +2231,15 @@ class StreamingMixin:
stream_terminal = stream_terminal or terminal
if failed:
logger.error(f"[{request_id}] Bedrock stream error: {event.data}")
# After the bookkeeping: the client may hang up on the terminal event.
yield chunk_bytes
completed_normally = stream_terminal and not stream_failed
except (GeneratorExit, asyncio.CancelledError):
# A client that hung up after the terminal event got the whole stream.
completed_normally = stream_terminal and not stream_failed
raise
except Exception as e:
error_message = format_exception_message(e)
logger.error(f"[{request_id}] Bedrock streaming error: {error_message}")
@@ -2410,6 +2459,13 @@ class StreamingMixin:
completed_normally = (
stream_state.get("stream_terminal", False) and not stream_failed
)
except (GeneratorExit, asyncio.CancelledError):
# A client that hung up after the terminal event got the whole stream.
stream_failed = stream_state.get("stream_failed", False)
completed_normally = (
stream_state.get("stream_terminal", False) and not stream_failed
)
raise
except Exception as e:
logger.error(f"[{request_id}] Backend streaming error: {e}")
error_data = public_errors.openai_error_body(
+27 -6
View File
@@ -22,6 +22,7 @@ if TYPE_CHECKING:
from headroom import savings_ledger
from headroom.observability import get_otel_metrics
from headroom.proxy.savings_attribution import event_count
from headroom.proxy.savings_tracker import SavingsTracker, estimate_request_savings_usd
logger = logging.getLogger("headroom.proxy")
@@ -654,6 +655,24 @@ class PrometheusMetrics:
if saved > 0:
self.extension_savings[key] += saved
def extension_savings_by_source(self) -> dict[str, int]:
"""Measured savings per source, as ``/stats`` reports ``extension_savings``.
Realized savings attribution rows (``ctx.record_savings`` from a turn
hook, ``record_scope_savings``) plus ``record_extension_savings`` totals.
A source reported through both APIs (``headroom-hdr`` does, per request)
shows the larger of the two totals rather than their sum: nothing ties an
attribution row to a ``record_extension_savings`` call, so summing would
double-count it. Estimated rows (``realized=False``) stay in
``savings.by_source`` only.
"""
out = dict(self.extension_savings)
for row in list(self.savings_by_source.values()):
source, tokens = str(row["source"]), int(row["tokens"])
if row["realized"] and tokens > out.get(source, 0):
out[source] = tokens
return out
def record_compression_failed(self, reason: str) -> None:
"""Record one fail-open compression failure, bucketed by ``reason``.
@@ -884,6 +903,10 @@ class PrometheusMetrics:
from headroom.telemetry.context import MAX_DISTINCT_MODELS
ledger_input_tokens = input_tokens if local_input_tokens is None else local_input_tokens
# An inferred write is the uncached slice under another name (see
# ``cache_inferred``), so it adds neither new input nor a billed write.
billed_write_tokens = 0 if cache_inferred else cache_write_tokens
new_input_tokens = int(uncached_input_tokens) + int(billed_write_tokens)
# Post-guard invariant (all providers): Headroom never forwards a request
# larger than the original — handlers revert any inflation before sending
# (verified clean on the wire). So compression savings are >= 0; a negative
@@ -970,7 +993,7 @@ class PrometheusMetrics:
"usd": 0.0,
},
)
row["events"] = int(row["events"]) + 1
row["events"] = int(row["events"]) + event_count(item)
row["tokens"] = int(row["tokens"]) + max(0, int(item.get("tokens", 0) or 0))
row["usd"] = round(
float(row["usd"]) + float(item.get("usd", 0.0) or 0.0),
@@ -982,14 +1005,14 @@ class PrometheusMetrics:
# New-input cohort, on the same predicate the ledger uses below.
if uncached_input_tokens > 0 or cache_write_tokens > 0:
self.new_input_tokens_total += uncached_input_tokens + cache_write_tokens
self.new_input_tokens_total += new_input_tokens
self.new_input_saved_tokens_total += max(0, int(tokens_saved))
# Track provider-specific prefix cache metrics
if cache_read_tokens > 0 or cache_write_tokens > 0:
pc = self.cache_by_provider[provider]
pc["cache_read_tokens"] += cache_read_tokens
pc["cache_write_tokens"] += cache_write_tokens
pc["cache_write_tokens"] += billed_write_tokens
pc["cache_write_5m_tokens"] += cache_write_5m_tokens
pc["cache_write_1h_tokens"] += cache_write_1h_tokens
if cache_write_5m_tokens > 0:
@@ -1180,9 +1203,7 @@ class PrometheusMetrics:
# show the same new-input rate the dashboard headline does.
# Omitted when there is no cache breakdown (e.g. Bedrock), so
# the ledger never divides savings by themselves.
new_input_tokens=(
int(uncached_input_tokens) + int(cache_write_tokens) if has_new_input else None
),
new_input_tokens=new_input_tokens if has_new_input else None,
deferred_tokens=deferral_saved,
)
+127 -7
View File
@@ -6,12 +6,12 @@ import base64
import json
import math
import re
from collections.abc import MutableMapping
import warnings
from collections.abc import Iterable, MutableMapping
from typing import Any
SAVINGS_ATTRIBUTION_TAG = "_headroom_savings_attribution"
_NAME_RE = re.compile(r"[^a-z0-9_.-]+")
MAX_SOURCES = 32
_SCOPE_KEY = "headroom_savings_attribution"
# Per-request stage timings contributed from outside the handler, merged into
@@ -51,6 +51,22 @@ STAGE_PREFIX = "ext:"
# (16 stages x 1h is nowhere near the float ceiling).
MAX_STAGE_MS = 3_600_000.0
# Source names are extension-supplied, so a ledger keeps at most this many
# rows by name. A source past it folds into ``other`` -- one row per
# (realized, estimated) -- so storage and the per-insert scan stay bounded
# while every token, dollar and event is still booked.
MAX_NAMED_ROWS = 256
OVERFLOW_SOURCE = "other"
# Core-booked sources never fold: ``tool_schema_savings_policy`` finds the
# deferral's row by name to lower it when hooks un-defer tools.
_UNFOLDED_SOURCES = frozenset({"tool_search"})
# A row's sums saturate here instead of overflowing to ``inf`` (see
# MAX_STAGE_MS for what a non-finite value does downstream). Both are far
# beyond any real saving; a saturated row is flagged ``saturated``.
MAX_ROW_USD = 1e15
MAX_ROW_TOKENS = 10**15
def _source_name(value: object) -> str:
name = _NAME_RE.sub("_", str(value or "other").strip().lower()).strip("_.-")
@@ -164,9 +180,6 @@ def record_savings(
details: dict[str, Any] | None = None,
) -> None:
"""Attribute savings to a source; this never changes headline totals."""
ledger = _ledger(tags)
if len(ledger) >= MAX_SOURCES:
return
# Same hazard as MAX_STAGE_MS, on the amounts rather than the durations:
# ``usd=inf`` reaches ``/stats`` and raises out of the JSON encoder, and
# ``int(inf)`` raises OverflowError right here, inside the handler, on a
@@ -193,14 +206,106 @@ def record_savings(
for key, value in list(details.items())[:12]
if isinstance(value, (str, int, float, bool)) or value is None
}
ledger.append(item)
accumulate(_ledger(tags), [item])
def from_tags(tags: MutableMapping[str, Any] | None) -> list[dict[str, Any]]:
raw = (tags or {}).get(SAVINGS_ATTRIBUTION_TAG)
if not isinstance(raw, list):
return []
return [dict(item) for item in raw[:MAX_SOURCES] if isinstance(item, dict)]
return [dict(item) for item in raw if isinstance(item, dict)]
def event_count(row: dict[str, Any]) -> int:
"""How many recordings a row stands for; a row without ``events`` is one."""
try:
return max(1, int(row.get("events", 1)))
except (TypeError, ValueError, OverflowError):
return 1
def accumulate(rows: list[dict[str, Any]], items: Iterable[dict[str, Any]]) -> None:
"""Add ``items`` to ``rows``, one row per (source, realized, estimated).
Every writer goes through here -- the per-request ledger and a WS session's
pending rows alike -- and no amount is ever dropped. Same-key rows sum
``tokens``, ``usd`` and ``events``; ``details`` stay only while every
summed row agrees. Once ``rows`` holds ``MAX_NAMED_ROWS`` rows, a new
source folds into ``OVERFLOW_SOURCE`` (which also takes unnamed savings),
so the list grows by at most the overflow and ``_UNFOLDED_SOURCES`` keys.
"""
for item in items:
key = _key(item)
target = _row_for(rows, key)
if (
target is None
and key[0] not in _UNFOLDED_SOURCES
and _row_count(rows) >= MAX_NAMED_ROWS
):
if key[0] != OVERFLOW_SOURCE:
# Details describe one source; the overflow row mixes several.
item = {k: v for k, v in item.items() if k != "details"}
key = (OVERFLOW_SOURCE, key[1], key[2])
target = _row_for(rows, key)
if target is None:
target = {**item, "source": key[0], "tokens": 0, "usd": 0.0, "events": 0}
rows.append(target)
else:
if target.get("details") != item.get("details"):
target.pop("details", None)
target["events"] = event_count(target)
_add_into(target, item)
def _add_into(target: dict[str, Any], item: dict[str, Any]) -> None:
"""Sum ``item`` into ``target``; a total that hit a bound stays flagged."""
tokens, tokens_clipped = _bounded(target.get("tokens"), item.get("tokens"), 0, MAX_ROW_TOKENS)
usd, usd_clipped = _bounded(target.get("usd"), item.get("usd"), -MAX_ROW_USD, MAX_ROW_USD)
target["tokens"] = int(tokens)
target["usd"] = round(usd, 12)
target["events"] += event_count(item)
if tokens_clipped or usd_clipped or item.get("saturated"):
target["saturated"] = True
def _bounded(current: Any, added: Any, low: float, high: float) -> tuple[float, bool]:
"""``current + added`` held inside ``[low, high]``, and whether it was clipped."""
a, a_clipped = _operand(current, low, high)
b, b_clipped = _operand(added, low, high)
total = max(low, min(a + b, high))
return total, a_clipped or b_clipped or total != a + b
def _operand(value: Any, low: float, high: float) -> tuple[float, bool]:
# Rows are plain dicts a reader may edit (deferral reconcile, plugins), so
# an operand can be junk; summing must not raise inside the handler. A
# non-finite or oversized operand reads as the bound it passed, never as
# zero, so a saturated total is not reset by the next update.
try:
number = float(value or 0)
except OverflowError: # an int beyond float range
number = math.inf if value > 0 else -math.inf
except (TypeError, ValueError):
return 0.0, False
if math.isnan(number):
return 0.0, False
bounded = max(low, min(number, high))
return bounded, bounded != number
def _row_count(rows: list[Any]) -> int:
return sum(1 for row in rows if isinstance(row, dict))
def _key(row: dict[str, Any]) -> tuple[str, bool, bool]:
# ``realized`` defaults to True, as in every consumer of these rows.
return (str(row.get("source")), bool(row.get("realized", True)), bool(row.get("estimated")))
def _row_for(rows: list[dict[str, Any]], key: tuple[str, bool, bool]) -> dict[str, Any] | None:
# The ledger is a plain list reachable through ``tags``; skip what this
# module did not write rather than raise inside the handler.
return next((row for row in rows if isinstance(row, dict) and _key(row) == key), None)
_INTERNAL_TAGS = frozenset({SAVINGS_ATTRIBUTION_TAG, STAGE_TIMING_TAG})
@@ -246,3 +351,18 @@ def decode(value: str) -> list[dict[str, Any]]:
if isinstance(decoded, list)
else []
)
def __getattr__(name: str) -> Any:
# MAX_SOURCES used to cap a request's ledger at 32 rows and silently drop
# the rest; rows now coalesce per source, and sources past MAX_NAMED_ROWS
# fold into OVERFLOW_SOURCE. Kept for importers.
if name == "MAX_SOURCES":
warnings.warn(
"headroom.proxy.savings_attribution.MAX_SOURCES is unused and will be "
"removed; rows coalesce per source, past MAX_NAMED_ROWS into 'other'.",
DeprecationWarning,
stacklevel=2,
)
return 32
raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+17 -1
View File
@@ -1203,6 +1203,8 @@ class HeadroomProxy(
session_ttl_seconds=config.prefix_freeze_session_ttl,
)
)
# Set by startup() when HEADROOM_PREFIX_STATE_FILE opts in.
self._prefix_state_file: str | None = None
# Compression cache store for token mode (session-scoped). The dict
# itself is mutated under `_compression_caches_lock`; the per-session
@@ -2048,6 +2050,17 @@ class HeadroomProxy(
async def startup(self):
"""Initialize async resources."""
self._get_shutdown_event().clear()
# Opt-in: resume the prefix trackers the previous process saved on its
# graceful shutdown, so warm conversations replay their cached prefix.
from headroom.cache.prefix_tracker import PREFIX_STATE_FILE_ENV, prefix_state_file
self._prefix_state_file = prefix_state_file()
if self._prefix_state_file and _MULTI_WORKER_CONFIG_ENV in os.environ:
# Each worker holds its own trackers; one file cannot hold them all.
logger.warning("%s ignored: not supported with multiple workers", PREFIX_STATE_FILE_ENV)
self._prefix_state_file = None
if self._prefix_state_file:
self.session_tracker_store.load_state(self._prefix_state_file)
self.pipeline_extensions.emit(
PipelineStage.PRE_START,
operation="proxy.startup",
@@ -2395,6 +2408,9 @@ class HeadroomProxy(
async def shutdown(self):
"""Cleanup async resources."""
self._get_shutdown_event().set()
# First, before any await can hit the shutdown step timeout.
if self._prefix_state_file:
self.session_tracker_store.save_state(self._prefix_state_file)
if self.http_client_h1 and self.http_client_h1 is not self.http_client:
await self.http_client_h1.aclose()
self.http_client_h1 = None
@@ -5276,7 +5292,7 @@ def create_app(config: ProxyConfig | None = None) -> FastAPI:
else {},
"compressions_by_strategy": dict(m.compressions_by_strategy),
"tokens_saved_by_strategy": dict(m.tokens_saved_by_strategy),
"extension_savings": dict(m.extension_savings),
"extension_savings": m.extension_savings_by_source(),
"codex_ws": {
"units_total": m.codex_ws_units_total,
"units_modified_total": m.codex_ws_units_modified_total,
+4 -3
View File
@@ -84,9 +84,10 @@ def deferred_booking(tags: object, tools: object) -> DeferredBooking | None:
``None`` when nothing is booked. The schemas are copied as they were when
booked, so a later in-place edit cannot change what the credit stands for.
The ledger entry is the latest ``tool_search`` one marked ``estimated``:
both the core deferral and the native deferral hook book that way, and a
hook's own measured saving never is, so it is never the one debited.
The ledger entry is the ``tool_search`` row marked ``estimated``: both the
core deferral and the native deferral hook book that way (rows coalesce, so
they share it), and a hook's own measured saving never is, so it is never
the one debited.
"""
if not isinstance(tags, dict) or "tool_search_deferred_tokens" not in tags:
return None
+91 -7
View File
@@ -21,10 +21,12 @@ the same deprecation policy.
from __future__ import annotations
import inspect
import logging
from collections.abc import Awaitable, Callable
from collections.abc import Awaitable, Callable, Mapping
from dataclasses import dataclass, field
from typing import Any, Protocol, runtime_checkable
from types import MappingProxyType
from typing import Any, Literal, Protocol, runtime_checkable
from headroom.proxy.tool_schema_savings_policy import (
deferred_booking,
@@ -90,10 +92,31 @@ class TurnContext:
)
@dataclass(frozen=True)
class ResponsesCreate:
"""One OpenAI Responses create request, before the proxy rewrites it.
``body`` is a read-only view of the Responses payload (for a WebSocket
``response.create`` frame, the inner ``response`` object). ``headers``
are the client's request headers, or the WebSocket handshake headers,
looked up by lowercase name. ``connection_id`` names the WebSocket
connection the frame arrived on (``None`` over HTTP): a
``previous_response_id`` chain lives within one connection, so it is the
key for anything a hook must hold across a chain's frames. A reconnect
gets a new id; Codex's first frame on it replays the full transcript
rather than continuing the old chain, so it arrives as a fresh request.
"""
body: Mapping[str, Any]
headers: Mapping[str, str]
transport: Literal["http", "websocket"]
connection_id: str | None = None
@runtime_checkable
class TurnHook(Protocol):
"""A registered turn observer. Both methods are optional (a hook may define
either); missing methods are simply skipped."""
"""A registered turn observer. Every method is optional (a hook may define
any of them); missing methods are simply skipped."""
name: str
@@ -104,9 +127,10 @@ class TurnHook(Protocol):
stream_safe: bool
# Optional: run order among registered hooks, lowest first (stable for
# ties; absent ⇒ DEFAULT_HOOK_PRIORITY). Convention: routers that change
# ``ctx.model`` 10-49, message folds 50-99, tool-catalog shaping that is
# gated on the final model (deferral) 200+. Registration order is
# ties; absent ⇒ DEFAULT_HOOK_PRIORITY). Convention: routers 10-49 (an
# OpenAI Responses router rewrites the model in ``on_responses_create``,
# which runs before every ``on_request``), message folds 50-99,
# tool-catalog shaping that is gated on the final model (deferral) 200+. Registration order is
# entry-point discovery order, which an operator does not control, so a
# hook whose correctness depends on running after another must say so.
priority: int
@@ -122,6 +146,26 @@ class TurnHook(Protocol):
May ``await call_model(messages)`` to re-drive the model (e.g. to resolve
an injected tool call), looping as needed before returning the final."""
async def on_responses_create(self, request: ResponsesCreate) -> dict[str, Any] | None:
"""Return a replacement body for an OpenAI Responses create request,
or ``None`` to leave it unchanged.
Called once per HTTP ``/v1/responses`` body and once per WebSocket
``response.create`` frame, on the event loop, before compression and
every model-gated stage (not when the client sent the Headroom bypass
header). This is where a router changes the model or reasoning effort:
unlike ``on_request`` it runs whether or not compression is enabled.
Everything after it -- memory, compression, tool-search deferral,
token counting, pricing, metrics, the WS continuation template -- sees
the replacement; the next hook gets it as its ``request.body``. The
view is read-only at the top level and nested values are shared with
the live request, so build replacements (``{**body, "reasoning":
{...}}``) rather than mutating nested dicts or lists. A hook that
raises then leaves nothing half-applied, and a request no hook
replaced keeps the client's original bytes. Keep it fast: it is awaited inline on every frame, so
no network I/O."""
_hooks: list[TurnHook] = []
@@ -301,3 +345,43 @@ async def run_response_hooks(
if replacement is not None:
current = replacement
return current
async def run_responses_create_hooks(
body: dict[str, Any],
*,
headers: Mapping[str, str],
transport: Literal["http", "websocket"],
connection_id: str | None = None,
) -> bool:
"""Run every hook's ``on_responses_create`` and apply the final body to
``body`` in place. True if any hook replaced it.
Inert (returns False) when no hook defines the method. A failing hook is
logged and skipped. A sync method is accepted as well as a coroutine.
"""
current: dict[str, Any] = body
for hook in registered_turn_hooks():
fn = getattr(hook, "on_responses_create", None)
if fn is None:
continue
request = ResponsesCreate(
body=MappingProxyType(current),
headers=headers,
transport=transport,
connection_id=connection_id,
)
try:
result = fn(request)
if inspect.isawaitable(result):
result = await result
except Exception: # a hook must never break the proxy
log.exception("turn hook %r on_responses_create failed", getattr(hook, "name", hook))
continue
if isinstance(result, dict):
current = result
if current is body:
return False
body.clear()
body.update(current)
return True
+118 -47
View File
@@ -1,10 +1,9 @@
"""Embedding-based relevance scorer for Headroom SDK.
This module provides semantic relevance scoring using `fastembed`
(BAAI/bge-small-en-v1.5 by default — 33M params, 384 dims, ~30 MB
int8-quantized ONNX). Same library + same model used by the Rust
SmartCrusher (fastembed-rs crate) so embeddings agree byte-for-byte
across the language boundary.
(BAAI/bge-small-en-v1.5 by default — 33M params, 384 dims, ~67 MB
quantized ONNX), loaded from a pinned Qdrant/bge-small-en-v1.5-onnx-Q
snapshot in the HuggingFace hub cache.
Key features:
- Semantic understanding ("errors" matches "failed", "issues")
@@ -28,9 +27,13 @@ from __future__ import annotations
import logging
import os
from typing import TYPE_CHECKING
from collections.abc import Iterator
from contextlib import contextmanager
from pathlib import Path
from typing import TYPE_CHECKING, Any
from headroom.offline import OfflineEgressBlocked, guard_egress
from headroom.onnx_runtime import _resolve_revision, hf_hub_download_local_first
from .base import RelevanceScore, RelevanceScorer
@@ -60,7 +63,31 @@ if TYPE_CHECKING:
logger = logging.getLogger(__name__)
def _load_text_embedding(kwargs: dict[str, str]) -> TextEmbedding:
@contextmanager
def _hf_hub_forced_offline() -> Iterator[None]:
"""Force the HuggingFace stack offline for the duration of the block.
huggingface_hub reads HF_HUB_OFFLINE once, at import, into
``constants.HF_HUB_OFFLINE``; if it was imported before this call the env
var alone changes nothing. Force both, and restore both on exit.
"""
from huggingface_hub import constants as hf_constants
previous = os.environ.get("HF_HUB_OFFLINE")
previous_constant = hf_constants.HF_HUB_OFFLINE
os.environ["HF_HUB_OFFLINE"] = "1"
hf_constants.HF_HUB_OFFLINE = True
try:
yield
finally:
hf_constants.HF_HUB_OFFLINE = previous_constant
if previous is None:
os.environ.pop("HF_HUB_OFFLINE", None)
else:
os.environ["HF_HUB_OFFLINE"] = previous
def _load_text_embedding(kwargs: dict[str, Any]) -> TextEmbedding:
"""Build a fastembed ``TextEmbedding``, cache first and network second.
``onnx_runtime.hf_hub_download_local_first`` can hang the air-gap guard on
@@ -83,25 +110,12 @@ def _load_text_embedding(kwargs: dict[str, str]) -> TextEmbedding:
never sent somewhere it would not otherwise go.
"""
from fastembed import TextEmbedding
from huggingface_hub import constants as hf_constants
# huggingface_hub reads HF_HUB_OFFLINE once, at import, into
# ``constants.HF_HUB_OFFLINE``; if it was imported before this call the
# env var alone changes nothing. Force both.
previous = os.environ.get("HF_HUB_OFFLINE")
previous_constant = hf_constants.HF_HUB_OFFLINE
os.environ["HF_HUB_OFFLINE"] = "1"
hf_constants.HF_HUB_OFFLINE = True
try:
return TextEmbedding(**kwargs)
with _hf_hub_forced_offline():
return TextEmbedding(**kwargs)
except Exception as cache_miss: # noqa: BLE001 - any local-lookup failure
logger.debug("fastembed cache lookup failed, falling back to network: %s", cache_miss)
finally:
hf_constants.HF_HUB_OFFLINE = previous_constant
if previous is None:
os.environ.pop("HF_HUB_OFFLINE", None)
else:
os.environ["HF_HUB_OFFLINE"] = previous
guard_egress(
f"fastembed weight download for {kwargs['model_name']}",
@@ -113,25 +127,77 @@ def _load_text_embedding(kwargs: dict[str, str]) -> TextEmbedding:
# Default model name. Same string used by the Rust embedding scorer.
DEFAULT_MODEL_NAME = "BAAI/bge-small-en-v1.5"
# Pinned revision of fastembed's underlying HF repo for the default model
# (fastembed resolves "BAAI/bge-small-en-v1.5" -> "qdrant/bge-small-en-v1.5-onnx-q").
# fastembed's TextEmbedding signature omits ``revision`` but forwards **kwargs to
# huggingface_hub.snapshot_download, so passing it pins the download for
# supply-chain integrity. Only the default model is pinned; custom models float.
# Set HEADROOM_HF_PIN=off to bypass (mirrors headroom.onnx_runtime pinning).
_DEFAULT_MODEL_PINNED_REVISION = "52398278842ec682c6f32300af41344b1c0b0bb2"
# The HF repo fastembed resolves DEFAULT_MODEL_NAME to, and every file a
# fastembed load of it reads. Its revision is pinned in
# ``onnx_runtime._PINNED_REVISIONS`` (HEADROOM_HF_PIN=off floats it).
DEFAULT_MODEL_REPO = "Qdrant/bge-small-en-v1.5-onnx-Q"
DEFAULT_MODEL_FILES = (
"model_optimized.onnx",
"tokenizer.json",
"tokenizer_config.json",
"special_tokens_map.json",
"config.json",
)
def _pinned_revision(model_name: str) -> str | None:
"""Return the pinned HF revision for ``model_name`` (default model only).
def _resolve_default_model_snapshot() -> str:
"""Return the local directory holding the pinned default-model snapshot.
Returns ``None`` for custom models or when ``HEADROOM_HF_PIN=off``.
fastembed cannot pin this itself: ``TextEmbedding`` accepts ``revision``
but drops it before ``snapshot_download`` (fastembed 0.9.0), so passing it
left the download floating on the repo's ``main``. Each file is resolved
here through ``hf_hub_download_local_first`` instead, which applies the
pinned SHA, tries the cache first and guards the network fallback.
The files land in the standard HuggingFace hub cache rather than
fastembed's default under the system temp dir, which macOS purges after a
few idle days.
Raises:
OfflineEgressBlocked: ``HEADROOM_OFFLINE`` is set and a file is not cached.
RuntimeError: the files resolved to more than one snapshot, which only
happens when ``main`` moved mid-download with pinning turned off.
"""
if os.environ.get("HEADROOM_HF_PIN", "").strip().lower() in ("off", "0", "false", "no"):
return None
if model_name == DEFAULT_MODEL_NAME:
return _DEFAULT_MODEL_PINNED_REVISION
return None
paths = [
Path(hf_hub_download_local_first(DEFAULT_MODEL_REPO, name)) for name in DEFAULT_MODEL_FILES
]
snapshot_dirs = {path.parent for path in paths}
if len(snapshot_dirs) != 1:
raise RuntimeError(
f"{DEFAULT_MODEL_REPO} files resolved to more than one snapshot: "
f"{sorted(str(d) for d in snapshot_dirs)}"
)
return str(snapshot_dirs.pop())
def _default_model_seed_hint() -> str:
"""How to pre-seed DEFAULT_MODEL_NAME on a host that cannot download it.
Names the exact snapshot the load looks up, because a fastembed cache
seeded for an older Headroom no longer satisfies it.
"""
revision = _resolve_revision(DEFAULT_MODEL_REPO, None) or "main"
return (
f"Pre-seed the HuggingFace hub cache with {DEFAULT_MODEL_REPO}@{revision} "
f"(`hf download {DEFAULT_MODEL_REPO} {' '.join(DEFAULT_MODEL_FILES)} "
f"--revision {revision}`), or use the BM25-only scorer. A fastembed cache "
"seeded for an older Headroom is not read for this model."
)
def _load_default_model() -> TextEmbedding:
"""Load DEFAULT_MODEL_NAME from its pinned snapshot, with no fastembed lookup.
Given ``specific_model_path`` fastembed loads that directory without
touching the Hub; the construction still runs with the Hub forced offline
so that a fastembed that stopped honouring it fails here instead of
downloading an unpinned copy.
"""
from fastembed import TextEmbedding
snapshot = _resolve_default_model_snapshot()
with _hf_hub_forced_offline():
return TextEmbedding(model_name=DEFAULT_MODEL_NAME, specific_model_path=snapshot)
def _cosine_similarity(a, b) -> float:
@@ -160,8 +226,8 @@ class EmbeddingScorer(RelevanceScorer):
"""Semantic relevance scorer using fastembed (ONNX-backed).
Default model: BAAI/bge-small-en-v1.5 (33M params, 384 dims).
Auto-downloads from HuggingFace Hub on first use (~30 MB
int8-quantized ONNX).
Auto-downloads its pinned snapshot from HuggingFace Hub on first
use (~67 MB quantized ONNX).
Example:
scorer = EmbeddingScorer()
@@ -223,23 +289,28 @@ class EmbeddingScorer(RelevanceScorer):
)
if self._model is None:
revision = _pinned_revision(self.model_name)
kwargs = {"model_name": self.model_name}
if revision is not None:
# fastembed forwards **kwargs to snapshot_download(revision=...).
kwargs["revision"] = revision
try:
self._model = _load_text_embedding(kwargs)
if self.model_name == DEFAULT_MODEL_NAME:
self._model = _load_default_model()
else:
# Other catalog models are not pinned: fastembed resolves
# them on the repo's main, cache first.
self._model = _load_text_embedding({"model_name": self.model_name})
except OfflineEgressBlocked as blocked:
# Translate at the boundary that owns the degradation, the way
# the Kompress and ONNX loaders do. Public model weights are
# not data leaving the box, so what the caller needs to hear
# is "this model is not available here and why", not an
# air-gap type it has never seen.
if self.model_name == DEFAULT_MODEL_NAME:
seed_hint = _default_model_seed_hint()
else:
seed_hint = (
"Pre-seed the fastembed cache on this host, or use the BM25-only scorer."
)
raise RuntimeError(
f"Embedding model {self.model_name!r} is unavailable: {blocked}. "
"Pre-seed the fastembed/HuggingFace cache on this host, or "
"use the BM25-only scorer."
f"Embedding model {self.model_name!r} is unavailable: "
f"{str(blocked).rstrip('.')}. {seed_hint}"
) from None
return self._model
+25
View File
@@ -153,6 +153,31 @@ class ReadMaturationManager:
# once per session (content and marker are stable per tool call).
self._replay_token_deltas: dict[str, int] = {}
def export_state(self) -> dict[str, Any]:
"""Session state as JSON, for ``SessionTrackerStore.save_state``."""
return {
"matured": {k: [m.marker, m.ccr_hash] for k, m in self._matured.items()},
"booked": sorted(self._booked),
"deltas": self._replay_token_deltas,
}
@staticmethod
def validate_state(state: Any) -> dict[str, Any]:
"""Normalize :meth:`export_state` output read from disk. Raises on a bad
shape, so a bad file is rejected at load and never inside a request."""
return {
"matured": {str(k): [str(m), str(h)] for k, (m, h) in state["matured"].items()},
"booked": [str(k) for k in state["booked"]],
"deltas": {str(k): int(v) for k, v in state["deltas"].items()},
}
def restore_state(self, state: dict[str, Any]) -> None:
"""Adopt :meth:`validate_state` output from the previous process, so a
matured Read's removal is not booked again after a restart."""
self._matured = {k: MaturedRead(m, h) for k, (m, h) in state["matured"].items()}
self._booked = set(state["booked"])
self._replay_token_deltas = dict(state["deltas"])
# ─── Per-request entry point ────────────────────────────────────────
def apply(
+7 -6
View File
@@ -172,13 +172,13 @@ pytorch-mps = [
]
# Semantic relevance scoring with embeddings.
# Uses `fastembed` (BAAI/bge-small-en-v1.5 by default — 33M params,
# 384 dims, ~30 MB int8-quantized ONNX). Same library + model used by
# the Rust SmartCrusher (`fastembed` crate), giving byte-equal embeddings
# across the language boundary. Replaced sentence-transformers in
# 384 dims, ~67 MB quantized ONNX), loaded from a pinned
# Qdrant/bge-small-en-v1.5-onnx-Q snapshot. Replaced sentence-transformers in
# Stage 3c.1 — fastembed is faster (~2-3x), smaller (no torch
# dependency), and outranks all-MiniLM-L6-v2 on MTEB by ~6 points.
# >=0.6.0 for `specific_model_path`, which the pinned-snapshot load needs.
relevance = [
"fastembed>=0.4.0; python_version<'3.14' or sys_platform != 'darwin' or platform_machine != 'x86_64'",
"fastembed>=0.6.0; python_version<'3.14' or sys_platform != 'darwin' or platform_machine != 'x86_64'",
"numpy>=1.24.0",
]
# Image compression (ML-based routing + OCR)
@@ -410,8 +410,9 @@ constraint-dependencies = [
"transformers>=5.5.0",
# PYSEC-2026-3447 — transitive dependency; fix at 83.0.0
"setuptools>=83.0.0",
# PYSEC-2026-3545/3546/3547 — transitive HTTP/WebSocket parser fixes
"aiohttp>=3.14.3",
# PYSEC-2026-3545/3546/3547 — transitive HTTP/WebSocket parser fixes;
# CVE-2026-111063/111064, GHSA-2g87-pp6c-29x5; fix at 3.14.4
"aiohttp>=3.14.4",
# PYSEC-2026-3552/3553/3554 — PKCS#7 and certificate verification fixes
"cryptography>=50.0.0",
]
+9 -3
View File
@@ -156,8 +156,13 @@ class _PromptCache:
return read, write, hit
def _drive(requests: list[list[dict[str, Any]]]) -> list[tuple[list[dict[str, Any]], int]]:
"""Send each history through the real handler; return (forwarded, read_hit)."""
def _drive(
requests: list[list[dict[str, Any]]], cache: _PromptCache | None = None, **config: Any
) -> list[tuple[list[dict[str, Any]], int]]:
"""Send each history through the real handler; return (forwarded, read_hit).
One app per call: a second call with the same ``cache`` is a proxy restart
in front of a provider whose prompt cache stayed warm."""
app = create_app(
ProxyConfig(
optimize=True,
@@ -168,9 +173,10 @@ def _drive(requests: list[list[dict[str, Any]]]) -> list[tuple[list[dict[str, An
rate_limit_enabled=False,
cost_tracking_enabled=False,
log_requests=False,
**config,
)
)
cache = _PromptCache()
cache = cache or _PromptCache()
seen: list[tuple[list[dict[str, Any]], int]] = []
with TestClient(app) as client:
proxy = client.app.state.proxy
+3 -2
View File
@@ -17,11 +17,12 @@ def test_wrap_help_lists_antigravity() -> None:
assert "antigravity" in result.output
def test_wrap_antigravity_help_mentions_custom_model_provider() -> None:
def test_wrap_antigravity_help_says_ide_has_no_third_party_providers() -> None:
result = CliRunner().invoke(main, ["wrap", "antigravity", "--help"])
assert result.exit_code == 0, result.output
assert "Antigravity" in result.output
assert "OpenAI-compatible" in result.output
assert "does not support third-party model providers" in result.output
assert "custom OpenAI-compatible model provider" not in result.output
def test_wrap_antigravity_prepare_only_exits_cleanly() -> None:
+20
View File
@@ -578,3 +578,23 @@ def test_token_source_and_dollar_source_coexist(tmp_path, monkeypatch):
def test_no_section_when_nothing_attributed(tmp_path, monkeypatch):
out = _report_for([_savings_perf_line("none")], tmp_path, monkeypatch)
assert "Savings by Source" not in out
def test_coalesced_savings_rows_count_every_event_in_text_and_summary():
"""A PERF row summed from 3 recordings is 3 events; a row without the field is 1."""
report = PerfReport(
perf_records=[
PerfRecord(
timestamp="2026-06-05 10:00:00,000",
request_id="hr_1",
savings_breakdown=[
{"source": "tool_search", "tokens": 300, "events": 3},
{"source": "router", "tokens": 5},
],
)
]
)
by_source = {row["source"]: row["events"] for row in build_perf_summary(report)["by_source"]}
assert by_source == {"tool_search": 3, "router": 1}
assert "tool_search: 3 events" in analyzer.format_report(report)
+44
View File
@@ -318,6 +318,50 @@ def test_extension_savings_surface_in_stats(
}
@pytest.mark.asyncio
async def test_turn_hook_savings_surface_in_stats_extension_savings(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""``ctx.record_savings`` from a turn hook must reach ``/stats.extension_savings``.
Before, only ``record_extension_savings`` filled the field and core never
calls it, so ``/stats`` showed ``{}`` while a hook saved ~8K tokens a request.
Estimated rows stay out, and a plugin reporting through both APIs (hdr) is
not counted twice.
"""
from fastapi.testclient import TestClient
from headroom.proxy.server import ProxyConfig, create_app
monkeypatch.setenv("HEADROOM_SAVINGS_PATH", str(tmp_path / "proxy_savings.json"))
app = create_app(ProxyConfig(cache_enabled=False, rate_limit_enabled=False, log_requests=False))
with TestClient(app) as client:
metrics = app.state.proxy.metrics
for _ in range(2):
await metrics.record_request(
provider="openai",
model="gpt-5.4",
input_tokens=1000,
output_tokens=10,
tokens_saved=0,
latency_ms=1.0,
savings_attribution=[
{"source": "tool_search", "realized": True, "tokens": 8000},
{"source": "tool_search", "realized": False, "estimated": True, "tokens": 500},
{"source": "hdr", "realized": True, "tokens": 300},
],
)
metrics.record_extension_savings("hdr", 300)
stats = client.get("/stats").json()
assert stats["extension_savings"] == {"tool_search": 16000, "hdr": 600}
by_source = {
(row["source"], row["realized"]): row["tokens"] for row in stats["savings"]["by_source"]
}
assert by_source[("tool_search", False)] == 1000
def test_prometheus_metrics_accumulates_codex_ws_unit_and_frame_counters():
from headroom.proxy.prometheus_metrics import PrometheusMetrics
+154
View File
@@ -396,3 +396,157 @@ async def test_extension_savings_reach_the_metrics_call() -> None:
attribution = h.metrics.record_request.await_args.kwargs["savings_attribution"]
assert [(row["source"], row["usd"]) for row in attribution] == [("routemegood", 0.42)]
# --- no row cap: every recording is booked -------------------------------------
@pytest.mark.asyncio
async def test_a_request_with_40_sources_books_every_token() -> None:
"""The ledger used to stop at 32 rows and drop the 33rd recording on."""
from headroom.proxy.prometheus_metrics import PrometheusMetrics
from headroom.proxy.savings_attribution import record_savings
tags: dict = {}
for i in range(40):
record_savings(tags, f"plugin{i}", tokens=100, usd=0.01)
record_savings(tags, "plugin0", tokens=100, usd=0.01)
rows = from_tags(tags)
metrics = PrometheusMetrics()
await metrics.record_request(
provider="openai",
model="gpt-5.4",
input_tokens=10,
output_tokens=1,
tokens_saved=0,
latency_ms=1.0,
savings_attribution=rows,
)
assert len(rows) == 40
booked = metrics.savings_by_source.values()
assert sum(int(row["tokens"]) for row in booked) == 4_100
assert sum(int(row["events"]) for row in booked) == 41
assert metrics.savings_by_source["plugin0:1"]["events"] == 2
def test_rows_coalesce_per_source_realized_and_estimated() -> None:
from headroom.proxy.savings_attribution import record_savings
tags: dict = {}
for _ in range(3):
record_savings(tags, "router", tokens=1, realized=True)
record_savings(tags, "router", tokens=1, realized=False)
record_savings(tags, "router", tokens=1, estimated=True)
rows = from_tags(tags)
assert [(r["realized"], r["estimated"], r["tokens"], r["events"]) for r in rows] == [
(True, False, 3, 3),
(False, False, 3, 3),
(True, True, 3, 3),
]
def test_merging_into_a_junk_row_does_not_raise_inside_the_handler() -> None:
from headroom.proxy.savings_attribution import record_savings
tags: dict = {SAVINGS_ATTRIBUTION_TAG: [{"source": "x", "tokens": None, "usd": "junk"}]}
record_savings(tags, "x", tokens=5, usd=0.5)
assert [(r["tokens"], r["usd"], r["events"]) for r in from_tags(tags)] == [(5, 0.5, 2)]
def test_distinct_sources_past_the_bound_fold_into_other_and_conserve_totals() -> None:
"""Source names are plugin-supplied; their count must not grow the ledger."""
from headroom.proxy.savings_attribution import MAX_NAMED_ROWS, record_savings
tags: dict = {}
for i in range(2_000):
record_savings(tags, f"extension_{i}", tokens=100, usd=0.01)
record_savings(tags, f"extension_{i}", tokens=1, estimated=True)
record_savings(tags, "extension_0", tokens=100, usd=0.01) # a named row still merges
rows = from_tags(tags)
assert len(rows) == MAX_NAMED_ROWS + 2 # plus one ``other`` row per estimated flag
assert sum(r["tokens"] for r in rows) == 2_000 * 101 + 100
assert sum(r["events"] for r in rows) == 4_001
assert math.isclose(sum(r["usd"] for r in rows), 2_001 * 0.01)
named = {(r["source"], r["estimated"]): r for r in rows}
assert named[("extension_0", False)]["events"] == 2
assert {(r["source"], r["estimated"]) for r in rows if r["source"] == "other"} == {
("other", False),
("other", True),
}
@pytest.mark.asyncio
async def test_same_source_usd_saturates_instead_of_overflowing() -> None:
"""Two finite amounts must not sum to ``inf`` on the way to the metrics."""
import json
from headroom.proxy.prometheus_metrics import PrometheusMetrics
from headroom.proxy.savings_attribution import MAX_ROW_USD, record_savings
tags: dict = {}
record_savings(tags, "same", tokens=1, usd=1e308)
record_savings(tags, "same", tokens=1, usd=1e308)
record_savings(tags, "same", tokens=1, usd=1.0) # must not reset the total
rows = from_tags(tags)
assert [(r["tokens"], r["events"], r["usd"], r["saturated"]) for r in rows] == [
(3, 3, MAX_ROW_USD, True)
]
metrics = PrometheusMetrics()
await metrics.record_request(
provider="openai",
model="gpt-5.4",
input_tokens=10,
output_tokens=1,
tokens_saved=0,
latency_ms=1.0,
savings_attribution=rows,
)
booked = metrics.savings_by_source["same:1"]["usd"]
assert math.isfinite(booked)
json.dumps(metrics.savings_by_source, allow_nan=False) # what /stats does
@pytest.mark.parametrize("then_usd", [1.0, -1.0])
def test_an_infinite_total_already_in_the_ledger_stays_saturated(then_usd) -> None:
from headroom.proxy.savings_attribution import MAX_ROW_USD, record_savings
tags: dict = {SAVINGS_ATTRIBUTION_TAG: [{"source": "x", "usd": math.inf}]}
record_savings(tags, "x", usd=then_usd)
[row] = from_tags(tags)
assert row["saturated"] is True
assert row["usd"] >= MAX_ROW_USD - 1.0
def test_tokens_stay_within_zero_and_the_bound() -> None:
from headroom.proxy.savings_attribution import MAX_ROW_TOKENS, accumulate
rows: list = [{"source": "x", "tokens": -(10**400)}, {"source": "y", "tokens": 10**400}]
accumulate(rows, [{"source": "x", "tokens": 5}, {"source": "y", "tokens": 5}])
assert [(r["tokens"], r["saturated"]) for r in rows] == [(5, True), (MAX_ROW_TOKENS, True)]
def test_tool_search_keeps_its_own_row_past_the_bound() -> None:
"""Deferral reconcile finds the ``tool_search`` row by name to lower it."""
from headroom.proxy.savings_attribution import MAX_NAMED_ROWS, record_savings
tags: dict = {}
for i in range(MAX_NAMED_ROWS):
record_savings(tags, f"extension_{i}", tokens=1)
record_savings(tags, "tool_search", tokens=900, realized=False, estimated=True)
assert [r["tokens"] for r in from_tags(tags) if r["source"] == "tool_search"] == [900]
def test_max_sources_is_deprecated_not_removed() -> None:
from headroom.proxy import savings_attribution
with pytest.warns(DeprecationWarning, match="MAX_SOURCES"):
assert savings_attribution.MAX_SOURCES == 32
+173
View File
@@ -0,0 +1,173 @@
"""The default relevance embedder loads one pinned snapshot.
fastembed's ``TextEmbedding`` accepts ``revision`` but drops it before
``snapshot_download``, so the old pin never reached the Hub and the model
floated on ``main``. These tests hold the replacement in place: the pinned
SHA reaches every file download and fastembed only gets the resolved
directory.
"""
from __future__ import annotations
import os
import sys
from pathlib import Path
from types import SimpleNamespace
import pytest
from headroom.offline import OFFLINE_ENV
from headroom.onnx_runtime import _PINNED_REVISIONS
from headroom.relevance import embedding
from headroom.relevance.embedding import (
DEFAULT_MODEL_FILES,
DEFAULT_MODEL_NAME,
DEFAULT_MODEL_REPO,
EmbeddingScorer,
)
PIN = _PINNED_REVISIONS[DEFAULT_MODEL_REPO]
@pytest.fixture
def fake_hub(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> list[dict[str, object]]:
"""Stand in for ``huggingface_hub.hf_hub_download``: record each call and
return the path the real cache layout would give for that revision."""
import huggingface_hub
calls: list[dict[str, object]] = []
def _download(repo_id: str, filename: str, **kwargs: object) -> str:
calls.append({"repo_id": repo_id, "filename": filename, **kwargs})
commit = kwargs.get("revision") or "main-commit"
return str(tmp_path / "snapshots" / str(commit) / filename)
monkeypatch.setattr(huggingface_hub, "hf_hub_download", _download)
monkeypatch.delenv("HEADROOM_HF_PIN", raising=False)
return calls
@pytest.fixture
def fake_fastembed(monkeypatch: pytest.MonkeyPatch) -> list[dict[str, object]]:
"""Install a stub fastembed whose constructor records its kwargs."""
constructed: list[dict[str, object]] = []
class _TextEmbedding:
def __init__(self, **kwargs: object) -> None:
constructed.append(kwargs)
monkeypatch.setitem(sys.modules, "fastembed", SimpleNamespace(TextEmbedding=_TextEmbedding))
return constructed
def test_every_file_is_downloaded_at_the_pinned_revision(fake_hub, fake_fastembed, tmp_path):
EmbeddingScorer()._get_model()
assert {c["filename"] for c in fake_hub} == set(DEFAULT_MODEL_FILES)
assert {c["repo_id"] for c in fake_hub} == {DEFAULT_MODEL_REPO}
assert {c["revision"] for c in fake_hub} == {PIN}
def test_fastembed_gets_the_snapshot_directory_not_a_revision(fake_hub, fake_fastembed, tmp_path):
EmbeddingScorer()._get_model()
assert fake_fastembed == [
{
"model_name": DEFAULT_MODEL_NAME,
"specific_model_path": str(tmp_path / "snapshots" / PIN),
}
]
def test_fastembed_is_constructed_with_the_hub_forced_offline(fake_hub, monkeypatch):
"""If fastembed ever stopped honouring ``specific_model_path`` it would
try the Hub; forcing it offline makes that a load failure, not an
unpinned download."""
from huggingface_hub import constants as hf_constants
seen: list[tuple[str | None, bool]] = []
class _TextEmbedding:
def __init__(self, **kwargs: object) -> None:
seen.append((os.environ.get("HF_HUB_OFFLINE"), hf_constants.HF_HUB_OFFLINE))
monkeypatch.setitem(sys.modules, "fastembed", SimpleNamespace(TextEmbedding=_TextEmbedding))
monkeypatch.setenv("HF_HUB_OFFLINE", "0")
monkeypatch.setattr(hf_constants, "HF_HUB_OFFLINE", False)
EmbeddingScorer()._get_model()
assert seen == [("1", True)]
assert os.environ["HF_HUB_OFFLINE"] == "0"
assert hf_constants.HF_HUB_OFFLINE is False
def test_pin_off_floats_on_main(fake_hub, fake_fastembed, monkeypatch):
monkeypatch.setenv("HEADROOM_HF_PIN", "off")
EmbeddingScorer()._get_model()
assert {c["revision"] for c in fake_hub} == {None}
def test_files_from_two_snapshots_are_refused(monkeypatch, fake_fastembed, tmp_path):
import huggingface_hub
def _download(repo_id: str, filename: str, **kwargs: object) -> str:
commit = "a" if filename == DEFAULT_MODEL_FILES[0] else "b"
return str(tmp_path / commit / filename)
monkeypatch.setattr(huggingface_hub, "hf_hub_download", _download)
with pytest.raises(RuntimeError, match="more than one snapshot"):
EmbeddingScorer()._get_model()
assert fake_fastembed == []
def test_a_cold_cache_offline_degrades_without_a_download(monkeypatch, fake_fastembed):
import huggingface_hub
from huggingface_hub.errors import LocalEntryNotFoundError
def _download(repo_id: str, filename: str, **kwargs: object) -> str:
if not kwargs.get("local_files_only"):
raise AssertionError("the network fallback ran while offline")
raise LocalEntryNotFoundError("not cached")
monkeypatch.setattr(huggingface_hub, "hf_hub_download", _download)
monkeypatch.setenv(OFFLINE_ENV, "1")
with pytest.raises(RuntimeError, match="is unavailable") as excinfo:
EmbeddingScorer()._get_model()
assert fake_fastembed == []
# The hint names the exact snapshot to seed, not the fastembed cache an
# older Headroom read.
assert f"{DEFAULT_MODEL_REPO}@{PIN}" in str(excinfo.value)
assert f"--revision {PIN}" in str(excinfo.value)
def test_other_models_keep_fastembed_resolution(monkeypatch, fake_hub):
seen: list[dict[str, str]] = []
monkeypatch.setattr(embedding, "_load_text_embedding", lambda kwargs: seen.append(kwargs))
monkeypatch.setitem(sys.modules, "fastembed", SimpleNamespace())
EmbeddingScorer("intfloat/e5-small-v2")._get_model()
assert seen == [{"model_name": "intfloat/e5-small-v2"}]
assert fake_hub == []
def test_fastembed_loads_specific_model_path_without_a_download(monkeypatch, tmp_path):
"""The contract the fix rests on, against the real fastembed: given
``specific_model_path`` it uses that directory and never reaches the Hub."""
pytest.importorskip("fastembed")
import fastembed.common.model_management as model_management
from fastembed import TextEmbedding
def _no_hub(*args: object, **kwargs: object) -> None:
raise AssertionError("fastembed reached the Hub despite specific_model_path")
monkeypatch.setattr(model_management, "snapshot_download", _no_hub)
model = TextEmbedding(
model_name=DEFAULT_MODEL_NAME,
specific_model_path=str(tmp_path),
cache_dir=str(tmp_path / "unused-cache"),
lazy_load=True,
)
assert Path(model.model._model_dir) == tmp_path
+13 -2
View File
@@ -475,11 +475,22 @@ class TestSessionAnalyzer:
assert result.recommendations == []
assert result.analysis_error == "API key not set"
@pytest.mark.parametrize(
"error",
[
"`claude -p` failed (exit 1):\nPrompt is too long",
# What codex exec printed on a real learn run: it refuses a prompt over 2**20 chars.
"`codex exec` failed (exit 1):\nError: turn/start: turn/start failed: Input exceeds "
"the maximum length of 1048576 characters. (code -32602), data: "
'{"input_error_code":"input_too_large","max_chars":1048576,"actual_chars":1786526}',
],
ids=["claude", "codex"],
)
@patch("headroom.learn.analyzer._call_llm")
def test_retries_smaller_digest_on_prompt_too_long(self, mock_call_llm: MagicMock):
def test_retries_smaller_digest_on_prompt_too_long(self, mock_call_llm: MagicMock, error):
"""A context-overflow error rebuilds the digest at half the budget and retries."""
mock_call_llm.side_effect = [
RuntimeError("`claude -p` failed (exit 1):\nPrompt is too long"),
RuntimeError(error),
{"context_file_rules": [], "memory_file_rules": []},
]
+115
View File
@@ -26,6 +26,7 @@ from headroom.learn.fixtures import (
)
from headroom.learn.loops import (
_IDENTITY_FIELDS,
LoopPattern,
_canonical_signature,
_identity_input,
_signature_tokens,
@@ -37,6 +38,7 @@ from headroom.learn.models import (
Recommendation,
RecommendationTarget,
SessionData,
SessionEvent,
ToolCall,
)
@@ -150,6 +152,119 @@ class TestDigestSurfacesLoops:
digest = _build_digest(_project(), [one_off_error_session()])
assert "Detected Loops" not in digest
@pytest.mark.parametrize("max_tokens", [80_000, 10_000])
@pytest.mark.parametrize(
("tool", "sample"),
[
("Bash", "x" * 120),
("Grep", "x" * 2000), # a long search pattern
("Glob", "src/" * 500 + "*.py"), # a long path
],
ids=["bash", "long-grep-pattern", "long-glob-path"],
)
def test_loop_section_stays_inside_the_digest_budget(self, tool, sample, max_tokens):
# Rendered whole, thousands of loops with hundreds of indices each made
# a 1.79M-char prompt, over Codex's 1,048,576-char input cap.
loops = [
LoopPattern(tool, "s", sample, 300, False, 1_000_000 - i, list(range(300)))
for i in range(2000)
]
digest = _build_digest(_project(), [], loops=loops, max_tokens=max_tokens)
section = digest[digest.index("=== Detected Loops") :]
assert len(section) <= max_tokens # a quarter of the budget's chars
# The costliest loops are the ones kept, and the caller's list is intact.
assert "~1,000,000 tokens wasted" in section
assert "~999,000 tokens wasted" not in section
assert loops[0].sample_input == sample
assert len(loops[0].msg_indices) == 300
@pytest.mark.parametrize("max_tokens", [80_000, 10_000])
def test_loops_fit_beside_a_large_prior_patterns_section(self, tmp_path, max_tokens):
# The event stream cannot trim sections placed ahead of it, so the
# loops give way to the prior patterns, which are never cut.
bullets = "".join(f"- rule {i:06d} {'y' * 80}\n" for i in range(max_tokens * 4 // 100))
claude_md = tmp_path / "CLAUDE.md"
claude_md.write_text(
f"<!-- headroom:learn:start -->\n{bullets}<!-- headroom:learn:end -->\n"
)
project = ProjectInfo(
name="proj",
project_path=tmp_path,
data_path=tmp_path / "data",
context_file=claude_md,
)
loops = [
LoopPattern("Grep", "s", "x" * 2000, 300, False, 1_000_000 - i, list(range(300)))
for i in range(25)
]
digest = _build_digest(project, [], loops=loops, max_tokens=max_tokens)
assert bullets.splitlines()[-1] in digest
assert "~1,000,000 tokens wasted" in digest
assert len(digest) <= max_tokens * 4
@pytest.mark.parametrize("with_loops", [False, True], ids=["no-loops", "loops"])
@pytest.mark.parametrize("with_events", [False, True], ids=["tool-calls", "events"])
@pytest.mark.parametrize("max_tokens", [80_000, 10_000])
def test_whole_digest_stays_inside_the_budget(self, max_tokens, with_events, with_loops):
# Far more session text than the budget: every line and its newline
# counts, and none goes in that would leave no room for the markers.
sessions = []
for s in range(5):
calls = [
ToolCall(
name="Bash",
tool_call_id=f"{s}-{i}",
input_data={"command": f"run {i}"},
output="e" * 300,
is_error=True,
msg_index=i,
)
for i in range(3000)
]
events = (
[SessionEvent(type="tool_call", msg_index=c.msg_index, tool_call=c) for c in calls]
if with_events
else []
)
sessions.append(SessionData(session_id=f"s{s}", tool_calls=calls, events=events))
loops = (
[
LoopPattern("Grep", "s", "x" * 2000, 300, False, 1_000_000 - i, list(range(300)))
for i in range(2000)
]
if with_loops
else []
)
digest = _build_digest(_project(), sessions, loops=loops, max_tokens=max_tokens)
assert len(digest) <= max_tokens * 4
assert "remaining" in digest and "sessions truncated" in digest
@pytest.mark.parametrize("with_events", [False, True], ids=["tool-calls", "events"])
@pytest.mark.parametrize("max_tokens", [80_000, 10_000])
def test_many_tiny_sessions_stay_inside_the_budget(self, max_tokens, with_events):
# Thousands of kept sessions, each closed by a blank line whose newline
# counts too; the marker reserve alone would absorb only ~100 of them.
sessions = []
for s in range(20_000):
call = ToolCall(
name="Bash",
tool_call_id=str(s),
input_data={"command": "ls"},
output="ok",
is_error=False,
msg_index=0,
)
events = [SessionEvent(type="tool_call", msg_index=0, tool_call=call)]
sessions.append(
SessionData(
session_id=f"s{s}", tool_calls=[call], events=events if with_events else []
)
)
digest = _build_digest(_project(), sessions, loops=[], max_tokens=max_tokens)
assert len(digest) <= max_tokens * 4
assert digest.count("=== Session ") > 500
assert "sessions truncated" in digest
# =============================================================================
# apply_loop_weighting
+17
View File
@@ -262,6 +262,23 @@ def test_request_attribute_provider_enriches_core_and_savings_metrics() -> None:
unregister_otel_metric_attribute_provider(identity_attributes)
def test_coalesced_savings_rows_count_every_event() -> None:
"""A row summed from 33 recordings is 33 events, not 1; a bare row is 1."""
reader = InMemoryMetricReader()
otel_metrics = HeadroomOtelMetrics(meter_provider=MeterProvider(metric_readers=[reader]))
otel_metrics.record_savings_attribution(
[
{"source": "tool_search", "tokens": 3_300, "events": 33},
{"source": "router", "tokens": 5},
]
)
events = _collect_metrics(reader)["headroom.savings.attribution.events"]
assert _find_point(events, source="tool_search").value == 33
assert _find_point(events, source="router").value == 1
def test_failing_request_attribute_provider_is_fail_open() -> None:
reader = InMemoryMetricReader()
provider = MeterProvider(metric_readers=[reader])
+6 -2
View File
@@ -2351,13 +2351,17 @@ _EGRESS_ALLOWLIST: dict[str, tuple[int, str]] = {
"calls guard_egress first.",
),
"relevance/embedding.py": (
1,
2,
"cache-only: the first of the two fastembed loads in "
"_load_text_embedding runs with HF_HUB_OFFLINE forced to 1, so "
"huggingface_hub resolves from the local cache or raises without "
"opening a socket. The network retry directly below it calls "
"guard_egress, which is why a pre-seeded air-gapped host still loads "
"the model and a cold one refuses instead of dialling.",
"the model and a cold one refuses instead of dialling. The load in "
"_load_default_model runs under the same forced HF_HUB_OFFLINE and "
"passes specific_model_path, which fastembed loads without any Hub "
"lookup; its files come through hf_hub_download_local_first, guarded "
"on the miss.",
),
}
+195
View File
@@ -11,6 +11,7 @@ import asyncio
import contextlib
import json
import logging
import math
import sys
from pathlib import Path
from types import SimpleNamespace
@@ -2372,3 +2373,197 @@ async def test_ws_session_metrics_track_model_per_response_create():
"model-a",
"model-b",
]
@pytest.mark.asyncio
@pytest.mark.parametrize(
("usage", "expected"),
[({"input_tokens": 10, "output_tokens": 1}, [("ws_fold", True)]), (None, [])],
ids=["billed", "usage_less"],
)
async def test_ws_turn_hook_savings_reach_the_turn_outcome(usage, expected):
"""A turn hook's savings on a Codex WS turn must reach that turn's outcome.
The WS path compressed without ``savings_tags``, so ``ctx.record_savings``
wrote into a throwaway dict and ``/stats`` never saw the attribution. A turn
with no input usage books nothing, the same gate as its headline savings.
"""
from headroom.proxy.savings_attribution import from_tags
from headroom.proxy.turn_hooks import clear_turn_hooks, register_turn_hook
class _DropOldInput:
name = "drop_old_input"
savings_source = "ws_fold"
stream_safe = True
def on_request(self, ctx: SimpleNamespace) -> None:
del ctx.messages[:-1]
first = json.dumps(
{
"type": "response.create",
"response": {
"model": "gpt-5.4",
"input": [
{"type": "message", "role": "user", "content": "old " * 50},
{"type": "message", "role": "user", "content": "new"},
],
},
}
)
upstream = _FakeUpstream(
[
json.dumps({"type": "response.created", "response": {"id": "r_1"}}),
json.dumps(
{
"type": "response.completed",
"response": {"id": "r_1", **({"usage": usage} if usage else {})},
}
),
]
)
client_ws = _FakeWebSocket(frames=[first])
handler = _DummyOpenAIHandler()
handler.config.optimize = True
outcomes = []
async def _record_request_outcome(outcome):
outcomes.append(outcome)
handler._record_request_outcome = _record_request_outcome
clear_turn_hooks()
register_turn_hook(_DropOldInput())
try:
with patch.dict(sys.modules, {"websockets": _make_fake_websockets_module(upstream)}):
await handler.handle_openai_responses_ws(client_ws)
finally:
clear_turn_hooks()
sent = json.loads(upstream.sent[0])["response"]["input"]
assert [item["content"] for item in sent] == ["new"] # the hook really ran
rows = [row for outcome in outcomes for row in from_tags(outcome.tags)]
assert [(row["source"], row["realized"]) for row in rows] == expected
assert all(row["tokens"] > 0 for row in rows)
class _UpstreamAfterSends(_FakeUpstream):
"""Streams its events only once ``sends`` frames reached it, so every frame's
savings are pending before the one usage-carrying outcome claims them."""
def __init__(self, events: list[str], *, sends: int) -> None:
super().__init__(events)
self._sends = sends
async def _iter(self):
while len(self.sent) < self._sends:
await asyncio.sleep(0)
for ev in self._events:
yield ev
@pytest.mark.asyncio
@pytest.mark.parametrize(
("sources_per_frame", "frames_n", "expected_rows", "overflowed"),
[
(lambda i: "tool_search", 33, 2, False),
(lambda i: f"src{i}", 33, 34, False),
# ws_fold + 255 named sources fill MAX_NAMED_ROWS; the other 45 share one row.
(lambda i: f"src{i}", 300, 257, True),
],
ids=["repeated_source", "distinct_sources", "distinct_sources_past_the_bound"],
)
async def test_ws_pending_savings_beyond_32_rows_are_all_booked(
sources_per_frame, frames_n, expected_rows, overflowed
):
"""Pending frames hand every token and every event to the billed turn.
Rows coalesce to one per (source, realized, estimated) key; distinct
sources past ``MAX_NAMED_ROWS`` fold into ``other`` rather than growing
the session's pending list without bound.
"""
from headroom.proxy.prometheus_metrics import PrometheusMetrics
from headroom.proxy.savings_attribution import SAVINGS_ATTRIBUTION_TAG, from_tags
from headroom.proxy.turn_hooks import clear_turn_hooks, register_turn_hook
seen = {"frame": 0}
class _DeferTools:
name = "defer_tools"
savings_source = "ws_fold"
stream_safe = True
def on_request(self, ctx: SimpleNamespace) -> None:
del ctx.messages[:-1]
ctx.record_savings(sources_per_frame(seen["frame"]), tokens=100, usd=0.01)
seen["frame"] += 1
def _frame(i: int) -> str:
return json.dumps(
{
"type": "response.create",
"response": {
"model": "gpt-5.4",
"input": [
{"type": "message", "role": "user", "content": f"old {i} " * 50},
{"type": "message", "role": "user", "content": f"new {i}"},
],
},
}
)
upstream = _UpstreamAfterSends(
[
json.dumps({"type": "response.created", "response": {"id": "r_1"}}),
json.dumps(
{
"type": "response.completed",
"response": {
"id": "r_1",
"usage": {"input_tokens": 10, "output_tokens": 1},
},
}
),
],
sends=frames_n,
)
client_ws = _FakeWebSocket(frames=[_frame(i) for i in range(frames_n)])
handler = _DummyOpenAIHandler()
handler.config.optimize = True
outcomes = []
async def _record_request_outcome(outcome):
outcomes.append(outcome)
handler._record_request_outcome = _record_request_outcome
clear_turn_hooks()
register_turn_hook(_DeferTools())
try:
with patch.dict(sys.modules, {"websockets": _make_fake_websockets_module(upstream)}):
await handler.handle_openai_responses_ws(client_ws)
finally:
clear_turn_hooks()
assert len(upstream.sent) == frames_n
assert seen["frame"] == frames_n
metrics = PrometheusMetrics()
stored = []
for outcome in outcomes:
rows = from_tags(outcome.tags)
stored.append(len(outcome.tags.get(SAVINGS_ATTRIBUTION_TAG, [])))
await metrics.record_request(
provider="openai",
model="gpt-5.4",
input_tokens=10,
output_tokens=1,
tokens_saved=0,
latency_ms=1.0,
savings_attribution=rows,
)
hook_rows = [row for row in metrics.savings_by_source.values() if row["source"] != "ws_fold"]
assert sum(int(row["tokens"]) for row in hook_rows) == 100 * frames_n
assert sum(int(row["events"]) for row in hook_rows) == frames_n
assert math.isclose(sum(float(row["usd"]) for row in hook_rows), 0.01 * frames_n)
assert ("other" in {row["source"] for row in hook_rows}) is overflowed
assert stored == [expected_rows]
+554
View File
@@ -0,0 +1,554 @@
"""A graceful proxy restart must not cost warm conversations their prompt cache.
Production, 2026-10-19: five graceful restarts in one day (app relaunches for
updates) each made the next request of every active Claude Code session read
only the ~25k-token tools + system prefix and re-write the rest, 247k-432k
tokens at a time, about a third of that day's cache writes. After a restart
the proxy has no ``PrefixCacheTracker`` for the conversation, so it compresses
the whole history afresh and the early messages come out as different bytes
than the prefix it forwarded before the restart.
``HEADROOM_PREFIX_STATE_FILE`` (opt-in) saves the tracker store on graceful
shutdown and restores it at startup, so the first request after a restart
replays the exact prefix the provider cached.
"""
from __future__ import annotations
import contextvars
import errno
import json
import os
import stat
from pathlib import Path
from types import SimpleNamespace
from typing import Any
import pytest
pytest.importorskip("fastapi")
import httpx
from fastapi.testclient import TestClient
from headroom.cache import prefix_tracker
from headroom.cache.compression_store import get_compression_store, reset_compression_store
from headroom.cache.prefix_tracker import PREFIX_STATE_FILE_ENV, SessionTrackerStore
from headroom.ccr.tool_injection import CCRToolInjector
from headroom.config import TransformResult
from headroom.proxy.server import ProxyConfig, create_app
from headroom.transforms.pipeline import TransformPipeline
from tests.test_anthropic_fork_lineage_cache import (
_drive,
_main,
_PromptCache,
_send,
_strip,
_summary_fork,
)
def _wire(messages: list[dict[str, Any]]) -> str:
"""The bytes the provider keys its prefix cache on (breakpoints excluded)."""
return json.dumps(_strip(messages))
def _ccr_hashes(messages: list[dict[str, Any]]) -> set[str]:
"""Retrieval references the model sees, found the way the proxy finds them."""
return set(CCRToolInjector().scan_for_markers(messages))
def _with_fake_kompress(monkeypatch: pytest.MonkeyPatch) -> None:
"""A deterministic stand-in for the Kompress ML stage (off in this suite).
A cold start forwards the fast pass, which skips Kompress, while warm
turns compress their new messages with it. So after a restart without
state, the cold fast pass re-emits every message Kompressed after the
first turn in a different form, which re-writes the cache from there."""
real_apply = TransformPipeline.apply
def apply(self, messages, model, **kwargs): # noqa: ANN001, ANN003, ANN202
skip = kwargs.get("skip_kompress", False)
frozen = kwargs.get("frozen_message_count", 0) or 0
result = real_apply(self, messages, model, **kwargs)
if skip:
return result
out = []
for i, message in enumerate(result.messages):
content = message.get("content")
if i >= frozen and isinstance(content, list):
blocks = []
for block in content:
text = block.get("content") if isinstance(block, dict) else None
if block.get("type") == "tool_result" and isinstance(text, str):
if not text.endswith(" [kompressed]"):
block = {**block, "content": text[: len(text) // 2] + " [kompressed]"}
blocks.append(block)
message = {**message, "content": blocks}
out.append(message)
result.messages = out
return result
monkeypatch.setattr(TransformPipeline, "apply", apply)
def _read_turn(i: int) -> list[dict[str, Any]]:
tid = f"toolu_r{i:02d}"
body = "\n".join(f"{n:5d} line {n} of file {i}: some code here" for n in range(300))
return [
{
"role": "assistant",
"content": [
{"type": "tool_use", "id": tid, "name": "Read", "input": {"file_path": f"/f{i}.py"}}
],
},
{"role": "user", "content": [{"type": "tool_result", "tool_use_id": tid, "content": body}]},
]
def _reads(turns: int) -> list[dict[str, Any]]:
"""One Read per turn; Claude Code's breakpoint rides the newest block."""
messages: list[dict[str, Any]] = [
{"role": "user", "content": [{"type": "text", "text": "Review the change."}]}
]
for i in range(turns):
messages += _read_turn(i)
messages[-1]["content"][-1]["cache_control"] = {"type": "ephemeral"}
return messages
# (history builder, turns before the restart, proxy config, fake Kompress)
_SCENARIOS = {
# Turns 1-2, restart, turn 3: Kompressed messages come back fast-passed.
"kompress": (_main, 2, {}, True),
# Reads held while active then cached verbatim stay verbatim; a fresh
# process with an empty CompressionCache freezes nothing and matures them.
"read-maturation": (
_reads,
5,
{
"read_maturation": True,
"read_maturation_quiesce_turns": 2,
"read_maturation_min_size_bytes": 100,
},
False,
),
}
def _restart_between_turns(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path, scenario: str
) -> tuple[list[dict[str, Any]], list[dict[str, Any]], int, dict[str, str]]:
"""Some turns in one proxy, the next turn in a fresh one, one warm
provider cache. Returns (last forwarded before, first forwarded after,
its read hit, the original behind each retrieval reference forwarded
before the restart)."""
build, turns, config, kompress = _SCENARIOS[scenario]
monkeypatch.setenv("HEADROOM_CCR_BACKEND", "memory")
# As the desktop app runs it: a cold start forwards the fast pass.
monkeypatch.setenv("HEADROOM_BACKGROUND_COMPRESSION", "1")
monkeypatch.setenv("HEADROOM_BACKGROUND_COMPRESSION_MIN_TOKENS", "1")
monkeypatch.chdir(tmp_path)
if kompress:
_with_fake_kompress(monkeypatch)
cache = _PromptCache()
reset_compression_store()
before = _drive([build(n) for n in range(1, turns + 1)], cache, **config)
store = get_compression_store()
originals = {h: store.retrieve(h).original_content for h in _ccr_hashes(before[-1][0])} # type: ignore[union-attr]
reset_compression_store() # nothing in process memory survives a restart
(after,) = _drive([build(turns + 1)], cache, **config)
return before[-1][0], after[0], after[1], originals
@pytest.mark.parametrize("scenario", list(_SCENARIOS))
def test_first_request_after_a_restart_replays_the_cached_prefix(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path, scenario: str
) -> None:
state = tmp_path / "prefix-state.json"
monkeypatch.setenv(PREFIX_STATE_FILE_ENV, str(state))
previous, current, hit, _ = _restart_between_turns(monkeypatch, tmp_path, scenario)
assert _wire(current[: len(previous)]) == _wire(previous)
assert hit >= len(previous) - 1, f"read only {hit + 1}/{len(previous)} cached messages"
def test_restored_retrieval_references_resolve_to_their_originals(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""Review of #4299: matching bytes are not enough. With the in-process CCR
backend a restart emptied the store, so a matured Read the restored
tracker kept replaying pointed at a hash that no longer resolved."""
monkeypatch.setenv(PREFIX_STATE_FILE_ENV, str(tmp_path / "prefix-state.json"))
previous, current, _, originals = _restart_between_turns(
monkeypatch, tmp_path, "read-maturation"
)
emitted = _ccr_hashes(current)
assert emitted & originals.keys(), "no pre-restart reference was replayed"
store = get_compression_store()
for h in emitted:
entry = store.retrieve(h)
assert entry is not None, f"hash={h} does not resolve after the restart"
if h in originals:
assert entry.original_content == originals[h]
@pytest.mark.parametrize("scenario", list(_SCENARIOS))
def test_without_the_state_file_a_restart_rewrites_the_prefix(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path, scenario: str
) -> None:
"""Default behavior is unchanged, and it is the bug the opt-in fixes, so
the test above is not vacuous."""
monkeypatch.delenv(PREFIX_STATE_FILE_ENV, raising=False)
previous, current, hit, _ = _restart_between_turns(monkeypatch, tmp_path, scenario)
assert _wire(current[: len(previous)]) != _wire(previous)
assert hit < len(previous) - 1
assert list(tmp_path.iterdir()) == [], "nothing may be written without the opt-in"
def _two_conversations() -> SessionTrackerStore:
store = SessionTrackerStore()
contextvars.Context().run(_send, store, _strip(_main(3)))
contextvars.Context().run(_send, store, [{"role": "user", "content": "unrelated"}])
return store
def test_restored_lineages_resume_and_new_ones_get_fresh_keys(tmp_path: Path) -> None:
"""Store level: a fork answered last still leaves the main turn resumable,
and a new conversation never lands on a restored lineage's key."""
store = _two_conversations()
base = _strip(_main(3))
contextvars.Context().run(_send, store, _strip(_summary_fork(3)))
path = str(tmp_path / "state.json")
assert store.save_state(path) == 2
restored = SessionTrackerStore()
assert restored.load_state(path) == 2
main = contextvars.Context().run(
restored.resolve_tracker, "sid", "anthropic", messages=_strip(_main(4))
)
new = contextvars.Context().run(
restored.resolve_tracker, "sid", "anthropic", messages=[{"role": "user", "content": "new"}]
)
assert main.get_frozen_message_count() == len(base)
assert main.get_last_original_messages() == base
assert restored.active_sessions == 3
assert new is not main and new.get_frozen_message_count() == 0
def test_expired_trackers_are_not_restored(tmp_path: Path) -> None:
path = tmp_path / "state.json"
_two_conversations().save_state(str(path))
data = json.loads(path.read_text())
data["trackers"][0]["meta"]["last_activity"] -= 3600 # past the 600s retention
path.write_text(json.dumps(data))
assert SessionTrackerStore().load_state(str(path)) == 1
def _bad_ref(path: Path) -> None:
data = json.loads(path.read_text())
data["trackers"][0]["meta"]["state"][3] = [-1]
path.write_text(json.dumps(data))
def _bad_maturation(path: Path) -> None:
data = json.loads(path.read_text())
data["trackers"][-1]["meta"]["maturation"] = {"matured": [1], "booked": [], "deltas": {}}
path.write_text(json.dumps(data))
@pytest.mark.parametrize(
"corrupt",
[
lambda p: p.write_text('{"version": 1, "trackers": [{"meta"'),
lambda p: p.write_text('{"version": 99, "trackers": []}'),
lambda p: p.write_text("[1, 2]"),
_bad_ref,
_bad_maturation,
],
ids=["truncated", "version", "shape", "bad-ref", "bad-maturation"],
)
def test_a_bad_state_file_starts_empty(tmp_path: Path, caplog, corrupt) -> None: # noqa: ANN001
path = tmp_path / "state.json"
_two_conversations().save_state(str(path))
corrupt(path)
store = SessionTrackerStore()
assert store.load_state(str(path)) == 0
assert store.active_sessions == 0
assert "ignoring prefix state" in caplog.text
def test_state_file_is_private_and_removed_once_loaded(tmp_path: Path) -> None:
path = tmp_path / "state.json"
path.write_text("stale")
path.chmod(0o644)
assert _two_conversations().save_state(str(path)) == 2
if os.name == "posix":
assert stat.S_IMODE(path.stat().st_mode) == 0o600
assert SessionTrackerStore().load_state(str(path)) == 2
assert not path.exists()
assert SessionTrackerStore().load_state(str(path)) == 0 # missing file: cold start
def test_save_keeps_the_newest_trackers_within_the_cap(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
store = _two_conversations()
newest = max(store._trackers.values(), key=lambda t: t._last_activity)
monkeypatch.setattr(prefix_tracker, "_PREFIX_STATE_MAX_TRACKERS", 1)
path = str(tmp_path / "state.json")
assert store.save_state(path) == 1
restored = SessionTrackerStore()
restored.load_state(path)
(kept,) = restored._trackers.values()
assert kept.get_last_original_messages() == newest.get_last_original_messages()
monkeypatch.setattr(prefix_tracker, "_PREFIX_STATE_MAX_BYTES", 10)
assert store.save_state(path) == 0
def test_stateless_mode_writes_nothing(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
monkeypatch.setenv("HEADROOM_STATELESS", "1")
path = tmp_path / "state.json"
assert _two_conversations().save_state(str(path)) == 0
assert not path.exists()
def test_a_stateless_proxy_leaves_a_saved_snapshot_alone(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""Loading deletes the file, so a stateless start must not load it: the
next normal start resumes those conversations."""
path = tmp_path / "state.json"
assert _two_conversations().save_state(str(path)) == 2
saved = path.read_text()
monkeypatch.setenv(PREFIX_STATE_FILE_ENV, str(path))
monkeypatch.setenv("HEADROOM_STATELESS", "1")
_drive([]) # one stateless proxy start and graceful shutdown
assert path.read_text() == saved
monkeypatch.delenv("HEADROOM_STATELESS")
assert SessionTrackerStore().load_state(str(path)) == 2
def test_a_failed_save_keeps_the_previous_snapshot(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
path = tmp_path / "state.json"
assert _two_conversations().save_state(str(path)) == 2
saved = path.read_text()
def disk_full(*args: Any, **kwargs: Any) -> None:
raise OSError(errno.ENOSPC, "No space left on device")
monkeypatch.setattr("headroom.fsutil.write_text", disk_full)
assert _two_conversations().save_state(str(path)) == 0
assert path.read_text() == saved
def test_saved_ccr_entries_resolve_after_a_restart(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""Store level, compressor markers in the replayed prefix: both hash
formats resolve to the same original with the same expiry after the
in-process CCR store is emptied, and an entry that expired does not."""
monkeypatch.setenv("HEADROOM_CCR_BACKEND", "memory")
reset_compression_store()
ccr = get_compression_store()
rows = ccr.store(json.dumps(list(range(400))), "[0, 1]", ttl=900)
blob = ccr.store("x" * 5000, "", ttl=900, explicit_hash="abcdef123456")
gone = ccr.store("expired original", "", ttl=900)
ccr._backend.get(gone).created_at -= 1000 # type: ignore[union-attr]
expires = {h: ccr.get_entry_status(h)["expires_at"] for h in (rows, blob)}
text = (
f"[400 items compressed to 2. Retrieve more: hash={rows}] "
f"<<ccr:{blob},base64,4.9KB>> [stale. Retrieve original: hash={gone}]"
)
store = SessionTrackerStore()
contextvars.Context().run(_send, store, [{"role": "user", "content": text}])
path = str(tmp_path / "state.json")
assert store.save_state(path) == 1
reset_compression_store()
assert SessionTrackerStore().load_state(path) == 1
ccr = get_compression_store()
assert ccr.retrieve(rows).original_content == json.dumps(list(range(400))) # type: ignore[union-attr]
assert ccr.retrieve(blob).original_content == "x" * 5000 # type: ignore[union-attr]
assert ccr.retrieve(gone) is None
for h, at in expires.items():
assert abs(ccr.get_entry_status(h)["expires_at"] - at) < 2
reset_compression_store()
def _chat_turns(n: int) -> list[dict[str, Any]]:
"""An OpenAI chat agent: one big tool result, then ``n - 1`` follow-ups."""
messages: list[dict[str, Any]] = [
{"role": "user", "content": "run the build and show me the log"},
{
"role": "assistant",
"content": None,
"tool_calls": [
{
"id": "call_1",
"type": "function",
"function": {"name": "bash", "arguments": "{}"},
}
],
},
{"role": "tool", "tool_call_id": "call_1", "content": "build log line OK\n" * 200},
]
for i in range(1, n):
messages += [
{"role": "assistant", "content": f"answer {i}"},
{"role": "user", "content": "and now?"},
]
return messages
def _relevance_pipeline(**kwargs: Any) -> TransformResult:
"""Query-dependent compression, like SmartCrusher's relevance scoring: the
same tool result compresses differently under a different user query."""
frozen = kwargs.get("frozen_message_count") or 0
query = next(m["content"] for m in reversed(kwargs["messages"]) if m["role"] == "user")
messages = [
{**m, "content": f"[log: kept lines relevant to {query!r}]"}
if i >= frozen and m.get("role") == "tool"
else m
for i, m in enumerate(kwargs["messages"])
]
return TransformResult(
messages=messages, tokens_before=2000, tokens_after=40, transforms_applied=["relevance"]
)
def _drive_openai_chat(requests: list[list[dict[str, Any]]]) -> list[list[dict[str, Any]]]:
"""Each history through the real OpenAI chat handler in token mode; one
app per call, so a second call is a proxy restart."""
app = create_app(
ProxyConfig(
optimize=True,
mode="token",
disable_kompress=True,
rate_limit_enabled=False,
cost_tracking_enabled=False,
log_requests=False,
)
)
forwarded: list[list[dict[str, Any]]] = []
with TestClient(app) as client:
proxy = client.app.state.proxy
proxy.openai_pipeline.apply = _relevance_pipeline
async def _upstream(method, url, headers, body, stream=False, **kwargs): # noqa: ANN001, ANN003
forwarded.append(json.loads(json.dumps(body["messages"])))
# Automatic prefix caching reports nothing cached on a
# conversation's first request, so there is no confirmed floor.
usage = {"prompt_tokens": 600, "completion_tokens": 3, "total_tokens": 603}
usage["prompt_tokens_details"] = {"cached_tokens": 0}
return httpx.Response(
200,
json={
"id": "chatcmpl_x",
"choices": [
{
"index": 0,
"message": {"role": "assistant", "content": "ok"},
"finish_reason": "stop",
}
],
"usage": usage,
},
)
proxy._retry_request = _upstream
for messages in requests:
response = client.post(
"/v1/chat/completions",
headers={"authorization": "Bearer test-key"},
json={"model": "gpt-4o-mini", "messages": messages},
)
assert response.status_code == 200, response.text[:300]
return forwarded
def test_openai_token_mode_replays_its_prefix_after_a_restart(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""Review of #4299: only the Anthropic handler seeded its CompressionCache
from a restored tracker. The OpenAI token path froze nothing, recompressed
the tool result under the new query, and with no provider-confirmed floor
the overlay declined the larger previous form, so the prefix changed."""
monkeypatch.setenv("HEADROOM_CCR_BACKEND", "memory")
monkeypatch.setenv(PREFIX_STATE_FILE_ENV, str(tmp_path / "prefix-state.json"))
reset_compression_store()
(previous,) = _drive_openai_chat([_chat_turns(1)])
(current,) = _drive_openai_chat([_chat_turns(2)])
assert previous[2]["content"] != _chat_turns(1)[2]["content"], "nothing was compressed"
assert current[: len(previous)] == previous
def test_read_maturation_state_survives_a_restart(tmp_path: Path) -> None:
"""Matured Reads stay booked once: without this a restart books their
removal again on every later request of the conversation."""
from headroom.config import ReadMaturationConfig
from headroom.transforms.read_maturation import MaturedRead, ReadMaturationManager
store = _two_conversations()
manager = ReadMaturationManager(ReadMaturationConfig(enabled=True))
manager._matured["toolu_r00"] = MaturedRead(marker="[Read of /f0.py ...]", ccr_hash="abc")
manager._booked.add("toolu_r00")
manager._replay_token_deltas["toolu_r00"] = 640
newest = max(store._trackers.values(), key=lambda t: t._last_activity)
newest.read_maturation_manager = manager
path = str(tmp_path / "state.json")
store.save_state(path)
restored = SessionTrackerStore()
restored.load_state(path)
states = [t.restored_maturation_state for t in restored._trackers.values()]
assert all(t.restored_from_disk for t in restored._trackers.values())
(state,) = [s for s in states if s is not None]
adopted = ReadMaturationManager(ReadMaturationConfig(enabled=True))
adopted.restore_state(state)
assert adopted._matured == manager._matured
assert adopted._booked == manager._booked
assert adopted._replay_token_deltas == manager._replay_token_deltas
def test_compress_sidecar_session_replays_its_prefix_after_a_restart(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""The same seed on the session-aware /v1/compress path (sidecar gateways),
which replays with the size bound alone (no provider-confirmed floor)."""
from tests.test_compress_session_mode import _compress, _make_client
monkeypatch.setenv("HEADROOM_CCR_BACKEND", "memory")
monkeypatch.setenv(PREFIX_STATE_FILE_ENV, str(tmp_path / "prefix-state.json"))
reset_compression_store()
forwarded = []
for history in (_chat_turns(1), _chat_turns(2)): # one proxy each: a restart between
with _make_client() as client:
client.app.state.proxy._no_ccr_pipeline = lambda: SimpleNamespace(
apply=_relevance_pipeline
)
forwarded.append(_compress(client, history, session_id="conv-r")["messages"])
previous, current = forwarded
assert previous[2]["content"] != _chat_turns(1)[2]["content"], "nothing was compressed"
assert current[: len(previous)] == previous
+9 -3
View File
@@ -56,10 +56,16 @@ def test_antigravity_render_setup_lines_contains_proxy_url() -> None:
assert "Antigravity" in joined
def test_antigravity_render_setup_lines_mentions_custom_provider() -> None:
def test_antigravity_setup_lines_do_not_claim_ide_provider_settings() -> None:
joined = "\n".join(render_setup_lines(8787))
assert "OpenAI-compatible" in joined
assert "/v1/models" in joined
assert "does not support third-party model providers" in joined
assert "Add a custom OpenAI-compatible" not in joined
assert "model-provider settings" not in joined
assert "mcp install --agent antigravity" in joined
assert "/v1internal:streamGenerateContent" in joined
assert "GOOGLE_GEMINI_BASE_URL" in joined
assert "GOOGLE_GEMINI_BASE_URL=http://127.0.0.1:8787" in joined
assert "For OpenAI-speaking clients" in joined
def test_antigravity_render_setup_lines_project_attribution() -> None:
+3 -1
View File
@@ -449,5 +449,7 @@ def test_websocket_route_carries_the_client_decision(
assert seen, "the Responses compressor was never reached on the WS path"
assert {
k: v for k, v in seen[0].items() if k not in {"timing", "deadline_started_at"}
k: v
for k, v in seen[0].items()
if k not in {"timing", "deadline_started_at", "savings_tags"}
} == expected
+296
View File
@@ -0,0 +1,296 @@
"""``on_responses_create``: one routing seam for OpenAI Responses on both transports.
Codex sends ``/v1/responses`` over a WebSocket when wrapped, and an HTTP
middleware never sees those frames, so a router installed as middleware did
nothing for wrapped Codex. A turn hook's ``on_responses_create`` runs on the
HTTP body and on every WebSocket ``response.create`` frame, before the proxy's
own stages, so a model/effort rewrite reaches the upstream and the accounting.
"""
from __future__ import annotations
import json
import sys
from typing import Any
from unittest.mock import patch
import pytest
from headroom.proxy.turn_hooks import (
ResponsesCreate,
clear_turn_hooks,
register_turn_hook,
)
from tests.test_openai_codex_ws_lifecycle import (
_DummyOpenAIHandler,
_FakeUpstream,
_FakeWebSocket,
_make_fake_websockets_module,
)
@pytest.fixture(autouse=True)
def _clean_registry():
clear_turn_hooks()
yield
clear_turn_hooks()
class _Router:
name = "test-router"
def __init__(self) -> None:
self.seen: list[tuple[str, str, str | None]] = []
self.connections: list[str | None] = []
async def on_responses_create(self, request: ResponsesCreate) -> dict:
self.seen.append(
(request.transport, str(request.body.get("model")), request.headers.get("user-agent"))
)
self.connections.append(request.connection_id)
return {**request.body, "model": "gpt-5.4-mini", "reasoning": {"effort": "low"}}
def _create(text: str, **extra: Any) -> str:
return json.dumps(
{"type": "response.create", "response": {"model": "gpt-5.5", "input": text, **extra}}
)
def _upstream() -> _FakeUpstream:
return _FakeUpstream(
[
json.dumps({"type": "response.created", "response": {"id": "r_1"}}),
json.dumps({"type": "response.completed", "response": {"id": "r_1"}}),
],
hold_after_events=True,
)
async def _run_ws(frames: list[str], headers: dict[str, str] | None = None) -> list[dict]:
upstream = _upstream()
client_ws = _FakeWebSocket(frames=frames, headers=headers)
with patch.dict(sys.modules, {"websockets": _make_fake_websockets_module(upstream)}):
await _DummyOpenAIHandler().handle_openai_responses_ws(client_ws)
return [json.loads(frame) for frame in upstream.sent]
@pytest.mark.asyncio
async def test_ws_create_frames_carry_the_hooks_model_and_effort_upstream() -> None:
router = _Router()
register_turn_hook(router)
# previous_response_id chains are left to the client and OpenAI: a model
# switch mid-chain is allowed, so the hook's rewrite rides alongside it.
sent = await _run_ws(
[
_create("first"),
json.dumps({"type": "response.cancel"}),
_create("next", previous_response_id="r_1"),
]
)
creates = [frame["response"] for frame in sent if frame.get("type") == "response.create"]
assert [c["model"] for c in creates] == ["gpt-5.4-mini", "gpt-5.4-mini"]
assert [c["reasoning"] for c in creates] == [{"effort": "low"}] * 2
assert creates[1]["previous_response_id"] == "r_1"
assert {"type": "response.cancel"} in sent
# Compression is off in the dummy handler: routing must not depend on it.
assert router.seen == [
("websocket", "gpt-5.5", "codex-cli/0.5"),
("websocket", "gpt-5.5", "codex-cli/0.5"),
]
# One connection, one id: what a hook keys a previous_response_id chain on.
assert router.connections[0] and len(set(router.connections)) == 1
@pytest.mark.asyncio
async def test_ws_bypass_header_skips_the_hook() -> None:
router = _Router()
register_turn_hook(router)
frames = [_create("first"), _create("next")]
sent = await _run_ws(frames, headers={"authorization": "Bearer t", "x-headroom-bypass": "true"})
assert router.seen == []
assert [frame["response"]["model"] for frame in sent] == ["gpt-5.5", "gpt-5.5"]
@pytest.mark.asyncio
async def test_a_hook_that_raises_does_not_break_the_session() -> None:
class _Broken:
name = "broken"
async def on_responses_create(self, request: ResponsesCreate) -> None:
# The body is read-only: a hook cannot half-apply an edit and then fail.
request.body["model"] = "gpt-5.4-mini" # type: ignore[index]
register_turn_hook(_Broken())
frames = [_create("first")]
sent = await _run_ws(frames)
assert sent == [json.loads(frames[0])]
class _NoOp:
name = "no-op"
async def on_responses_create(self, request: ResponsesCreate) -> None:
return None
def _post_http(raw: bytes, headers: dict[str, str] | None = None) -> tuple[Any, list, list]:
"""POST raw bytes to /v1/responses.
Returns the response, what reached the upstream call as
``(body, body_mutated)`` pairs, and the recorded outcomes.
"""
pytest.importorskip("fastapi")
httpx = pytest.importorskip("httpx")
from fastapi.testclient import TestClient
from headroom.proxy.loopback_guard import require_loopback
from headroom.proxy.server import ProxyConfig, create_app
app = create_app(
ProxyConfig(
optimize=False,
cache_enabled=False,
rate_limit_enabled=False,
cost_tracking_enabled=False,
)
)
app.dependency_overrides[require_loopback] = lambda: None
sent: list[Any] = []
outcomes: list[Any] = []
with TestClient(app) as client:
server = app.state.proxy
async def fake_retry(method, url, headers, body, stream=False, **kwargs):
sent.append((_as_json(body), kwargs.get("body_mutated")))
return httpx.Response(
200,
json={
"id": "resp_1",
"object": "response",
"status": "completed",
"model": "gpt-5.4-mini",
"output": [],
"usage": {"input_tokens": 10, "output_tokens": 2},
},
request=httpx.Request("POST", url),
)
record = server._record_request_outcome
async def capture(outcome):
outcomes.append(outcome)
await record(outcome)
server._retry_request = fake_retry
server._record_request_outcome = capture
resp = client.post(
"/v1/responses",
content=raw,
headers={
"Authorization": "Bearer sk-test",
"Content-Type": "application/json",
"User-Agent": "codex_exec/0.162.1",
**(headers or {}),
},
)
return resp, sent, outcomes
def _as_json(body: Any) -> dict:
return json.loads(body) if isinstance(body, (bytes, str)) else body
_RAW = json.dumps({"model": "gpt-5.5", "input": "hi", "stream": False}).encode()
def test_http_body_carries_the_hooks_model_and_the_outcome_prices_it() -> None:
router = _Router()
register_turn_hook(router)
resp, sent, outcomes = _post_http(_RAW)
assert resp.status_code == 200, resp.text
assert router.seen == [("http", "gpt-5.5", "codex_exec/0.162.1")]
assert router.connections == [None]
body, mutated = sent[0]
assert body["model"] == "gpt-5.4-mini"
assert body["reasoning"] == {"effort": "low"}
assert mutated is True
assert outcomes and all(o.model == "gpt-5.4-mini" for o in outcomes)
def test_http_hook_that_changes_nothing_keeps_the_clients_bytes() -> None:
register_turn_hook(_NoOp())
resp, sent, _ = _post_http(_RAW)
assert resp.status_code == 200, resp.text
# Unmutated is what sends the client's original bytes (#1542).
assert sent == [(json.loads(_RAW), False)]
def test_http_bypass_header_skips_the_hook() -> None:
router = _Router()
register_turn_hook(router)
resp, sent, _ = _post_http(_RAW, headers={"x-headroom-bypass": "true"})
assert resp.status_code == 200, resp.text
assert router.seen == []
assert sent == [(json.loads(_RAW), False)]
def test_http_hook_that_turns_on_streaming_takes_the_streaming_path() -> None:
class _Streamer:
name = "streamer"
async def on_responses_create(self, request: ResponsesCreate) -> dict:
return {**request.body, "stream": True}
register_turn_hook(_Streamer())
pytest.importorskip("fastapi")
from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
from headroom.proxy.loopback_guard import require_loopback
from headroom.proxy.server import ProxyConfig, create_app
app = create_app(
ProxyConfig(
optimize=False,
cache_enabled=False,
rate_limit_enabled=False,
cost_tracking_enabled=False,
)
)
app.dependency_overrides[require_loopback] = lambda: None
streamed: list[dict] = []
with TestClient(app) as client:
server = app.state.proxy
async def fake_stream(url, headers, body, *args, **kwargs):
streamed.append(body)
return JSONResponse({"ok": True})
async def no_buffered(*args, **kwargs):
raise AssertionError("a streaming upstream request took the buffered path")
server._stream_response = fake_stream
server._retry_request = no_buffered
resp = client.post(
"/v1/responses",
content=_RAW,
headers={"Authorization": "Bearer sk-test", "Content-Type": "application/json"},
)
assert resp.status_code == 200, resp.text
assert [b["stream"] for b in streamed] == [True]
+64
View File
@@ -405,6 +405,70 @@ def test_backend_clean_eof_requires_protocol_completion(provider, complete):
assert outcomes[0].status_code == (200 if complete else 502)
@pytest.mark.parametrize("provider", ["anthropic", "openai"])
def test_backend_client_hangup_after_terminal_event_is_completed(provider):
"""A client may close on the terminal event, before the backend's EOF."""
from types import MethodType
from headroom.proxy.handlers.streaming import StreamingMixin
class Backend(_Backend):
async def stream_message(self, body, headers):
yield SimpleNamespace(
event_type="message_stop",
raw_sse='event: message_stop\ndata: {"type":"message_stop"}\n\n',
data={"type": "message_stop"},
)
await asyncio.Event().wait()
async def stream_openai_message(self, body, headers):
yield "data: [DONE]\n\n"
await asyncio.Event().wait()
outcomes = []
async def record(outcome):
outcomes.append(outcome)
handler = _handler(Backend(provider))
handler._record_request_outcome = record
handler._extract_anthropic_cache_ttl_metrics = lambda usage: (0, 0)
handler._parse_sse_usage_from_buffer = MethodType(
StreamingMixin._parse_sse_usage_from_buffer, handler
)
async def drive():
arguments = {
"body": {"messages": []},
"headers": {},
"model": "m",
"request_id": "rid",
"original_tokens": 0,
"optimized_tokens": 0,
"tokens_saved": 0,
"transforms_applied": [],
"tags": {},
"optimization_latency": 0.0,
"backend": handler.anthropic_backend,
}
if provider == "anthropic":
response = await StreamingMixin._stream_response_bedrock(
handler, provider=provider, **arguments
)
else:
response = await StreamingMixin._stream_openai_via_backend(
handler, start_time=0.0, **arguments
)
body = response.body_iterator
while b"message_stop" not in (chunk := await body.__anext__()) and b"[DONE]" not in chunk:
pass
await body.aclose()
asyncio.run(drive())
assert len(outcomes) == 1
assert outcomes[0].status_code == 200
@pytest.mark.parametrize("provider", ["anthropic", "openai"])
@pytest.mark.parametrize("complete", [False, True])
def test_backend_prefix_tracker_advances_only_after_completion(provider, complete):
+5 -2
View File
@@ -119,8 +119,11 @@ class TestLiteLLMLogSuppression:
import os
monkeypatch.delenv("LITELLM_SUPPRESS_DEBUG_INFO", raising=False)
sys.modules.pop("headroom.providers.litellm", None)
sys.modules.pop("litellm", None)
# delitem, not pop: teardown puts the real modules back. A bare pop made
# every later `import litellm` load a second copy, so a test pinning a
# rate on it missed modules still holding the first (CostTracker).
monkeypatch.delitem(sys.modules, "headroom.providers.litellm", raising=False)
monkeypatch.delitem(sys.modules, "litellm", raising=False)
original_import = builtins.__import__
fake_litellm = ModuleType("litellm")
-25
View File
@@ -13,11 +13,6 @@ pytest.importorskip("fastapi")
from headroom import paths
from headroom.proxy.output_savings import SavingsRecorder
from headroom.relevance.embedding import (
_DEFAULT_MODEL_PINNED_REVISION,
DEFAULT_MODEL_NAME,
_pinned_revision,
)
@pytest.fixture(autouse=True)
@@ -100,23 +95,3 @@ def test_memory_disabled_under_stateless(tmp_path, monkeypatch):
proxy = app.state.proxy
assert proxy.memory_handler is None
assert not workspace.exists()
# ---- fastembed model pinning ----------------------------------------------
def test_fastembed_default_model_is_pinned_to_sha(monkeypatch):
monkeypatch.delenv("HEADROOM_HF_PIN", raising=False)
rev = _pinned_revision(DEFAULT_MODEL_NAME)
assert rev == _DEFAULT_MODEL_PINNED_REVISION
assert len(rev) == 40 and all(c in "0123456789abcdef" for c in rev)
def test_fastembed_custom_model_not_pinned(monkeypatch):
monkeypatch.delenv("HEADROOM_HF_PIN", raising=False)
assert _pinned_revision("intfloat/e5-small-v2") is None
def test_fastembed_pin_can_be_disabled(monkeypatch):
monkeypatch.setenv("HEADROOM_HF_PIN", "off")
assert _pinned_revision(DEFAULT_MODEL_NAME) is None
+109
View File
@@ -176,3 +176,112 @@ def test_stats_and_ledger_share_one_new_input_cohort(tmp_path, monkeypatch):
)
# The cache-read-only turn's savings still count on the whole-wire figure.
assert tokens["saved"] == 600
def test_inferred_openai_write_counts_as_new_input_once(tmp_path, monkeypatch):
"""OpenAI paths with no reported write pass ``cache_inferred=True`` with the
write equal to the uncached slice (input - cached): one set of tokens under
two names. Adding both doubled new input, so a true 50% rate read 33%, and
the provider row showed (and priced a premium on) a write nobody billed."""
ledger_path = tmp_path / "savings_events.jsonl"
monkeypatch.setattr(savings_ledger, "_resolve_path", lambda path=None: ledger_path)
with _make_client(tmp_path, monkeypatch) as client:
proxy = client.app.state.proxy
asyncio.run(
proxy.metrics.record_request(
provider="openai",
model="gpt-5.4",
input_tokens=2_000,
output_tokens=10,
tokens_saved=1_000,
latency_ms=10.0,
cache_read_tokens=1_000,
cache_write_tokens=1_000,
uncached_input_tokens=1_000,
cache_inferred=True,
)
)
stats = client.get("/stats").json()
lifetime = savings_ledger.aggregate_savings(path=ledger_path).lifetime
tokens = stats["tokens"]
totals = stats["prefix_cache"]["totals"]
openai_row = stats["prefix_cache"]["by_provider"]["openai"]
assert tokens["new_input_tokens"] == 1_000
assert lifetime["new_input_tokens"] == 1_000
# 1,000 saved / (1,000 new + 1,000 saved), not 1,000 / 3,000.
assert tokens["new_input_savings_percent"] == 50.0
assert lifetime["new_input_savings_percent"] == 50.0
assert openai_row["cache_write_tokens"] == 0
assert openai_row["hit_rate"] == 50.0
new_input = totals["cache_write_tokens"] + totals["uncached_input_tokens"]
assert new_input == totals["new_input_tokens"]
def test_inferred_openai_write_carries_no_write_premium(tmp_path, monkeypatch):
"""The OpenAI row prices its write premium from the cost tracker's model.
Where the catalog gives that model a write rate above input (gpt-5.6
publishes 1.25x), an inferred write counted as a write was charged the
premium on tokens OpenAI billed as plain input."""
import litellm
from headroom.pricing.counterfactual import resolve_rates
from headroom.proxy.outcome import RequestOutcome
ledger_path = tmp_path / "savings_events.jsonl"
monkeypatch.setattr(savings_ledger, "_resolve_path", lambda path=None: ledger_path)
# A real catalog id with known rates, so the live catalog cannot move them.
model = "gpt-4o"
monkeypatch.setitem(
litellm.model_cost,
model,
{
"input_cost_per_token": 4e-6,
"output_cost_per_token": 3.2e-5,
"cache_read_input_token_cost": 4e-7,
"cache_creation_input_token_cost": 5e-6,
"litellm_provider": "openai",
"mode": "chat",
},
)
resolve_rates.cache_clear()
try:
with _make_client(tmp_path, monkeypatch) as client:
proxy = client.app.state.proxy
# The Chat Completions handler's outcome: no reported write, so the
# write is inferred as input - cached. Feeds metrics AND the cost
# tracker, which supplies the price build_prefix_cache_stats uses.
asyncio.run(
proxy._record_request_outcome(
RequestOutcome(
request_id="req_inferred_write",
provider="openai",
model=model,
original_tokens=2_000,
optimized_tokens=2_000,
provider_input_tokens=2_000,
output_tokens=10,
tokens_saved=0,
attempted_input_tokens=2_000,
cache_read_tokens=1_000,
cache_write_tokens=1_000,
uncached_input_tokens=1_000,
cache_inferred=True,
)
)
)
openai_row = client.get("/stats").json()["prefix_cache"]["by_provider"]["openai"]
finally:
resolve_rates.cache_clear()
# The catalog write rate is in force, so a write would be charged 25%.
assert openai_row["cache_pricing_source"] == "catalog"
assert openai_row["write_premium"] == "25%"
# 1,000 reads x $4/M x 90% read discount.
assert openai_row["savings_usd"] == 0.0036
# Counted as a write: 1,000 x $4/M x 25% = $0.001 premium, net $0.0026.
assert openai_row["write_premium_usd"] == 0.0
assert openai_row["net_savings_usd"] == 0.0036
assert openai_row["cache_write_tokens"] == 0
@@ -0,0 +1,227 @@
"""A client that hangs up after the terminal event still got a complete stream.
Codex CLI closes the connection as soon as it reads ``response.completed``,
before the upstream EOF ends the proxy's read loop. The outcome was decided
only after that loop, so every such turn recorded as a 502 failure with no
usage and no cache metrics, although the client got a complete 200 response.
Success needs the terminal event the client was handed, not one only parsed
from upstream: the memory filter holds ``message_stop`` until after the stream.
"""
from __future__ import annotations
import asyncio
import json
from typing import Any
from unittest.mock import AsyncMock, MagicMock
import httpx
import pytest
from headroom.proxy.server import HeadroomProxy
def _event(name: str, payload: dict[str, Any]) -> bytes:
return f"event: {name}\ndata: {json.dumps(payload)}\n\n".encode()
START = _event("response.created", {"type": "response.created", "response": {"id": "r1"}})
COMPLETED = _event(
"response.completed",
{
"type": "response.completed",
"response": {
"id": "r1",
"status": "completed",
"usage": {
"input_tokens": 1_000,
"input_tokens_details": {"cached_tokens": 600, "cache_write_tokens": 0},
"output_tokens": 5,
},
},
},
)
# A whole Anthropic message in one upstream chunk: the parser sees message_stop
# before the client gets the first frame the memory filter splits it into.
MESSAGE = b"".join(
[
_event(
"message_start",
{
"type": "message_start",
"message": {
"id": "m1",
"type": "message",
"role": "assistant",
"model": "claude-test",
"content": [],
"usage": {"input_tokens": 1_000, "output_tokens": 1},
},
},
),
_event(
"content_block_start",
{"type": "content_block_start", "index": 0, "content_block": {"type": "text"}},
),
_event(
"content_block_delta",
{
"type": "content_block_delta",
"index": 0,
"delta": {"type": "text_delta", "text": "ok"},
},
),
_event("content_block_stop", {"type": "content_block_stop", "index": 0}),
_event(
"message_delta",
{
"type": "message_delta",
"delta": {"stop_reason": "end_turn"},
"usage": {"output_tokens": 5},
},
),
_event("message_stop", {"type": "message_stop"}),
]
)
MEMORY_STREAM = {
"url": "https://api.anthropic.com/v1/messages",
"headers": {"x-api-key": "sk-test"},
"body": {"model": "claude-test", "max_tokens": 100, "stream": True, "messages": []},
"provider": "anthropic",
"model": "claude-test",
"memory_user_id": "user-1",
"server_memory_tool_names": frozenset({"memory_save"}),
}
def _proxy(*chunks: bytes, upstream_eof: asyncio.Event | None = None) -> HeadroomProxy:
proxy = object.__new__(HeadroomProxy)
proxy.http_client = MagicMock(spec=httpx.AsyncClient)
proxy._config = MagicMock()
proxy._config.ccr_inject_tool = False
proxy._config.retry_max_attempts = 1
proxy.config = proxy._config
proxy._record_request_outcome = AsyncMock()
response = MagicMock()
response.headers = httpx.Headers({"content-type": "text/event-stream"})
response.status_code = 200
async def aiter_bytes():
for chunk in chunks or (START, COMPLETED):
yield chunk
if upstream_eof is not None:
await upstream_eof.wait() # the upstream EOF the client never waits for
response.aiter_bytes = aiter_bytes
response.aclose = AsyncMock()
proxy.http_client.build_request = MagicMock(return_value=MagicMock())
proxy.http_client.send = AsyncMock(return_value=response)
return proxy
async def _stream(proxy: HeadroomProxy, **overrides: Any):
arguments: dict[str, Any] = {
"url": "https://chatgpt.com/backend-api/codex/responses",
"headers": {"authorization": "Bearer test"},
"body": {"model": "gpt-5.4", "stream": True, "input": "Reply with: ok"},
"provider": "openai",
"model": "gpt-5.4",
"request_id": "test-hangup",
"original_tokens": 10,
"optimized_tokens": 10,
"tokens_saved": 0,
"transforms_applied": [],
"tags": {},
"optimization_latency": 0.0,
}
if overrides.get("memory_user_id"):
proxy.memory_handler = MagicMock()
response = await proxy._stream_response(**{**arguments, **overrides})
return response.body_iterator
@pytest.mark.parametrize("hangup", ["closed_at_terminal_yield", "cancelled_awaiting_eof"])
async def test_client_hangup_after_terminal_event_records_success_with_usage(hangup):
proxy = _proxy(upstream_eof=asyncio.Event())
body = await _stream(proxy)
seen = b""
if hangup == "closed_at_terminal_yield":
# The generator is suspended at the yield of the terminal chunk.
while b"response.completed" not in seen:
seen += await body.__anext__()
await body.aclose()
else:
# The generator read past the terminal chunk and waits for EOF.
async def read_all() -> None:
nonlocal seen
async for chunk in body:
seen += chunk
reader = asyncio.create_task(read_all())
while b"response.completed" not in seen:
await asyncio.sleep(0)
reader.cancel()
with pytest.raises(asyncio.CancelledError):
await reader
proxy._record_request_outcome.assert_awaited_once()
outcome = proxy._record_request_outcome.await_args.args[0]
assert outcome.status_code == 200
assert outcome.provider_input_tokens == 1_000
assert outcome.cache_read_tokens == 600
assert outcome.output_tokens == 5
async def test_client_hangup_before_terminal_event_is_still_a_failure():
proxy = _proxy(upstream_eof=asyncio.Event())
body = await _stream(proxy)
assert b"response.created" in await body.__anext__()
await body.aclose()
outcome = proxy._record_request_outcome.await_args.args[0]
assert outcome.status_code == 502
@pytest.mark.parametrize("frames_read", [1, 2, 3, 4, 5])
async def test_memory_filtered_hangup_before_the_client_gets_message_stop_is_a_failure(
frames_read,
):
"""Frames 1-4 come from the one upstream chunk; frame 5 is the held message_delta."""
proxy = _proxy(MESSAGE)
body = await _stream(proxy, **MEMORY_STREAM)
frames = [await body.__anext__() for _ in range(frames_read)]
assert b"message_start" in frames[0]
assert not any(b"message_stop" in frame for frame in frames)
await body.aclose()
outcome = proxy._record_request_outcome.await_args.args[0]
assert outcome.status_code == 502
async def test_memory_filtered_hangup_after_message_stop_is_forwarded_records_success():
proxy = _proxy(MESSAGE)
body = await _stream(proxy, **MEMORY_STREAM)
while b"message_stop" not in await body.__anext__():
pass
await body.aclose()
outcome = proxy._record_request_outcome.await_args.args[0]
assert outcome.status_code == 200
assert outcome.provider_input_tokens == 1_000
assert outcome.output_tokens == 5
async def test_malformed_event_after_a_valid_one_still_forwards_the_chunk():
"""Invalid UTF-8 ends the stream with an error, after the upstream bytes."""
valid = _event("response.output_text.delta", {"type": "response.output_text.delta"})
malformed = b'event: response.output_text.delta\ndata: {"delta": "\xff"}\n\n'
proxy = _proxy(START, valid + malformed)
body = await _stream(proxy)
frames = [frame async for frame in body]
assert frames[:2] == [START, valid + malformed]
assert b"error" in frames[2]
outcome = proxy._record_request_outcome.await_args.args[0]
assert outcome.status_code == 502
+1
View File
@@ -133,6 +133,7 @@ def test_request_runner_attributes_savings_with_handler_counters():
"tokens": 15,
"usd": 0.0,
"details": {"message_tokens_saved": 14, "tool_tokens_saved": 1},
"events": 1,
}
]
Generated
+401 -335
View File
@@ -23,7 +23,7 @@ resolution-markers = [
[manifest]
constraints = [
{ name = "aiohttp", specifier = ">=3.14.3" },
{ name = "aiohttp", specifier = ">=3.14.4" },
{ name = "cryptography", specifier = ">=50.0.0" },
{ name = "gitpython", specifier = ">=3.1.58" },
{ name = "langsmith", specifier = ">=0.9.0" },
@@ -88,7 +88,7 @@ wheels = [
[[package]]
name = "aiohttp"
version = "3.14.3"
version = "3.14.4"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "aiohappyeyeballs" },
@@ -101,126 +101,168 @@ dependencies = [
{ name = "typing-extensions", marker = "python_full_version < '3.13'" },
{ name = "yarl" },
]
sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
{ url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
{ url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
{ url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
{ url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
{ url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
{ url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
{ url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
{ url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
{ url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
{ url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
{ url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
{ url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
{ url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
{ url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
{ url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
{ url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
{ url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
{ url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
{ url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
{ url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
{ url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
{ url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
{ url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
{ url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
{ url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
{ url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
{ url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
{ url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
{ url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
{ url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
{ url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
{ url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
{ url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
{ url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
{ url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
{ url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
{ url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
{ url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
{ url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
{ url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
{ url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
{ url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
{ url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
{ url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
{ url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
{ url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
{ url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
{ url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
{ url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
{ url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
{ url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
{ url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
{ url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
{ url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
{ url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
{ url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
{ url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
{ url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
{ url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
{ url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
{ url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
{ url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
{ url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
{ url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
{ url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
{ url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
{ url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
{ url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
{ url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
{ url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
{ url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
{ url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
{ url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
{ url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
{ url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
{ url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
{ url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
{ url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
{ url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
{ url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
{ url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
{ url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
{ url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
{ url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
{ url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
{ url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
{ url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
{ url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
{ url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
{ url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
{ url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
{ url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
{ url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
{ url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
{ url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
{ url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
{ url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
{ url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
{ url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
{ url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
{ url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
{ url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
{ url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
{ url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
{ url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
{ url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
{ url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
{ url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
{ url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
{ url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
{ url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
{ url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
{ url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
{ url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
{ url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
{ url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
{ url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
{ url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
{ url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
{ url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
{ url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
{ url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
{ url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
{ url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
{ url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
{ url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
{ url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
{ url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
{ url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
{ url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
{ url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
{ url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
{ url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
{ url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
{ url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
{ url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
{ url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
{ url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
{ url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
{ url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
{ url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
{ url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
{ url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
{ url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
{ url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
{ url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
{ url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
{ url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
{ url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
{ url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
{ url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
{ url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
{ url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
{ url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
{ url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
{ url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
{ url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
{ url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
{ url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
{ url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
{ url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
{ url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
{ url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
{ url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
{ url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
{ url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
{ url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
{ url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
{ url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
{ url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
{ url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
{ url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
{ url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
{ url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
{ url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
{ url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
{ url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
{ url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
{ url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
{ url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
{ url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
{ url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
{ url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
{ url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
{ url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
{ url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
{ url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
{ url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
{ url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
{ url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
{ url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
{ url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
{ url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
{ url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
{ url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
{ url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
{ url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
{ url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
{ url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
{ url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
{ url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
{ url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
{ url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
{ url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
{ url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
{ url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
{ url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
{ url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
{ url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
{ url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
{ url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
{ url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
{ url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
{ url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
{ url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
{ url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
{ url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
{ url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
{ url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
{ url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
{ url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
{ url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
{ url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
{ url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
{ url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
{ url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
{ url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
{ url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
{ url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
{ url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
{ url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
{ url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
{ url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
{ url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
{ url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
{ url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
{ url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
{ url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
{ url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
{ url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
{ url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
{ url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
{ url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
{ url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
{ url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
{ url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
{ url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
{ url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
{ url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
{ url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
{ url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
{ url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
{ url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
{ url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
{ url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
{ url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
{ url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
{ url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
{ url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
{ url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
{ url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
{ url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
{ url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
{ url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
{ url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
{ url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
{ url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
{ url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
{ url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
{ url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
{ url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
{ url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
{ url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
{ url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
{ url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
{ url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
]
[[package]]
@@ -284,12 +326,12 @@ name = "any-llm-sdk"
version = "1.12.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "httpx", marker = "python_full_version >= '3.11'" },
{ name = "openai", marker = "python_full_version >= '3.11'" },
{ name = "openresponses-types", marker = "python_full_version >= '3.11'" },
{ name = "pydantic", marker = "python_full_version >= '3.11'" },
{ name = "rich", marker = "python_full_version >= '3.11'" },
{ name = "typing-extensions", marker = "python_full_version >= '3.11'" },
{ name = "httpx" },
{ name = "openai" },
{ name = "openresponses-types" },
{ name = "pydantic" },
{ name = "rich" },
{ name = "typing-extensions" },
]
sdist = { url = "https://files.pythonhosted.org/packages/21/d5/21ef27d031b72f0054ba0015a66cc1f10cda9410e4a3acb6e795d848ad0d/any_llm_sdk-1.12.1.tar.gz", hash = "sha256:76e043fcaa56fccfb375a908511869dc7dbf393dd97a82d06bb764d8201724e8", size = 152078, upload-time = "2026-03-18T13:13:01.735Z" }
wheels = [
@@ -686,7 +728,7 @@ name = "coloredlogs"
version = "15.0.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "humanfriendly", marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "humanfriendly" },
]
sdist = { url = "https://files.pythonhosted.org/packages/cc/c7/eed8f27100517e8c0e6b923d5f0845d0cb99763da6fdee00478f91db7325/coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0", size = 278520, upload-time = "2021-06-11T10:22:45.202Z" }
wheels = [
@@ -698,7 +740,7 @@ name = "colorlog"
version = "6.10.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "colorama", marker = "python_full_version >= '3.13' and sys_platform == 'win32'" },
{ name = "colorama", marker = "sys_platform == 'win32'" },
]
sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }
wheels = [
@@ -885,7 +927,7 @@ name = "cuda-bindings"
version = "13.3.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "cuda-pathfinder" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/a9/21/8464d133752951c154feafb3b65c297e7d80f301183d220bec4c830f1441/cuda_bindings-13.3.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:120fcc53d57903df529c3486962c56528cba5b7d6c57c99537320ed9922c8b86", size = 6073403, upload-time = "2026-05-29T23:11:36.22Z" },
@@ -920,43 +962,43 @@ wheels = [
[package.optional-dependencies]
cublas = [
{ name = "nvidia-cublas", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cuda-nvrtc", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cublas", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
{ name = "nvidia-cuda-nvrtc", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
cudart = [
{ name = "nvidia-cuda-runtime", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cuda-runtime", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
cufft = [
{ name = "nvidia-cufft", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cufft", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
{ name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
cufile = [
{ name = "nvidia-cufile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cufile", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
cupti = [
{ name = "nvidia-cuda-cupti", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cuda-cupti", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
curand = [
{ name = "nvidia-curand", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-curand", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
cusolver = [
{ name = "nvidia-cublas", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cusolver", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cublas", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
{ name = "nvidia-cusolver", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
{ name = "nvidia-cusparse", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
{ name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
cusparse = [
{ name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cusparse", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
{ name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
nvjitlink = [
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
nvrtc = [
{ name = "nvidia-cuda-nvrtc", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-cuda-nvrtc", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
nvtx = [
{ name = "nvidia-nvtx", marker = "(python_full_version < '3.11' and platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
{ name = "nvidia-nvtx", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
]
[[package]]
@@ -1051,7 +1093,7 @@ name = "exceptiongroup"
version = "1.3.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "typing-extensions", marker = "python_full_version < '3.11'" },
{ name = "typing-extensions" },
]
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 = [
@@ -1079,18 +1121,18 @@ name = "fastembed"
version = "0.8.0"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "huggingface-hub", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "loguru", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "mmh3", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "huggingface-hub" },
{ name = "loguru" },
{ name = "mmh3" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.11' and python_full_version < '3.14') or (python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.11' and sys_platform != 'darwin') or (platform_machine == 'x86_64' and sys_platform == 'darwin')" },
{ name = "onnxruntime", version = "1.26.0", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "pillow", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "py-rust-stemmers", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "requests", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "tokenizers", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "tqdm", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "pillow" },
{ name = "py-rust-stemmers" },
{ name = "requests" },
{ name = "tokenizers" },
{ name = "tqdm" },
]
sdist = { url = "https://files.pythonhosted.org/packages/26/25/58865e36b6e8a9a0d0ff905b5601aa30db97956327c0df42ec4ed6accc21/fastembed-0.8.0.tar.gz", hash = "sha256:75966edfa8b006ee78514c726bd7f6a50721dadc89305279052be9db72fd53e8", size = 75115, upload-time = "2026-03-23T16:34:41.699Z" }
wheels = [
@@ -1468,7 +1510,7 @@ name = "gunicorn"
version = "26.0.0"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "packaging", marker = "python_full_version < '3.11' or sys_platform != 'win32'" },
{ name = "packaging" },
]
sdist = { url = "https://files.pythonhosted.org/packages/6d/b7/a4a3f632f823e432ce6bc65f62961b7980c898c77f075a2f7118cb3846fe/gunicorn-26.0.0.tar.gz", hash = "sha256:ca9346f85e3a4aeeb64d491045c16b9a35647abd37ea15efe53080eb8b090baf", size = 727286, upload-time = "2026-05-05T06:38:25.529Z" }
wheels = [
@@ -1771,7 +1813,7 @@ requires-dist = [
{ name = "datasets", marker = "extra == 'voice-train'", specifier = ">=5.0.1" },
{ name = "fastapi", marker = "extra == 'dev'", specifier = ">=0.100.0" },
{ name = "fastapi", marker = "extra == 'proxy'", specifier = ">=0.100.0" },
{ name = "fastembed", marker = "(python_full_version < '3.14' and extra == 'relevance') or (platform_machine != 'x86_64' and extra == 'relevance') or (sys_platform != 'darwin' and extra == 'relevance')", specifier = ">=0.4.0" },
{ name = "fastembed", marker = "(python_full_version < '3.14' and extra == 'relevance') or (platform_machine != 'x86_64' and extra == 'relevance') or (sys_platform != 'darwin' and extra == 'relevance')", specifier = ">=0.6.0" },
{ name = "gunicorn", marker = "sys_platform != 'win32' and extra == 'proxy-prod'", specifier = ">=21.0.0" },
{ name = "headroom-ai", extras = ["proxy"], marker = "extra == 'proxy-prod'" },
{ name = "headroom-ai", extras = ["proxy", "code", "ml", "memory", "relevance", "image", "reports", "otel", "evals", "voice", "html", "mcp", "spreadsheet"], marker = "extra == 'all'" },
@@ -1998,7 +2040,7 @@ name = "humanfriendly"
version = "10.0"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "pyreadline3", marker = "python_full_version < '3.11' and sys_platform == 'win32'" },
{ name = "pyreadline3", marker = "sys_platform == 'win32'" },
]
sdist = { url = "https://files.pythonhosted.org/packages/cc/3f/2c29224acb2e2df4d2046e4c73ee2662023c58ff5b113c4c1adac0886c43/humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc", size = 360702, upload-time = "2021-09-17T21:40:43.31Z" }
wheels = [
@@ -2650,12 +2692,12 @@ name = "magika"
version = "0.6.2"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "click", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "click" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.11' and python_full_version < '3.14') or (python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.11' and sys_platform != 'darwin') or (platform_machine == 'x86_64' and sys_platform == 'darwin')" },
{ name = "onnxruntime", version = "1.26.0", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "python-dotenv", marker = "python_full_version < '3.14' or platform_machine != 'x86_64' or sys_platform != 'darwin'" },
{ name = "python-dotenv" },
]
sdist = { url = "https://files.pythonhosted.org/packages/fe/b6/8fdd991142ad3e037179a494b153f463024e5a211ef3ad948b955c26b4de/magika-0.6.2.tar.gz", hash = "sha256:37eb6ae8020f6e68f231bc06052c0a0cbe8e6fa27492db345e8dc867dbceb067", size = 3036634, upload-time = "2025-05-02T14:54:18.88Z" }
wheels = [
@@ -3423,7 +3465,7 @@ name = "nvidia-cublas"
version = "13.1.1.3"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "nvidia-cuda-nvrtc", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-cuda-nvrtc" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" },
@@ -3462,7 +3504,7 @@ name = "nvidia-cudnn-cu13"
version = "9.20.0.48"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-cublas" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" },
@@ -3474,7 +3516,7 @@ name = "nvidia-cufft"
version = "12.0.0.61"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-nvjitlink" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
@@ -3504,9 +3546,9 @@ name = "nvidia-cusolver"
version = "12.0.4.66"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-cublas" },
{ name = "nvidia-cusparse" },
{ name = "nvidia-nvjitlink" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
@@ -3518,7 +3560,7 @@ name = "nvidia-cusparse"
version = "12.6.3.3"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
{ name = "nvidia-nvjitlink" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
@@ -3588,8 +3630,8 @@ name = "omegaconf"
version = "2.3.0"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "antlr4-python3-runtime", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "pyyaml", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "antlr4-python3-runtime" },
{ name = "pyyaml" },
]
sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" }
wheels = [
@@ -3607,13 +3649,13 @@ resolution-markers = [
"python_full_version < '3.11'",
]
dependencies = [
{ name = "coloredlogs", marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "flatbuffers", marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "coloredlogs" },
{ name = "flatbuffers" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11' or python_full_version >= '3.14'" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11' and python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin'" },
{ name = "packaging", marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "protobuf", marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "sympy", marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.14' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "packaging" },
{ name = "protobuf" },
{ name = "sympy" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/35/d6/311b1afea060015b56c742f3531168c1644650767f27ef40062569960587/onnxruntime-1.23.2-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:a7730122afe186a784660f6ec5807138bf9d792fa1df76556b27307ea9ebcbe3", size = 17195934, upload-time = "2025-10-27T23:06:14.143Z" },
@@ -3659,10 +3701,10 @@ resolution-markers = [
"(python_full_version == '3.11.*' and platform_machine != 'x86_64' and sys_platform == 'darwin') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')",
]
dependencies = [
{ name = "flatbuffers", marker = "(python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "packaging", marker = "(python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "protobuf", marker = "(python_full_version >= '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and sys_platform != 'darwin')" },
{ name = "flatbuffers" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" } },
{ name = "packaging" },
{ name = "protobuf" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/d4/81/29a9eb470994a75eb7b3ccf32be314d7c66675a00ac7b50294816cc2db27/onnxruntime-1.26.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ee1109ef4ef27cad90e823399e61e03b3c6c7bfe0fb820b4baf3678c15be8b3c", size = 18005108, upload-time = "2026-05-08T19:08:11.728Z" },
@@ -3746,7 +3788,7 @@ name = "openresponses-types"
version = "2.3.0.post1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "pydantic", marker = "python_full_version >= '3.11'" },
{ name = "pydantic" },
]
sdist = { url = "https://files.pythonhosted.org/packages/d9/26/b612c3215f5599714fa94d63eb5ee59b4eb66dbdeeaf86bb4d848359484d/openresponses_types-2.3.0.post1.tar.gz", hash = "sha256:11b8896d3621d2ac2439f6ff106f34ddcb1bbd517c317a6c852a9df2e98a0753", size = 19254, upload-time = "2026-01-22T20:02:03.933Z" }
wheels = [
@@ -4017,10 +4059,10 @@ resolution-markers = [
"python_full_version < '3.11'",
]
dependencies = [
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "python-dateutil", marker = "python_full_version < '3.11'" },
{ name = "pytz", marker = "python_full_version < '3.11'" },
{ name = "tzdata", marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" } },
{ name = "python-dateutil" },
{ name = "pytz" },
{ name = "tzdata" },
]
sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
wheels = [
@@ -4096,9 +4138,9 @@ resolution-markers = [
"python_full_version == '3.11.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
]
dependencies = [
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11'" },
{ name = "python-dateutil", marker = "python_full_version >= '3.11'" },
{ name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" } },
{ name = "python-dateutil" },
{ name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
]
sdist = { url = "https://files.pythonhosted.org/packages/de/da/b1dc0481ab8d55d0f46e343cfe67d4551a0e14fcee52bd38ca1bd73258d8/pandas-3.0.0.tar.gz", hash = "sha256:0facf7e87d38f721f0af46fe70d97373a37701b1c09f7ed7aeeb292ade5c050f", size = 4633005, upload-time = "2026-01-21T15:52:04.726Z" }
wheels = [
@@ -5022,17 +5064,17 @@ name = "rapidocr"
version = "3.8.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "colorlog", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "omegaconf", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "opencv-python", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "pillow", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "pyclipper", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "pyyaml", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "requests", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "shapely", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "six", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "tqdm", marker = "(python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin')" },
{ name = "colorlog" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" } },
{ name = "omegaconf" },
{ name = "opencv-python" },
{ name = "pillow" },
{ name = "pyclipper" },
{ name = "pyyaml" },
{ name = "requests" },
{ name = "shapely" },
{ name = "six" },
{ name = "tqdm" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/ea/4a/fa521d947f0fc7bb304bf11bec4cb66266bd81494588b4cb48dc01001719/rapidocr-3.8.1-py3-none-any.whl", hash = "sha256:650044b1fbce9e6bae5cae462dcf8be754cde11e2f23fc51f65dcc08deae2c46", size = 15080319, upload-time = "2026-04-11T07:13:22.56Z" },
@@ -5043,17 +5085,17 @@ name = "rapidocr-onnxruntime"
version = "1.4.4"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11' or python_full_version >= '3.13'" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
{ name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version < '3.13' and platform_machine == 'x86_64' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform != 'darwin')" },
{ name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version < '3.11' and platform_machine != 'x86_64') or (python_full_version >= '3.13' and platform_machine != 'x86_64') or (python_full_version < '3.11' and sys_platform != 'darwin') or (python_full_version >= '3.13' and sys_platform != 'darwin') or (platform_machine == 'x86_64' and sys_platform == 'darwin')" },
{ name = "onnxruntime", version = "1.26.0", source = { registry = "https://pypi.org/simple/" }, marker = "(python_full_version >= '3.11' and python_full_version < '3.13' and platform_machine != 'x86_64') or (python_full_version >= '3.11' and python_full_version < '3.13' and sys_platform != 'darwin')" },
{ name = "opencv-python", marker = "python_full_version < '3.13'" },
{ name = "pillow", marker = "python_full_version < '3.13'" },
{ name = "pyclipper", marker = "python_full_version < '3.13'" },
{ name = "pyyaml", marker = "python_full_version < '3.13'" },
{ name = "shapely", marker = "python_full_version < '3.13'" },
{ name = "six", marker = "python_full_version < '3.13'" },
{ name = "tqdm", marker = "python_full_version < '3.13'" },
{ name = "opencv-python" },
{ name = "pillow" },
{ name = "pyclipper" },
{ name = "pyyaml" },
{ name = "shapely" },
{ name = "six" },
{ name = "tqdm" },
]
wheels = [
{ url = "https://files.pythonhosted.org/packages/ba/12/1e5497183bdbe782dbb91bad1d0d2297dba4d2831b2652657f7517bfc6df/rapidocr_onnxruntime-1.4.4-py3-none-any.whl", hash = "sha256:971d7d5f223a7a808662229df1ef69893809d8457d834e6373d3854bc1782cbf", size = 14915192, upload-time = "2025-01-17T01:48:25.104Z" },
@@ -5437,10 +5479,10 @@ resolution-markers = [
"python_full_version < '3.11'",
]
dependencies = [
{ name = "joblib", marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "threadpoolctl", marker = "python_full_version < '3.11'" },
{ name = "joblib" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" } },
{ name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple/" } },
{ name = "threadpoolctl" },
]
sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" }
wheels = [
@@ -5499,10 +5541,10 @@ resolution-markers = [
"python_full_version == '3.11.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
]
dependencies = [
{ name = "joblib", marker = "python_full_version >= '3.11'" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11'" },
{ name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11'" },
{ name = "threadpoolctl", marker = "python_full_version >= '3.11'" },
{ name = "joblib" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" } },
{ name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple/" } },
{ name = "threadpoolctl" },
]
sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" }
wheels = [
@@ -5552,7 +5594,7 @@ resolution-markers = [
"python_full_version < '3.11'",
]
dependencies = [
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" } },
]
sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
wheels = [
@@ -5626,7 +5668,7 @@ resolution-markers = [
"python_full_version == '3.11.*' and platform_machine == 'x86_64' and sys_platform == 'darwin'",
]
dependencies = [
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11'" },
{ name = "numpy", version = "2.4.1", source = { registry = "https://pypi.org/simple/" } },
]
sdist = { url = "https://files.pythonhosted.org/packages/56/3e/9cca699f3486ce6bc12ff46dc2031f1ec8eb9ccc9a320fdaf925f1417426/scipy-1.17.0.tar.gz", hash = "sha256:2591060c8e648d8b96439e111ac41fd8342fdeff1876be2e19dea3fe8930454e", size = 30396830, upload-time = "2026-01-10T21:34:23.009Z" }
wheels = [
@@ -6854,128 +6896,152 @@ wheels = [
[[package]]
name = "yarl"
version = "1.22.0"
version = "1.25.1"
source = { registry = "https://pypi.org/simple/" }
dependencies = [
{ name = "idna" },
{ name = "multidict" },
{ name = "propcache" },
]
sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" }
sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/43/a2204825342f37c337f5edb6637040fa14e365b2fcc2346960201d457579/yarl-1.22.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c7bd6683587567e5a49ee6e336e0612bec8329be1b7d4c8af5687dcdeb67ee1e", size = 140517, upload-time = "2025-10-06T14:08:42.494Z" },
{ url = "https://files.pythonhosted.org/packages/44/6f/674f3e6f02266428c56f704cd2501c22f78e8b2eeb23f153117cc86fb28a/yarl-1.22.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5cdac20da754f3a723cceea5b3448e1a2074866406adeb4ef35b469d089adb8f", size = 93495, upload-time = "2025-10-06T14:08:46.2Z" },
{ url = "https://files.pythonhosted.org/packages/b8/12/5b274d8a0f30c07b91b2f02cba69152600b47830fcfb465c108880fcee9c/yarl-1.22.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:07a524d84df0c10f41e3ee918846e1974aba4ec017f990dc735aad487a0bdfdf", size = 94400, upload-time = "2025-10-06T14:08:47.855Z" },
{ url = "https://files.pythonhosted.org/packages/e2/7f/df1b6949b1fa1aa9ff6de6e2631876ad4b73c4437822026e85d8acb56bb1/yarl-1.22.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1b329cb8146d7b736677a2440e422eadd775d1806a81db2d4cded80a48efc1a", size = 347545, upload-time = "2025-10-06T14:08:49.683Z" },
{ url = "https://files.pythonhosted.org/packages/84/09/f92ed93bd6cd77872ab6c3462df45ca45cd058d8f1d0c9b4f54c1704429f/yarl-1.22.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:75976c6945d85dbb9ee6308cd7ff7b1fb9409380c82d6119bd778d8fcfe2931c", size = 319598, upload-time = "2025-10-06T14:08:51.215Z" },
{ url = "https://files.pythonhosted.org/packages/c3/97/ac3f3feae7d522cf7ccec3d340bb0b2b61c56cb9767923df62a135092c6b/yarl-1.22.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:80ddf7a5f8c86cb3eb4bc9028b07bbbf1f08a96c5c0bc1244be5e8fefcb94147", size = 363893, upload-time = "2025-10-06T14:08:53.144Z" },
{ url = "https://files.pythonhosted.org/packages/06/49/f3219097403b9c84a4d079b1d7bda62dd9b86d0d6e4428c02d46ab2c77fc/yarl-1.22.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d332fc2e3c94dad927f2112395772a4e4fedbcf8f80efc21ed7cdfae4d574fdb", size = 371240, upload-time = "2025-10-06T14:08:55.036Z" },
{ url = "https://files.pythonhosted.org/packages/35/9f/06b765d45c0e44e8ecf0fe15c9eacbbde342bb5b7561c46944f107bfb6c3/yarl-1.22.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cf71bf877efeac18b38d3930594c0948c82b64547c1cf420ba48722fe5509f6", size = 346965, upload-time = "2025-10-06T14:08:56.722Z" },
{ url = "https://files.pythonhosted.org/packages/c5/69/599e7cea8d0fcb1694323b0db0dda317fa3162f7b90166faddecf532166f/yarl-1.22.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:663e1cadaddae26be034a6ab6072449a8426ddb03d500f43daf952b74553bba0", size = 342026, upload-time = "2025-10-06T14:08:58.563Z" },
{ url = "https://files.pythonhosted.org/packages/95/6f/9dfd12c8bc90fea9eab39832ee32ea48f8e53d1256252a77b710c065c89f/yarl-1.22.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6dcbb0829c671f305be48a7227918cfcd11276c2d637a8033a99a02b67bf9eda", size = 335637, upload-time = "2025-10-06T14:09:00.506Z" },
{ url = "https://files.pythonhosted.org/packages/57/2e/34c5b4eb9b07e16e873db5b182c71e5f06f9b5af388cdaa97736d79dd9a6/yarl-1.22.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f0d97c18dfd9a9af4490631905a3f131a8e4c9e80a39353919e2cfed8f00aedc", size = 359082, upload-time = "2025-10-06T14:09:01.936Z" },
{ url = "https://files.pythonhosted.org/packages/31/71/fa7e10fb772d273aa1f096ecb8ab8594117822f683bab7d2c5a89914c92a/yarl-1.22.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:437840083abe022c978470b942ff832c3940b2ad3734d424b7eaffcd07f76737", size = 357811, upload-time = "2025-10-06T14:09:03.445Z" },
{ url = "https://files.pythonhosted.org/packages/26/da/11374c04e8e1184a6a03cf9c8f5688d3e5cec83ed6f31ad3481b3207f709/yarl-1.22.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a899cbd98dce6f5d8de1aad31cb712ec0a530abc0a86bd6edaa47c1090138467", size = 351223, upload-time = "2025-10-06T14:09:05.401Z" },
{ url = "https://files.pythonhosted.org/packages/82/8f/e2d01f161b0c034a30410e375e191a5d27608c1f8693bab1a08b089ca096/yarl-1.22.0-cp310-cp310-win32.whl", hash = "sha256:595697f68bd1f0c1c159fcb97b661fc9c3f5db46498043555d04805430e79bea", size = 82118, upload-time = "2025-10-06T14:09:11.148Z" },
{ url = "https://files.pythonhosted.org/packages/62/46/94c76196642dbeae634c7a61ba3da88cd77bed875bf6e4a8bed037505aa6/yarl-1.22.0-cp310-cp310-win_amd64.whl", hash = "sha256:cb95a9b1adaa48e41815a55ae740cfda005758104049a640a398120bf02515ca", size = 86852, upload-time = "2025-10-06T14:09:12.958Z" },
{ url = "https://files.pythonhosted.org/packages/af/af/7df4f179d3b1a6dcb9a4bd2ffbc67642746fcafdb62580e66876ce83fff4/yarl-1.22.0-cp310-cp310-win_arm64.whl", hash = "sha256:b85b982afde6df99ecc996990d4ad7ccbdbb70e2a4ba4de0aecde5922ba98a0b", size = 82012, upload-time = "2025-10-06T14:09:14.664Z" },
{ url = "https://files.pythonhosted.org/packages/4d/27/5ab13fc84c76a0250afd3d26d5936349a35be56ce5785447d6c423b26d92/yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511", size = 141607, upload-time = "2025-10-06T14:09:16.298Z" },
{ url = "https://files.pythonhosted.org/packages/6a/a1/d065d51d02dc02ce81501d476b9ed2229d9a990818332242a882d5d60340/yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6", size = 94027, upload-time = "2025-10-06T14:09:17.786Z" },
{ url = "https://files.pythonhosted.org/packages/c1/da/8da9f6a53f67b5106ffe902c6fa0164e10398d4e150d85838b82f424072a/yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028", size = 94963, upload-time = "2025-10-06T14:09:19.662Z" },
{ url = "https://files.pythonhosted.org/packages/68/fe/2c1f674960c376e29cb0bec1249b117d11738db92a6ccc4a530b972648db/yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d", size = 368406, upload-time = "2025-10-06T14:09:21.402Z" },
{ url = "https://files.pythonhosted.org/packages/95/26/812a540e1c3c6418fec60e9bbd38e871eaba9545e94fa5eff8f4a8e28e1e/yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503", size = 336581, upload-time = "2025-10-06T14:09:22.98Z" },
{ url = "https://files.pythonhosted.org/packages/0b/f5/5777b19e26fdf98563985e481f8be3d8a39f8734147a6ebf459d0dab5a6b/yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65", size = 388924, upload-time = "2025-10-06T14:09:24.655Z" },
{ url = "https://files.pythonhosted.org/packages/86/08/24bd2477bd59c0bbd994fe1d93b126e0472e4e3df5a96a277b0a55309e89/yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e", size = 392890, upload-time = "2025-10-06T14:09:26.617Z" },
{ url = "https://files.pythonhosted.org/packages/46/00/71b90ed48e895667ecfb1eaab27c1523ee2fa217433ed77a73b13205ca4b/yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d", size = 365819, upload-time = "2025-10-06T14:09:28.544Z" },
{ url = "https://files.pythonhosted.org/packages/30/2d/f715501cae832651d3282387c6a9236cd26bd00d0ff1e404b3dc52447884/yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7", size = 363601, upload-time = "2025-10-06T14:09:30.568Z" },
{ url = "https://files.pythonhosted.org/packages/f8/f9/a678c992d78e394e7126ee0b0e4e71bd2775e4334d00a9278c06a6cce96a/yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967", size = 358072, upload-time = "2025-10-06T14:09:32.528Z" },
{ url = "https://files.pythonhosted.org/packages/2c/d1/b49454411a60edb6fefdcad4f8e6dbba7d8019e3a508a1c5836cba6d0781/yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed", size = 385311, upload-time = "2025-10-06T14:09:34.634Z" },
{ url = "https://files.pythonhosted.org/packages/87/e5/40d7a94debb8448c7771a916d1861d6609dddf7958dc381117e7ba36d9e8/yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6", size = 381094, upload-time = "2025-10-06T14:09:36.268Z" },
{ url = "https://files.pythonhosted.org/packages/35/d8/611cc282502381ad855448643e1ad0538957fc82ae83dfe7762c14069e14/yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e", size = 370944, upload-time = "2025-10-06T14:09:37.872Z" },
{ url = "https://files.pythonhosted.org/packages/2d/df/fadd00fb1c90e1a5a8bd731fa3d3de2e165e5a3666a095b04e31b04d9cb6/yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca", size = 81804, upload-time = "2025-10-06T14:09:39.359Z" },
{ url = "https://files.pythonhosted.org/packages/b5/f7/149bb6f45f267cb5c074ac40c01c6b3ea6d8a620d34b337f6321928a1b4d/yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b", size = 86858, upload-time = "2025-10-06T14:09:41.068Z" },
{ url = "https://files.pythonhosted.org/packages/2b/13/88b78b93ad3f2f0b78e13bfaaa24d11cbc746e93fe76d8c06bf139615646/yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376", size = 81637, upload-time = "2025-10-06T14:09:42.712Z" },
{ url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" },
{ url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" },
{ url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" },
{ url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" },
{ url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" },
{ url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" },
{ url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" },
{ url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" },
{ url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" },
{ url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" },
{ url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" },
{ url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" },
{ url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" },
{ url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" },
{ url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" },
{ url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" },
{ url = "https://files.pythonhosted.org/packages/ea/f3/d67de7260456ee105dc1d162d43a019ecad6b91e2f51809d6cddaa56690e/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53", size = 139980, upload-time = "2025-10-06T14:10:14.601Z" },
{ url = "https://files.pythonhosted.org/packages/01/88/04d98af0b47e0ef42597b9b28863b9060bb515524da0a65d5f4db160b2d5/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a", size = 93424, upload-time = "2025-10-06T14:10:16.115Z" },
{ url = "https://files.pythonhosted.org/packages/18/91/3274b215fd8442a03975ce6bee5fe6aa57a8326b29b9d3d56234a1dca244/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c", size = 93821, upload-time = "2025-10-06T14:10:17.993Z" },
{ url = "https://files.pythonhosted.org/packages/61/3a/caf4e25036db0f2da4ca22a353dfeb3c9d3c95d2761ebe9b14df8fc16eb0/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601", size = 373243, upload-time = "2025-10-06T14:10:19.44Z" },
{ url = "https://files.pythonhosted.org/packages/6e/9e/51a77ac7516e8e7803b06e01f74e78649c24ee1021eca3d6a739cb6ea49c/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a", size = 342361, upload-time = "2025-10-06T14:10:21.124Z" },
{ url = "https://files.pythonhosted.org/packages/d4/f8/33b92454789dde8407f156c00303e9a891f1f51a0330b0fad7c909f87692/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df", size = 387036, upload-time = "2025-10-06T14:10:22.902Z" },
{ url = "https://files.pythonhosted.org/packages/d9/9a/c5db84ea024f76838220280f732970aa4ee154015d7f5c1bfb60a267af6f/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2", size = 397671, upload-time = "2025-10-06T14:10:24.523Z" },
{ url = "https://files.pythonhosted.org/packages/11/c9/cd8538dc2e7727095e0c1d867bad1e40c98f37763e6d995c1939f5fdc7b1/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b", size = 377059, upload-time = "2025-10-06T14:10:26.406Z" },
{ url = "https://files.pythonhosted.org/packages/a1/b9/ab437b261702ced75122ed78a876a6dec0a1b0f5e17a4ac7a9a2482d8abe/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273", size = 365356, upload-time = "2025-10-06T14:10:28.461Z" },
{ url = "https://files.pythonhosted.org/packages/b2/9d/8e1ae6d1d008a9567877b08f0ce4077a29974c04c062dabdb923ed98e6fe/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a", size = 361331, upload-time = "2025-10-06T14:10:30.541Z" },
{ url = "https://files.pythonhosted.org/packages/ca/5a/09b7be3905962f145b73beb468cdd53db8aa171cf18c80400a54c5b82846/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d", size = 382590, upload-time = "2025-10-06T14:10:33.352Z" },
{ url = "https://files.pythonhosted.org/packages/aa/7f/59ec509abf90eda5048b0bc3e2d7b5099dffdb3e6b127019895ab9d5ef44/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02", size = 385316, upload-time = "2025-10-06T14:10:35.034Z" },
{ url = "https://files.pythonhosted.org/packages/e5/84/891158426bc8036bfdfd862fabd0e0fa25df4176ec793e447f4b85cf1be4/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67", size = 374431, upload-time = "2025-10-06T14:10:37.76Z" },
{ url = "https://files.pythonhosted.org/packages/bb/49/03da1580665baa8bef5e8ed34c6df2c2aca0a2f28bf397ed238cc1bbc6f2/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95", size = 81555, upload-time = "2025-10-06T14:10:39.649Z" },
{ url = "https://files.pythonhosted.org/packages/9a/ee/450914ae11b419eadd067c6183ae08381cfdfcb9798b90b2b713bbebddda/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d", size = 86965, upload-time = "2025-10-06T14:10:41.313Z" },
{ url = "https://files.pythonhosted.org/packages/98/4d/264a01eae03b6cf629ad69bae94e3b0e5344741e929073678e84bf7a3e3b/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b", size = 81205, upload-time = "2025-10-06T14:10:43.167Z" },
{ url = "https://files.pythonhosted.org/packages/88/fc/6908f062a2f77b5f9f6d69cecb1747260831ff206adcbc5b510aff88df91/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10", size = 146209, upload-time = "2025-10-06T14:10:44.643Z" },
{ url = "https://files.pythonhosted.org/packages/65/47/76594ae8eab26210b4867be6f49129861ad33da1f1ebdf7051e98492bf62/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3", size = 95966, upload-time = "2025-10-06T14:10:46.554Z" },
{ url = "https://files.pythonhosted.org/packages/ab/ce/05e9828a49271ba6b5b038b15b3934e996980dd78abdfeb52a04cfb9467e/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9", size = 97312, upload-time = "2025-10-06T14:10:48.007Z" },
{ url = "https://files.pythonhosted.org/packages/d1/c5/7dffad5e4f2265b29c9d7ec869c369e4223166e4f9206fc2243ee9eea727/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f", size = 361967, upload-time = "2025-10-06T14:10:49.997Z" },
{ url = "https://files.pythonhosted.org/packages/50/b2/375b933c93a54bff7fc041e1a6ad2c0f6f733ffb0c6e642ce56ee3b39970/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0", size = 323949, upload-time = "2025-10-06T14:10:52.004Z" },
{ url = "https://files.pythonhosted.org/packages/66/50/bfc2a29a1d78644c5a7220ce2f304f38248dc94124a326794e677634b6cf/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e", size = 361818, upload-time = "2025-10-06T14:10:54.078Z" },
{ url = "https://files.pythonhosted.org/packages/46/96/f3941a46af7d5d0f0498f86d71275696800ddcdd20426298e572b19b91ff/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708", size = 372626, upload-time = "2025-10-06T14:10:55.767Z" },
{ url = "https://files.pythonhosted.org/packages/c1/42/8b27c83bb875cd89448e42cd627e0fb971fa1675c9ec546393d18826cb50/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f", size = 341129, upload-time = "2025-10-06T14:10:57.985Z" },
{ url = "https://files.pythonhosted.org/packages/49/36/99ca3122201b382a3cf7cc937b95235b0ac944f7e9f2d5331d50821ed352/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d", size = 346776, upload-time = "2025-10-06T14:10:59.633Z" },
{ url = "https://files.pythonhosted.org/packages/85/b4/47328bf996acd01a4c16ef9dcd2f59c969f495073616586f78cd5f2efb99/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8", size = 334879, upload-time = "2025-10-06T14:11:01.454Z" },
{ url = "https://files.pythonhosted.org/packages/c2/ad/b77d7b3f14a4283bffb8e92c6026496f6de49751c2f97d4352242bba3990/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5", size = 350996, upload-time = "2025-10-06T14:11:03.452Z" },
{ url = "https://files.pythonhosted.org/packages/81/c8/06e1d69295792ba54d556f06686cbd6a7ce39c22307100e3fb4a2c0b0a1d/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f", size = 356047, upload-time = "2025-10-06T14:11:05.115Z" },
{ url = "https://files.pythonhosted.org/packages/4b/b8/4c0e9e9f597074b208d18cef227d83aac36184bfbc6eab204ea55783dbc5/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62", size = 342947, upload-time = "2025-10-06T14:11:08.137Z" },
{ url = "https://files.pythonhosted.org/packages/e0/e5/11f140a58bf4c6ad7aca69a892bff0ee638c31bea4206748fc0df4ebcb3a/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03", size = 86943, upload-time = "2025-10-06T14:11:10.284Z" },
{ url = "https://files.pythonhosted.org/packages/31/74/8b74bae38ed7fe6793d0c15a0c8207bbb819cf287788459e5ed230996cdd/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249", size = 93715, upload-time = "2025-10-06T14:11:11.739Z" },
{ url = "https://files.pythonhosted.org/packages/69/66/991858aa4b5892d57aef7ee1ba6b4d01ec3b7eb3060795d34090a3ca3278/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b", size = 83857, upload-time = "2025-10-06T14:11:13.586Z" },
{ url = "https://files.pythonhosted.org/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload-time = "2025-10-06T14:11:15.465Z" },
{ url = "https://files.pythonhosted.org/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload-time = "2025-10-06T14:11:17.106Z" },
{ url = "https://files.pythonhosted.org/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload-time = "2025-10-06T14:11:19.064Z" },
{ url = "https://files.pythonhosted.org/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload-time = "2025-10-06T14:11:20.996Z" },
{ url = "https://files.pythonhosted.org/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload-time = "2025-10-06T14:11:22.847Z" },
{ url = "https://files.pythonhosted.org/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload-time = "2025-10-06T14:11:24.889Z" },
{ url = "https://files.pythonhosted.org/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload-time = "2025-10-06T14:11:27.307Z" },
{ url = "https://files.pythonhosted.org/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload-time = "2025-10-06T14:11:29.387Z" },
{ url = "https://files.pythonhosted.org/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload-time = "2025-10-06T14:11:31.423Z" },
{ url = "https://files.pythonhosted.org/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload-time = "2025-10-06T14:11:33.055Z" },
{ url = "https://files.pythonhosted.org/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload-time = "2025-10-06T14:11:35.136Z" },
{ url = "https://files.pythonhosted.org/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload-time = "2025-10-06T14:11:37.094Z" },
{ url = "https://files.pythonhosted.org/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload-time = "2025-10-06T14:11:38.83Z" },
{ url = "https://files.pythonhosted.org/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload-time = "2025-10-06T14:11:40.624Z" },
{ url = "https://files.pythonhosted.org/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload-time = "2025-10-06T14:11:42.578Z" },
{ url = "https://files.pythonhosted.org/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload-time = "2025-10-06T14:11:44.863Z" },
{ url = "https://files.pythonhosted.org/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload-time = "2025-10-06T14:11:46.796Z" },
{ url = "https://files.pythonhosted.org/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload-time = "2025-10-06T14:11:48.845Z" },
{ url = "https://files.pythonhosted.org/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload-time = "2025-10-06T14:11:50.897Z" },
{ url = "https://files.pythonhosted.org/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload-time = "2025-10-06T14:11:52.549Z" },
{ url = "https://files.pythonhosted.org/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload-time = "2025-10-06T14:11:54.225Z" },
{ url = "https://files.pythonhosted.org/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload-time = "2025-10-06T14:11:56.069Z" },
{ url = "https://files.pythonhosted.org/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload-time = "2025-10-06T14:11:58.783Z" },
{ url = "https://files.pythonhosted.org/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload-time = "2025-10-06T14:12:00.686Z" },
{ url = "https://files.pythonhosted.org/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload-time = "2025-10-06T14:12:02.628Z" },
{ url = "https://files.pythonhosted.org/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload-time = "2025-10-06T14:12:04.871Z" },
{ url = "https://files.pythonhosted.org/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload-time = "2025-10-06T14:12:06.624Z" },
{ url = "https://files.pythonhosted.org/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload-time = "2025-10-06T14:12:08.362Z" },
{ url = "https://files.pythonhosted.org/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload-time = "2025-10-06T14:12:10.994Z" },
{ url = "https://files.pythonhosted.org/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload-time = "2025-10-06T14:12:13.317Z" },
{ url = "https://files.pythonhosted.org/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload-time = "2025-10-06T14:12:15.398Z" },
{ url = "https://files.pythonhosted.org/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload-time = "2025-10-06T14:12:16.935Z" },
{ url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" },
{ url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
{ url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
{ url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
{ url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
{ url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
{ url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
{ url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
{ url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
{ url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
{ url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
{ url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
{ url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
{ url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
{ url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
{ url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
{ url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
{ url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
{ url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
{ url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
{ url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
{ url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
{ url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
{ url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
{ url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
{ url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
{ url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
{ url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
{ url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
{ url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
{ url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
{ url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
{ url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
{ url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
{ url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
{ url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
{ url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
{ url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
{ url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
{ url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
{ url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
{ url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
{ url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
{ url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
{ url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
{ url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
{ url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
{ url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
{ url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
{ url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
{ url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
{ url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
{ url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
{ url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
{ url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
{ url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
{ url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
{ url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
{ url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
{ url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
{ url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
{ url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
{ url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
{ url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
{ url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
{ url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
{ url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
{ url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
{ url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
{ url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
{ url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
{ url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
{ url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
{ url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
{ url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
{ url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
{ url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
{ url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
{ url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
{ url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
{ url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
{ url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
{ url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
{ url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
{ url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
{ url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
{ url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
{ url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
{ url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
{ url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
{ url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
{ url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
{ url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
{ url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
{ url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
{ url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
{ url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
{ url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
{ url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
{ url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
{ url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
{ url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
{ url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
{ url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
{ url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
{ url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
{ url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
{ url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
{ url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
{ url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
{ url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
{ url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
{ url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
{ url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
{ url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
{ url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
{ url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
{ url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
{ url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
{ url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
{ url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
{ url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
{ url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
{ url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
{ url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
{ url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
{ url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
{ url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
{ url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
{ url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
{ url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
{ url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
{ url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
{ url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
{ url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
{ url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
{ url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
{ url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
]
[[package]]