Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

feat(cua-s1): add specialist model research project (#3964)

Francesco Bonaccib7f7e2d87146
diff --git a/.github/workflows/ci-cua-s1.yml b/.github/workflows/ci-cua-s1.yml
new file mode 100644
index 0000000000..6be88493d7
--- /dev/null
+++ b/.github/workflows/ci-cua-s1.yml
@@ -0,0 +1,120 @@
+name: "CI: cua-s1"
+
+on:
+ push:
+ branches: [main]
+ paths:
+ - "libs/cua-s1/**"
+ - ".github/workflows/ci-cua-s1.yml"
+ pull_request:
+ paths:
+ - "libs/cua-s1/**"
+ - ".github/workflows/ci-cua-s1.yml"
+ workflow_dispatch:
+
+permissions:
+ contents: read
+
+jobs:
+ test:
+ name: Lint, test, and train smoke
+ runs-on: ubuntu-latest
+ timeout-minutes: 15
+ env:
+ CUA_TELEMETRY_ENABLED: "false"
+ HF_DATASETS_OFFLINE: "1"
+ HF_HUB_OFFLINE: "1"
+ PYTHONHASHSEED: "0"
+ TRANSFORMERS_OFFLINE: "1"
+ WANDB_MODE: disabled
+ defaults:
+ run:
+ working-directory: libs/cua-s1/python
+
+ steps:
+ - name: Check out Cua
+ uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+
+ - name: Set up uv and Python
+ uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
+ with:
+ python-version: "3.12"
+ enable-cache: true
+ cache-dependency-glob: libs/cua-s1/python/uv.lock
+
+ - name: Install test dependencies
+ run: uv sync --frozen --extra pdf --group test
+
+ - name: Check formatting and lint
+ run: |
+ uv run --frozen ruff format --check src tests ../evals ../training
+ uv run --frozen ruff check src tests ../evals ../training
+
+ - name: Check package imports
+ run: |
+ uv run --frozen python - <<'PY'
+ import cua_s1
+ from cua_s1 import checkpoint, model, pdf, schema, synth
+
+ assert cua_s1.__version__
+ assert all((checkpoint, model, pdf, schema, synth))
+ PY
+
+ - name: Run unit tests without model downloads
+ run: uv run --frozen pytest -q
+
+ - name: Run deterministic CPU training smoke
+ shell: bash
+ run: |
+ set -euo pipefail
+ smoke_root="$RUNNER_TEMP/cua-s1-training-smoke"
+ data_dir="$smoke_root/data"
+
+ uv run --frozen python -m cua_s1.synth \
+ --output "$data_dir" \
+ --episodes 48 \
+ --seed 2026 \
+ --train-ratio 0.5 \
+ --validation-ratio 0.25 \
+ --test-ratio 0.25
+ test -s "$data_dir/train.jsonl"
+ test -s "$data_dir/validation.jsonl"
+
+ for replay in first second; do
+ uv run --frozen python ../training/train.py train "$data_dir/train.jsonl" \
+ --validation "$data_dir/validation.jsonl" \
+ --output "$smoke_root/$replay" \
+ --encoder tiny \
+ --width 8 \
+ --rank 4 \
+ --context-tokens 32 \
+ --option-tokens 16 \
+ --epochs 1 \
+ --batch-size 256 \
+ --workers 0 \
+ --device cpu \
+ --seed 7
+ done
+
+ SMOKE_ROOT="$smoke_root" uv run --frozen python - <<'PY'
+ import json
+ import os
+ from pathlib import Path
+
+ import torch
+
+ from cua_s1.checkpoint import load_checkpoint_files
+
+ root = Path(os.environ["SMOKE_ROOT"])
+ first_state, first_config, first_metadata = load_checkpoint_files(root / "first")
+ second_state, second_config, second_metadata = load_checkpoint_files(root / "second")
+
+ assert first_config == second_config
+ assert first_metadata == second_metadata
+ assert first_state.keys() == second_state.keys()
+ assert all(torch.equal(first_state[name], second_state[name]) for name in first_state)
+
+ first_document = json.loads((root / "first/config.json").read_text(encoding="utf-8"))
+ second_document = json.loads((root / "second/config.json").read_text(encoding="utf-8"))
+ assert first_document == second_document
+ PY
diff --git a/libs/cua-s1/.gitignore b/libs/cua-s1/.gitignore
new file mode 100644
index 0000000000..174d15fe98
--- /dev/null
+++ b/libs/cua-s1/.gitignore
@@ -0,0 +1,7 @@
+**/__pycache__/
+**/.pytest_cache/
+**/.ruff_cache/
+python/.venv/
+artifacts/
+checkpoints/
+runs/
diff --git a/libs/cua-s1/MODEL_CARD.md b/libs/cua-s1/MODEL_CARD.md
new file mode 100644
index 0000000000..a0b83a4e73
--- /dev/null
+++ b/libs/cua-s1/MODEL_CARD.md
@@ -0,0 +1,129 @@
+# Cua-S1 model card
+
+## Model family
+
+Cua-S1 is a research family of small, specialist computer-use models. Each
+checkpoint is expected to have a narrow task contract and checkpoint-specific
+evaluation evidence. Membership in the family does not imply general
+computer-use capability.
+
+## Initial checkpoint
+
+**Name:** `cua-s1-form-v0`
+
+**Intended scope:** research on form-oriented user-interface tasks in the
+environments and task distributions documented with the checkpoint release.
+
+**Status:** research profile. This component includes source code but does not
+distribute weights, training datasets, or a checkpoint artifact manifest.
+
+## Model design
+
+The reference `tinyx` configuration uses a byte-level transformer encoder with
+an option-attention classification head. Its size depends on the checked-in
+configuration used for a training run.
+For each interface element, the model selects one option from a fixed set:
+
+- fill the element with one of the entities extracted from the source document;
+- check the element;
+- click the element; or
+- skip the element.
+
+The prototype scores interface elements independently and does not generate
+field values. Its document parser only extracts values represented as
+`Label: value` pairs. Plain code is responsible for turning selected options
+into an execution order.
+
+## Training data
+
+The included generator creates fictional form episodes using reserved phone
+numbers, `.invalid` domains, invalid test identifiers, and fictional brands.
+It can co-locate similar field concepts and vary form titles to reduce simple
+label or title shortcuts. Generated data is not a substitute for evaluation on
+real interface variation.
+
+No real user submission dataset is included. This model card does not grant or
+establish distribution rights for a future checkpoint artifact.
+
+## Intended uses
+
+- Research on narrowly specified form-oriented computer-use tasks.
+- Evaluation of specialist-model behavior in isolated, controlled environments.
+- Study of task-specific failure modes, verification, and human oversight.
+
+## Out-of-scope uses
+
+- General-purpose or open-ended computer operation.
+- Unsupervised operation on production accounts or sensitive data.
+- Actions with financial, legal, medical, employment, safety, or other
+ high-impact consequences.
+- Bypassing access controls, consent, rate limits, or service policies.
+- Treating model output or apparent task completion as proof that an action was
+ correct or successful.
+
+## Limitations
+
+Computer-use behavior can fail because of unfamiliar layouts, changed interface
+state, ambiguous labels, localization, timing, occlusion, accessibility
+settings, visual similarity, or unexpected dialogs. A specialist checkpoint
+may also overfit its evaluation distribution and may not recognize when a task
+has moved outside that distribution.
+
+The model may select the wrong target, enter incorrect information, expose
+sensitive data, repeat an action, or report success without satisfying the
+intended outcome. Interface content can also contain adversarial or misleading
+instructions. No claim of robustness, broad transfer, autonomy, or general
+capability is made here.
+
+## Evaluation
+
+No model result is claimed by this source-only component. The included tests
+exercise implementation behavior, not checkpoint quality. Offline evaluation
+utilities report abstention, coverage, selective accuracy, wrong actions,
+wrong targets, and unsafe actions. Synthetic splits are disjoint by form
+signature, and model selection uses validation rather than test results.
+
+A checkpoint release must report:
+
+- the exact checkpoint and code revisions;
+- the task set, environment, applications, and operating-system configuration;
+- the action space, observation method, stopping rules, and retry policy;
+- success criteria and independent outcome verification;
+- aggregate results together with representative failure categories; and
+- known exclusions and material differences from real-world deployment.
+
+Comparisons are meaningful only when task definitions, environments, scoring
+methods, and model-selection procedures are compatible.
+
+## Observed failure modes
+
+Expected failures include window-title changes and similar concepts such as
+email versus street address or state versus an organization name. Synthetic
+title variation and hard-negative concepts do not cover every ambiguity.
+
+The executor also depends on the interface accessibility state. If a control's
+current state is unavailable, an apparently valid action might be unsafe. The
+included runtime refuses checkbox mutations when the role or checked state is
+unknown, skips a checkbox that is already checked, and verifies the checked
+postcondition. A future runtime or checkpoint integration must preserve an
+equivalent fail-closed boundary rather than assume that actions are idempotent.
+
+## Deployment guidance
+
+Use an isolated environment, least-privilege credentials, bounded actions, and
+auditable logs that do not retain secrets unnecessarily. Validate state before
+actions and verify outcomes afterward. Require a human confirmation gate for
+consequential or irreversible actions, and provide a reliable way to stop the
+system.
+
+See [`SECURITY.md`](SECURITY.md) for threat-model and reporting guidance.
+
+## Data, architecture, and licensing
+
+This component does not grant rights to future checkpoint weights, external
+training data, or unlisted third-party materials. A checkpoint release must
+document its exact artifact license, data provenance, and applicable
+third-party notices before distribution or use decisions are made. The source
+code is MIT-licensed, but an official checkpoint may use separate terms that
+permit research and evaluation while requiring a commercial license for
+production, hosted inference, resale, or commercial redistribution.
diff --git a/libs/cua-s1/README.md b/libs/cua-s1/README.md
new file mode 100644
index 0000000000..23f4f808ca
--- /dev/null
+++ b/libs/cua-s1/README.md
@@ -0,0 +1,127 @@
+# Cua-S1
+
+Cua-S1 is a research project for studying small, specialist computer-use
+models. The project is intentionally scoped around models that perform a
+defined class of interface tasks rather than a generally capable computer-use
+agent.
+
+The first checkpoint in the project family is `cua-s1-form-v0`, a specialist
+checkpoint for research on form-oriented user-interface tasks. It should not be
+treated as a general-purpose assistant or as evidence of reliable performance
+outside its evaluated task and environment boundaries.
+
+## Project status
+
+Cua-S1 is at an early research stage. This component includes Python model,
+synthetic-data, training, evaluation, and optional Cua Driver integration code.
+It does not include or download model weights, datasets, demo binaries, or
+recordings. No checkpoint performance claim is established by this source-only
+release.
+
+Before evaluating or using a checkpoint, read [`MODEL_CARD.md`](MODEL_CARD.md)
+for its intended scope and limitations and [`SECURITY.md`](SECURITY.md) for
+deployment guidance.
+
+The source code in this component is available under the repository's MIT
+license. That license does not apply to future official model weights,
+datasets, hosted services, or Cua trademarks. A future checkpoint may permit
+research and evaluation while requiring a separate agreement for commercial
+production use; its release must state those artifact-specific terms clearly.
+
+## Python package
+
+The Python distribution is named `cua-s1`, and its import name is `cua_s1`.
+This source-only change does not publish the distribution to a package index.
+
+Install the standalone development environment from this component:
+
+```bash
+uv sync --project libs/cua-s1/python --extra pdf --group test
+uv run --project libs/cua-s1/python pytest libs/cua-s1/python/tests
+```
+
+The package exposes research primitives without downloading a model:
+
+```python
+import cua_s1
+
+print(cua_s1.__version__)
+```
+
+Loading a checkpoint requires a local `safetensors` file and matching JSON
+configuration. Pickle-based PyTorch checkpoints are rejected.
+
+## Safety boundary
+
+Planning and execution are separate. The optional runtime defaults to a dry
+run, requires one unambiguous target window, uses snapshot-bound element
+tokens, and reobserves the window after each mutation. `execute` and `submit`
+are independent opt-ins. PDF access is confined to configured allowed roots.
+Without explicit configuration, the library and MCP server use their current
+working directory as the allowed root. Production deployments should use a
+dedicated, least-privilege directory.
+
+Submission is deliberately narrow: `submit=true` permits at most one
+high-confidence `Button` or `AXButton` whose normalized label is exactly
+`Submit` or `Submit Form`. Other click decisions are omitted. Inspect the
+dry-run plan before enabling both execution flags.
+
+## Optional MCP server
+
+The `cua-s1-mcp` command is an advanced integration surface, not a configured
+model service. Install the optional dependencies before running it:
+
+```bash
+uv sync --project libs/cua-s1/python --extra mcp --extra pdf
+```
+
+The server uses the MCP stdio transport and requires these host settings:
+
+- `CUA_S1_PLANNER_FACTORY` identifies trusted Python code in
+ `module:attribute` form. Importing the factory executes code with the server
+ process's privileges, so do not point it at untrusted modules.
+- `CUA_S1_ALLOWED_PDF_ROOTS` is an operating-system path-separated list of
+ directories that the server may read. If it is unset, the server uses its
+ current working directory.
+- `CUA_S1_DRIVER_BINARY`, `CUA_S1_DRIVER_TRANSPORT`, and `CUA_S1_SESSION` can
+ override the Cua Driver executable, transport, and session.
+
+The connected Cua Driver must provide exact-window snapshots, snapshot-bound
+element tokens, and confirmed action effects. The portable Cua Driver contract
+does not currently expose `set_value`, so fill execution fails closed unless
+the connected runtime explicitly advertises compatible token-based value
+mutation. Planning remains available without executing mutations.
+
+Treat MCP tool results and stdio logs as sensitive. They can contain values
+extracted from PDFs, form labels, window metadata, and values selected for
+entry.
+
+## Checkpoints
+
+| Checkpoint | Scope | Status |
+| --- | --- | --- |
+| `cua-s1-form-v0` | Form-oriented computer-use research | Profile defined; weights not distributed |
+
+Checkpoint-specific release materials should document the exact artifact,
+runtime requirements, evaluation setup, results, and applicable terms. Do not
+assume that results transfer across applications, operating systems, languages,
+layouts, accessibility settings, or task distributions.
+
+## Evaluation
+
+The included offline metrics distinguish accuracy, abstention, coverage, wrong
+actions, wrong targets, and actions taken when the expected behavior was to
+abstain. Synthetic train, validation, and test splits are separated by form
+signature. A future checkpoint release must add an untouched holdout, artifact
+hashes, exact environment details, and independently reproducible results.
+
+## Responsible use
+
+Run computer-use models in isolated environments with least-privilege
+credentials, explicit action boundaries, and independent verification of
+important outcomes. Require human review before consequential, irreversible,
+financial, legal, medical, account, permission, or external-communication
+actions.
+
+Report suspected vulnerabilities through the process in
+[`SECURITY.md`](SECURITY.md).
diff --git a/libs/cua-s1/SECURITY.md b/libs/cua-s1/SECURITY.md
new file mode 100644
index 0000000000..e842514d2f
--- /dev/null
+++ b/libs/cua-s1/SECURITY.md
@@ -0,0 +1,55 @@
+# Cua-S1 security
+
+## Report a vulnerability
+
+Do not open a public issue, discussion, or pull request for a suspected
+vulnerability. Use
+[GitHub private vulnerability reporting](https://github.com/trycua/cua/security/advisories/new)
+and identify Cua-S1 plus the affected checkpoint, package version, or commit.
+
+Provide the smallest reproduction needed to investigate, the security impact,
+and any known mitigation. Do not include credentials, private user data, or
+unrelated sensitive material. Redact logs and screenshots before attaching
+them, and avoid public disclosure until remediation and disclosure timing have
+been coordinated with the maintainers.
+
+For incorrect behavior without a security impact, use the repository's public
+bug-report process.
+
+## Deployment risks
+
+A computer-use model acts on content supplied by applications and may encounter
+malicious instructions, deceptive controls, or unexpected state. Treat screen
+content, documents, web pages, and model-generated actions as untrusted.
+
+Operators should:
+
+- isolate the runtime from the host and unrelated accounts;
+- grant only the credentials, applications, files, network destinations, and
+ actions required for the evaluated task;
+- keep secrets out of observations and logs where possible;
+- validate targets and state before actions and independently verify outcomes;
+- require human confirmation for consequential, irreversible, privileged, or
+ external actions;
+- enforce time, action, and resource limits and provide an immediate stop
+ mechanism; and
+- retain enough redacted evidence to investigate failures without collecting
+ unnecessary sensitive data.
+
+Treat all tool results, planning reports, MCP stdio output, and runtime logs as
+sensitive. They can contain PDF-extracted fields, form labels, window metadata,
+and values selected for entry. Do not send them to shared telemetry or retain
+them in unredacted logs.
+
+The `cua-s1-form-v0` name denotes a specialist research checkpoint, not a
+security boundary. Its outputs must not be used as authorization or as proof
+that a requested operation is safe.
+
+## Artifact integrity
+
+Obtain checkpoints and packages only from documented project distribution
+channels. Verify the exact version and any published digest or signature before
+use. Do not load untrusted model or serialization artifacts into a privileged
+process. Cua-S1 accepts `safetensors` plus JSON checkpoints and rejects common
+pickle-based checkpoint extensions, but callers must still verify the source
+and integrity of every artifact.
diff --git a/libs/cua-s1/THIRD_PARTY_NOTICES.md b/libs/cua-s1/THIRD_PARTY_NOTICES.md
new file mode 100644
index 0000000000..2ed49a7cd0
--- /dev/null
+++ b/libs/cua-s1/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,46 @@
+# Third-party notices
+
+This Cua-S1 component does not bundle third-party model weights, datasets,
+binaries, or media.
+
+## jevlike
+
+Parts of `python/src/cua_s1/model.py` are adapted from the MIT-licensed
+[`jevlike`](https://github.com/vinnylarouge/jevlike) project at commit
+[`94f5fd1b0b11d52bbdfdf4e0ee6aa96b568f8452`](https://github.com/vinnylarouge/jevlike/commit/94f5fd1b0b11d52bbdfdf4e0ee6aa96b568f8452).
+The adapted material is limited to the byte-collation and small attention-model
+primitives in that file.
+
+Copyright (c) 2026 Minimal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The Python package declares Hatchling as a build-system requirement. Hatchling
+is build tooling and is not bundled in the resulting package; it is distributed
+under its own terms.
+
+The Python package declares its runtime dependencies in `python/pyproject.toml`.
+The component-local `python/uv.lock` records the tested development resolution.
+Those dependencies remain distributed under their own licenses and are not
+copied into this repository.
+
+Future checkpoint or software distributions must update this file with the
+applicable notices for all included third-party code, models, datasets, assets,
+and other materials. A reference to Cua-S1 or `cua-s1-form-v0` does not grant
+rights to third-party material.
diff --git a/libs/cua-s1/evals/README.md b/libs/cua-s1/evals/README.md
new file mode 100644
index 0000000000..3d9effcaee
--- /dev/null
+++ b/libs/cua-s1/evals/README.md
@@ -0,0 +1,16 @@
+# Offline evaluation scaffold
+
+`metrics.evaluate_predictions` compares normalized JSON-like records from any
+model or provider. It never performs inference or network access.
+
+Gold records require a stable `id`, `action`, and optional `target`. Ambiguous
+cases may instead include an `acceptable` list:
+
+```json
+{"id":"city","acceptable":[{"action":"fill","target":2},{"action":"fill","target":5}]}
+```
+
+Prediction records use the same `id`, `action`, and optional `target` shape.
+Missing predictions are scored as abstentions. The report separates exact
+accuracy, coverage, selective accuracy, wrong actions, wrong targets, and
+actions taken where the gold behavior required abstention.
diff --git a/libs/cua-s1/evals/__init__.py b/libs/cua-s1/evals/__init__.py
new file mode 100644
index 0000000000..f55213dd5d
--- /dev/null
+++ b/libs/cua-s1/evals/__init__.py
@@ -0,0 +1,5 @@
+"""Offline evaluation helpers for Cua-S1 predictions."""
+
+from .metrics import evaluate_predictions
+
+__all__ = ["evaluate_predictions"]
diff --git a/libs/cua-s1/evals/metrics.py b/libs/cua-s1/evals/metrics.py
new file mode 100644
index 0000000000..9330d666f7
--- /dev/null
+++ b/libs/cua-s1/evals/metrics.py
@@ -0,0 +1,102 @@
+"""Provider-neutral metrics for action selection and safe abstention.
+
+Gold and prediction records are plain mappings so outputs from any local model
+or external provider can be normalized before scoring. No inference or network
+access happens in this module.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+ABSTAIN_ACTIONS = frozenset({"abstain", "skip"})
+
+
+def _choice(record: Mapping[str, Any]) -> tuple[str, int | str | None]:
+ action = str(record.get("action", "abstain"))
+ if action in ABSTAIN_ACTIONS:
+ action = "abstain"
+ target = record.get("target", record.get("entity_index"))
+ return action, target
+
+
+def _acceptable(record: Mapping[str, Any]) -> set[tuple[str, int | str | None]]:
+ alternatives = record.get("acceptable")
+ if alternatives is None:
+ return {_choice(record)}
+ return {_choice(option) for option in alternatives}
+
+
+def evaluate_predictions(
+ gold: Iterable[Mapping[str, Any]],
+ predictions: Iterable[Mapping[str, Any]],
+) -> dict[str, Any]:
+ """Score predictions by stable ``id`` without assuming a model provider.
+
+ Missing predictions count as abstentions. Multiple acceptable gold choices
+ let an evaluation represent an intentionally ambiguous target without
+ arbitrarily declaring one equivalent target wrong.
+ """
+
+ gold_by_id = {str(record["id"]): record for record in gold}
+ predictions_by_id = {str(record["id"]): record for record in predictions}
+ unknown = sorted(set(predictions_by_id) - set(gold_by_id))
+ if unknown:
+ raise ValueError(f"predictions contain unknown ids: {unknown}")
+
+ counts: Counter[str] = Counter()
+ per_action: dict[str, Counter[str]] = {}
+ for case_id, expected_record in gold_by_id.items():
+ acceptable = _acceptable(expected_record)
+ expected_actions = {action for action, _ in acceptable}
+ prediction = predictions_by_id.get(case_id, {"action": "abstain"})
+ predicted = _choice(prediction)
+ predicted_action, predicted_target = predicted
+ abstained = predicted_action in ABSTAIN_ACTIONS
+ correct = predicted in acceptable
+
+ counts["total"] += 1
+ counts["correct"] += int(correct)
+ counts["abstained"] += int(abstained)
+ counts["acted"] += int(not abstained)
+ counts["acted_correct"] += int(correct and not abstained)
+
+ if not correct and not abstained:
+ if predicted_action not in expected_actions:
+ counts["wrong_action"] += 1
+ else:
+ counts["wrong_target"] += 1
+ if not abstained and expected_actions <= ABSTAIN_ACTIONS:
+ counts["unsafe_action"] += 1
+
+ bucket_name = sorted(expected_actions)[0] if len(expected_actions) == 1 else "ambiguous"
+ bucket = per_action.setdefault(bucket_name, Counter())
+ bucket["total"] += 1
+ bucket["correct"] += int(correct)
+ bucket["abstained"] += int(abstained)
+ if predicted_target is not None:
+ bucket["targeted"] += 1
+
+ total = counts["total"]
+ acted = counts["acted"]
+ return {
+ "examples": total,
+ "accuracy": counts["correct"] / total if total else 0.0,
+ "coverage": acted / total if total else 0.0,
+ "abstention_rate": counts["abstained"] / total if total else 0.0,
+ "selective_accuracy": counts["acted_correct"] / acted if acted else 0.0,
+ "wrong_action_rate": counts["wrong_action"] / total if total else 0.0,
+ "wrong_target_rate": counts["wrong_target"] / total if total else 0.0,
+ "unsafe_action_rate": counts["unsafe_action"] / total if total else 0.0,
+ "counts": dict(counts),
+ "per_action": {
+ action: {
+ "accuracy": bucket["correct"] / bucket["total"],
+ "abstention_rate": bucket["abstained"] / bucket["total"],
+ "examples": bucket["total"],
+ }
+ for action, bucket in sorted(per_action.items())
+ },
+ }
diff --git a/libs/cua-s1/python/LICENSE b/libs/cua-s1/python/LICENSE
new file mode 100644
index 0000000000..b8b198ce3e
--- /dev/null
+++ b/libs/cua-s1/python/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cua AI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/libs/cua-s1/python/pyproject.toml b/libs/cua-s1/python/pyproject.toml
new file mode 100644
index 0000000000..60baff7c89
--- /dev/null
+++ b/libs/cua-s1/python/pyproject.toml
@@ -0,0 +1,80 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cua-s1"
+version = "0.0.0"
+description = "Research tools for small, specialist computer-use models"
+readme = { text = "Cua-S1 provides research code for small, specialist computer-use models. The package does not include or download model weights.", content-type = "text/markdown" }
+license = { file = "LICENSE" }
+authors = [
+ { name = "TryCua", email = "[email protected]" }
+]
+keywords = [
+ "computer-use",
+ "machine-learning",
+ "research",
+]
+classifiers = [
+ "Development Status :: 2 - Pre-Alpha",
+ "Intended Audience :: Developers",
+ "Intended Audience :: Science/Research",
+ "License :: OSI Approved :: MIT License",
+ "Operating System :: OS Independent",
+ "Programming Language :: Python :: 3",
+ "Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
+ "Programming Language :: Python :: 3.13",
+ "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+requires-python = ">=3.11,<3.14"
+dependencies = [
+ "numpy>=1.26",
+ "safetensors>=0.4,<1",
+ "torch>=2.2,<3",
+]
+
+[project.optional-dependencies]
+pdf = [
+ "pdfplumber>=0.11,<1",
+]
+mcp = [
+ "mcp>=1,<2",
+]
+all = [
+ "mcp>=1,<2",
+ "pdfplumber>=0.11,<1",
+]
+
+[project.scripts]
+cua-s1-mcp = "cua_s1.server:main"
+
+[project.urls]
+Homepage = "https://github.com/trycua/cua"
+Documentation = "https://github.com/trycua/cua/tree/main/libs/cua-s1"
+Repository = "https://github.com/trycua/cua"
+Issues = "https://github.com/trycua/cua/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cua_s1"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["B", "E", "F", "I", "W"]
+ignore = ["E501"]
+
+[dependency-groups]
+test = [
+ "pytest>=8,<10",
+ "pytest-asyncio>=0.24,<2",
+ "ruff>=0.12,<1",
+]
diff --git a/libs/cua-s1/python/src/cua_s1/__init__.py b/libs/cua-s1/python/src/cua_s1/__init__.py
new file mode 100644
index 0000000000..00eefac9a8
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/__init__.py
@@ -0,0 +1,8 @@
+"""Package metadata for the Cua-S1 research project.
+
+The package does not include or download checkpoint weights.
+"""
+
+__version__ = "0.0.0"
+
+__all__ = ["__version__"]
diff --git a/libs/cua-s1/python/src/cua_s1/checkpoint.py b/libs/cua-s1/python/src/cua_s1/checkpoint.py
new file mode 100644
index 0000000000..9705900894
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/checkpoint.py
@@ -0,0 +1,181 @@
+"""Safe, serialization-only checkpoint helpers for Cua-S1 models."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import torch
+
+FORMAT_NAME = "cua-s1"
+FORMAT_VERSION = 1
+
+
+def _canonical_json(value: Any) -> bytes:
+ return json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def _state_signature(tensors: Mapping[str, Any], config: Mapping[str, Any]) -> str:
+ digest = hashlib.sha256()
+ digest.update(_canonical_json(dict(config)))
+ for name in sorted(tensors):
+ tensor = tensors[name]
+ digest.update(_canonical_json([name, str(tensor.dtype), list(tensor.shape)]))
+ raw = tensor.detach().cpu().contiguous().reshape(-1).view(torch.uint8)
+ digest.update(raw.numpy().tobytes())
+ return digest.hexdigest()
+
+
+def _temporary_path(target: Path) -> Path:
+ descriptor, name = tempfile.mkstemp(prefix=f".{target.name}.", suffix=".tmp", dir=target.parent)
+ os.close(descriptor)
+ return Path(name)
+
+
+def resolve_checkpoint_paths(directory_or_path: str | Path) -> tuple[Path, Path]:
+ """Return the weights and JSON paths for a checkpoint location."""
+ path = Path(directory_or_path).expanduser()
+ suffix = path.suffix.lower()
+ if suffix in {".pt", ".pth", ".bin", ".pkl", ".pickle"}:
+ raise ValueError(
+ "legacy pickle-based checkpoints are not supported; convert the model "
+ "to a safetensors file plus JSON configuration in a trusted environment"
+ )
+ if suffix == ".safetensors":
+ return path, path.with_suffix(".json")
+ if suffix == ".json":
+ return path.with_suffix(".safetensors"), path
+ if suffix:
+ raise ValueError("checkpoint path must be a directory, .safetensors file, or .json file")
+ return path / "model.safetensors", path / "config.json"
+
+
+def save_checkpoint_files(
+ directory_or_path: str | Path,
+ state_dict: Mapping[str, Any],
+ config: Mapping[str, Any],
+ metadata: Mapping[str, Any] | None = None,
+) -> tuple[Path, Path]:
+ """Write tensors with safetensors and non-executable data with JSON."""
+ weights_path, config_path = resolve_checkpoint_paths(directory_or_path)
+ try:
+ from safetensors.torch import save_file
+ except ImportError as exc: # pragma: no cover - depends on optional installation
+ raise RuntimeError("saving Cua-S1 checkpoints requires the 'safetensors' package") from exc
+
+ if weights_path.exists() and weights_path.is_dir():
+ raise ValueError(f"weights path is a directory: {weights_path}")
+ if config_path.exists() and config_path.is_dir():
+ raise ValueError(f"config path is a directory: {config_path}")
+ weights_path.parent.mkdir(parents=True, exist_ok=True)
+ config_path.parent.mkdir(parents=True, exist_ok=True)
+
+ tensors: dict[str, Any] = {}
+ for name, tensor in state_dict.items():
+ if not isinstance(name, str) or not name:
+ raise ValueError("state_dict keys must be non-empty strings")
+ if not hasattr(tensor, "detach"):
+ raise TypeError(f"state_dict value {name!r} is not a tensor")
+ tensors[name] = tensor.detach().cpu().contiguous()
+ if not tensors:
+ raise ValueError("cannot save an empty state_dict")
+
+ try:
+ state_signature = _state_signature(tensors, config)
+ except (TypeError, ValueError) as exc:
+ raise ValueError("checkpoint config and metadata must be JSON serializable") from exc
+ document = {
+ "format": FORMAT_NAME,
+ "format_version": FORMAT_VERSION,
+ "state_signature": state_signature,
+ "config": dict(config),
+ "metadata": dict(metadata or {}),
+ }
+ try:
+ encoded = json.dumps(document, indent=2, sort_keys=True) + "\n"
+ except (TypeError, ValueError) as exc:
+ raise ValueError("checkpoint config and metadata must be JSON serializable") from exc
+
+ weights_temporary = _temporary_path(weights_path)
+ config_temporary = _temporary_path(config_path)
+ try:
+ save_file(
+ tensors,
+ str(weights_temporary),
+ metadata={
+ "format": FORMAT_NAME,
+ "format_version": str(FORMAT_VERSION),
+ "state_signature": state_signature,
+ },
+ )
+ os.replace(weights_temporary, weights_path)
+ config_temporary.write_text(encoded, encoding="utf-8")
+ os.replace(config_temporary, config_path)
+ finally:
+ weights_temporary.unlink(missing_ok=True)
+ config_temporary.unlink(missing_ok=True)
+ return weights_path, config_path
+
+
+def load_checkpoint_files(
+ directory_or_path: str | Path,
+) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]:
+ """Load a safetensors state dict and validate its JSON configuration."""
+ weights_path, config_path = resolve_checkpoint_paths(directory_or_path)
+ try:
+ from safetensors import safe_open
+ from safetensors.torch import load_file
+ except ImportError as exc: # pragma: no cover - depends on optional installation
+ raise RuntimeError("loading Cua-S1 checkpoints requires the 'safetensors' package") from exc
+
+ if not weights_path.is_file():
+ raise FileNotFoundError(f"checkpoint weights not found: {weights_path}")
+ if not config_path.is_file():
+ raise FileNotFoundError(f"checkpoint config not found: {config_path}")
+
+ try:
+ document = json.loads(config_path.read_text(encoding="utf-8"))
+ except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+ raise ValueError(f"invalid checkpoint JSON: {config_path}") from exc
+ if not isinstance(document, dict):
+ raise ValueError("checkpoint JSON must contain an object")
+ if document.get("format") != FORMAT_NAME:
+ raise ValueError(f"unsupported checkpoint format: {document.get('format')!r}")
+ if document.get("format_version") != FORMAT_VERSION:
+ raise ValueError(
+ f"unsupported checkpoint format version: {document.get('format_version')!r}"
+ )
+ config = document.get("config")
+ metadata = document.get("metadata", {})
+ state_signature = document.get("state_signature")
+ if not isinstance(config, dict):
+ raise ValueError("checkpoint JSON field 'config' must be an object")
+ if not isinstance(metadata, dict):
+ raise ValueError("checkpoint JSON field 'metadata' must be an object")
+ if not isinstance(state_signature, str) or len(state_signature) != 64:
+ raise ValueError("checkpoint JSON field 'state_signature' must be a SHA-256 digest")
+
+ try:
+ with safe_open(str(weights_path), framework="pt", device="cpu") as handle:
+ weights_metadata = handle.metadata() or {}
+ if weights_metadata.get("format") != FORMAT_NAME:
+ raise ValueError("unsupported safetensors checkpoint format")
+ if weights_metadata.get("format_version") != str(FORMAT_VERSION):
+ raise ValueError("unsupported safetensors checkpoint format version")
+ if weights_metadata.get("state_signature") != state_signature:
+ raise ValueError("checkpoint state signature mismatch")
+ state_dict = load_file(str(weights_path), device="cpu")
+ except ValueError:
+ raise
+ except Exception as exc:
+ raise ValueError(f"invalid safetensors checkpoint: {weights_path}") from exc
+ if not state_dict:
+ raise ValueError("checkpoint contains no tensors")
+ if _state_signature(state_dict, config) != state_signature:
+ raise ValueError("checkpoint state signature mismatch")
+ return state_dict, config, metadata
diff --git a/libs/cua-s1/python/src/cua_s1/concepts.py b/libs/cua-s1/python/src/cua_s1/concepts.py
new file mode 100644
index 0000000000..5f4775089a
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/concepts.py
@@ -0,0 +1,985 @@
+"""Catalogue of form-field concepts with label synonyms and value generators.
+
+Each concept describes one kind of information (a phone number, a policy
+number, ...). A form shows it under one of `form_labels`; a source document
+lists it under one of `doc_labels`. The synthetic generator samples both
+sides independently so the model has to learn that "Tel" and "Phone number"
+are the same thing while "Emergency contact phone" is not.
+"""
+
+from __future__ import annotations
+
+import random
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+PersonData = dict[str, str]
+ValueGenerator = Callable[[random.Random, PersonData], str]
+
+FIRST_NAMES = (
+ "Maya",
+ "Liam",
+ "Aisha",
+ "Noah",
+ "Priya",
+ "Ethan",
+ "Sofia",
+ "Mateo",
+ "Hannah",
+ "Kenji",
+ "Olivia",
+ "Diego",
+ "Amara",
+ "Lucas",
+ "Zara",
+ "Omar",
+ "Isla",
+ "Felix",
+ "Nadia",
+ "Tomas",
+ "Grace",
+ "Ravi",
+ "Elena",
+ "Jonas",
+ "Leila",
+ "Marcus",
+ "Chloe",
+ "Ibrahim",
+ "Ruth",
+ "Dmitri",
+)
+LAST_NAMES = (
+ "Okafor",
+ "Nguyen",
+ "Schmidt",
+ "Garcia",
+ "Patel",
+ "Kowalski",
+ "Haddad",
+ "Fischer",
+ "Moreau",
+ "Tanaka",
+ "Silva",
+ "Andersen",
+ "Rossi",
+ "Ivanova",
+ "Mbeki",
+ "O'Brien",
+ "Larsson",
+ "Delgado",
+ "Yamamoto",
+ "Novak",
+ "Chen",
+ "Becker",
+ "Abernathy",
+ "Quinn",
+ "Farouk",
+ "Lindqvist",
+ "Ortega",
+)
+STREETS = (
+ "Maple",
+ "Oak",
+ "Cedar",
+ "Harbor",
+ "Lakeview",
+ "Sunset",
+ "Ridge",
+ "Park",
+ "Willow",
+ "Birch",
+ "Station",
+ "Mill",
+ "Highland",
+ "Elm",
+ "Bridge",
+)
+STREET_TYPES = ("St", "Ave", "Rd", "Blvd", "Lane", "Drive", "Court", "Way")
+CITIES = (
+ ("Portland", "OR", "97205"),
+ ("Austin", "TX", "78701"),
+ ("Denver", "CO", "80202"),
+ ("Boston", "MA", "02108"),
+ ("Seattle", "WA", "98101"),
+ ("Madison", "WI", "53703"),
+ ("Raleigh", "NC", "27601"),
+ ("Tucson", "AZ", "85701"),
+ ("Omaha", "NE", "68102"),
+ ("Savannah", "GA", "31401"),
+ ("Boise", "ID", "83702"),
+ ("Burlington", "VT", "05401"),
+)
+COMPANIES = (
+ "Example Robotics",
+ "Example Trading",
+ "Test Manufacturing",
+ "Example Health",
+ "Test Logistics",
+ "Example Industries",
+ "Test Software",
+ "Example Foods",
+ "Test Freight",
+ "Example Design",
+ "Test Energy",
+ "Example Services",
+)
+INSURERS = (
+ "Example Health Plan",
+ "Test Mutual",
+ "Example Care",
+ "Test Assurance",
+ "Example Benefit Group",
+ "Test Community Health",
+)
+JOB_TITLES = (
+ "Software Engineer",
+ "Nurse Practitioner",
+ "Account Manager",
+ "Data Analyst",
+ "Robotics Technician",
+ "Product Designer",
+ "Warehouse Supervisor",
+ "Dental Hygienist",
+ "Civil Engineer",
+ "Sales Associate",
+ "Registered Nurse",
+ "Project Manager",
+)
+CAR_MAKES = (
+ ("Example Motors", "Alpha"),
+ ("Test Automotive", "Beta"),
+ ("Example Electric", "Gamma"),
+ ("Test Vehicles", "Delta"),
+)
+COUNTRIES = ("United States", "Canada", "United Kingdom", "Germany", "Australia", "Japan", "Brazil")
+BANKS = ("Example Bank", "Test Credit Union", "Example Savings", "Test Community Bank")
+UNIVERSITIES = (
+ "Example State University",
+ "Test Technical Institute",
+ "Example College",
+ "Test Polytechnic",
+ "Example Community College",
+)
+DEGREES = (
+ "BSc Computer Science",
+ "BA Economics",
+ "MSc Nursing",
+ "BEng Mechanical",
+ "MBA",
+ "Associate of Arts",
+ "PhD Chemistry",
+)
+RELATIONS = (
+ "Spouse",
+ "Mother",
+ "Father",
+ "Sister",
+ "Brother",
+ "Partner",
+ "Friend",
+ "Daughter",
+ "Son",
+)
+REASONS = (
+ "Annual check-up",
+ "Persistent cough for two weeks",
+ "Follow-up after surgery",
+ "Knee pain when climbing stairs",
+ "Flu vaccination",
+ "Migraine headaches",
+ "Back pain",
+ "Skin rash on left arm",
+ "Blood pressure review",
+ "Allergy testing",
+)
+BLOOD_TYPES = ("A+", "A-", "B+", "B-", "O+", "O-", "AB+", "AB-")
+
+
+def _digits(rng: random.Random, n: int) -> str:
+ return "".join(str(rng.randint(0, 9)) for _ in range(n))
+
+
+def _alnum(rng: random.Random, n: int) -> str:
+ return "".join(rng.choice("ABCDEFGHJKLMNPQRSTUVWXYZ0123456789") for _ in range(n))
+
+
+def gen_phone(rng: random.Random) -> str:
+ suffix = rng.randint(100, 199)
+ return rng.choice(
+ (
+ f"(202) 555-{suffix:04d}",
+ f"202-555-{suffix:04d}",
+ f"202.555.{suffix:04d}",
+ f"+1 202 555 {suffix:04d}",
+ )
+ )
+
+
+def gen_date(rng: random.Random, start: int = 1940, end: int = 2008) -> str:
+ y, m, d = rng.randint(start, end), rng.randint(1, 12), rng.randint(1, 28)
+ return rng.choice(
+ (
+ f"{m:02d}/{d:02d}/{y}",
+ f"{y}-{m:02d}-{d:02d}",
+ f"{d} {['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][m - 1]} {y}",
+ )
+ )
+
+
+def gen_money(rng: random.Random) -> str:
+ v = rng.randint(30, 220) * 1000
+ return rng.choice((f"${v:,}", f"{v} USD", f"${v // 1000}k"))
+
+
+@dataclass
+class Concept:
+ key: str
+ form_labels: tuple[str, ...]
+ doc_labels: tuple[str, ...]
+ value: ValueGenerator
+ kind: str = "text" # text | textarea | select
+ placeholder: tuple[str, ...] = ()
+ group: str = "general" # concepts in the same group are plausible confusers
+ options: tuple[str, ...] = () # for select kind
+
+
+def C(
+ key: str,
+ form_labels: Sequence[str],
+ doc_labels: Sequence[str],
+ value: ValueGenerator,
+ **kwargs: Any,
+) -> Concept:
+ """Build a concept while normalizing label collections to tuples."""
+ return Concept(key, tuple(form_labels), tuple(doc_labels), value, **kwargs)
+
+
+# Person-level values are generated once per "person" so derived fields agree.
+def person(rng: random.Random) -> PersonData:
+ """Generate one internally consistent synthetic person's field values."""
+ first, last = rng.choice(FIRST_NAMES), rng.choice(LAST_NAMES)
+ city, state, zipc = rng.choice(CITIES)
+ ec_first, ec_last = rng.choice(FIRST_NAMES), rng.choice(LAST_NAMES)
+ make, model = rng.choice(CAR_MAKES)
+ domain = rng.choice(("example.invalid", "mail.example.invalid", "test.example.invalid"))
+ return {
+ "first": first,
+ "last": last,
+ "full": f"{first} {last}",
+ "email": rng.choice(
+ (
+ f"{first.lower()}.{last.lower().replace(chr(39), '')}@{domain}",
+ f"{first[0].lower()}{last.lower().replace(chr(39), '')}{rng.randint(1, 99)}@{domain}",
+ )
+ ),
+ "phone": gen_phone(rng),
+ "work_phone": gen_phone(rng),
+ "dob": gen_date(rng),
+ "street": f"{rng.randint(10, 9999)} {rng.choice(STREETS)} {rng.choice(STREET_TYPES)}",
+ "unit": rng.choice(("Apt 4B", "Unit 12", "Suite 300", "#7", "Apt 2")),
+ "city": city,
+ "state": state,
+ "zip": zipc,
+ "country": rng.choice(COUNTRIES),
+ "insurer": rng.choice(INSURERS),
+ "policy": f"TEST-POL-{_digits(rng, 8)}",
+ "group_no": f"TEST-GRP-{_digits(rng, 6)}",
+ "member_id": f"TEST-MBR-{_alnum(rng, 9)}",
+ "ec_name": f"{ec_first} {ec_last}",
+ "ec_phone": gen_phone(rng),
+ "ec_relation": rng.choice(RELATIONS),
+ "employer": rng.choice(COMPANIES),
+ "job_title": rng.choice(JOB_TITLES),
+ "years": str(rng.randint(1, 25)),
+ "salary": gen_money(rng),
+ "start": gen_date(rng, 2026, 2027),
+ "linkedin": f"https://profiles.example.invalid/{first.lower()}-{last.lower().replace(chr(39), '')}",
+ "website": f"https://{last.lower().replace(chr(39), '')}.example.invalid",
+ "ssn": f"900-{_digits(rng, 2)}-{_digits(rng, 4)}",
+ "license": f"TEST-DL-{_alnum(rng, 8)}",
+ "passport": f"TEST-PPT-{_alnum(rng, 8)}",
+ "car_make": make,
+ "car_model": model,
+ "car_year": str(rng.randint(2008, 2026)),
+ "plate": f"TEST-{_alnum(rng, 3)}",
+ "vin": f"TESTVIN-IQ-{_alnum(rng, 7)}",
+ "bank": rng.choice(BANKS),
+ "account": f"TEST-ACCT-{_digits(rng, 10)}",
+ "routing": f"TEST-ROUTE-{_digits(rng, 9)}",
+ "university": rng.choice(UNIVERSITIES),
+ "degree": rng.choice(DEGREES),
+ "grad_year": str(rng.randint(1995, 2025)),
+ "reason": rng.choice(REASONS),
+ "blood": rng.choice(BLOOD_TYPES),
+ "allergies": rng.choice(("Penicillin", "None", "Peanuts", "Latex", "Shellfish")),
+ "medications": rng.choice(
+ ("None", "Metformin 500mg", "Lisinopril 10mg", "Albuterol inhaler")
+ ),
+ "doctor": f"Dr. {rng.choice(LAST_NAMES)}",
+ "sex": rng.choice(("Female", "Male")),
+ "marital": rng.choice(("Single", "Married", "Divorced", "Widowed")),
+ "nationality": rng.choice(
+ ("American", "Canadian", "British", "German", "Indian", "Japanese")
+ ),
+ "company_reg": f"TEST-REG-{_digits(rng, 7)}",
+ "tax_id": f"00-{_digits(rng, 7)}",
+ "claim_no": f"TEST-CLM-{_digits(rng, 6)}",
+ "incident_date": gen_date(rng, 2025, 2026),
+ "incident_desc": rng.choice(
+ (
+ "Rear-ended at a stop light",
+ "Water damage from burst pipe",
+ "Lost luggage on connecting flight",
+ "Slipped on icy pavement",
+ )
+ ),
+ "cover": rng.choice(
+ (
+ "I am excited to apply for this role and bring my experience to your team.",
+ "With five years in the field I believe I would be a strong fit.",
+ "Please consider my application for the open position.",
+ )
+ ),
+ }
+
+
+CONCEPTS: list[Concept] = [
+ C(
+ "first_name",
+ ("First name", "Given name", "First Name", "Forename", "First"),
+ ("First name", "Given name", "First", "Forename"),
+ lambda r, p: p["first"],
+ placeholder=("Given name", "First"),
+ group="name",
+ ),
+ C(
+ "last_name",
+ ("Last name", "Surname", "Family name", "Last Name", "Last"),
+ ("Last name", "Surname", "Family name", "Last"),
+ lambda r, p: p["last"],
+ placeholder=("Family name",),
+ group="name",
+ ),
+ C(
+ "full_name",
+ (
+ "Full name",
+ "Name",
+ "Your name",
+ "Applicant name",
+ "Patient name",
+ "Legal name",
+ "Name (as on ID)",
+ ),
+ ("Name", "Full name", "Patient", "Applicant", "Legal name", "Insured"),
+ lambda r, p: p["full"],
+ group="name",
+ ),
+ C(
+ "email",
+ ("Email address", "Email", "E-mail", "Contact email", "Your email", "Email Address"),
+ ("Email", "E-mail", "Email address", "Contact"),
+ lambda r, p: p["email"],
+ group="contact",
+ ),
+ C(
+ "phone",
+ (
+ "Phone number",
+ "Phone",
+ "Telephone",
+ "Mobile phone",
+ "Contact phone",
+ "Primary phone",
+ "Cell phone",
+ "Mobile number",
+ "Daytime phone",
+ ),
+ ("Phone", "Tel", "Telephone", "Mobile", "Cell", "Contact number", "Primary phone"),
+ lambda r, p: p["phone"],
+ placeholder=("(555) 555-5555",),
+ group="contact",
+ ),
+ C(
+ "work_phone",
+ ("Work phone", "Office phone", "Business phone", "Work telephone"),
+ ("Work phone", "Office", "Business tel", "Work"),
+ lambda r, p: p["work_phone"],
+ group="contact",
+ ),
+ C(
+ "dob",
+ ("Date of birth", "Birth date", "DOB", "Birthday", "Date of Birth"),
+ ("DOB", "Date of birth", "Born", "Birth date", "Birthday"),
+ lambda r, p: p["dob"],
+ placeholder=("MM/DD/YYYY", "YYYY-MM-DD"),
+ group="dates",
+ ),
+ C(
+ "street",
+ (
+ "Street address",
+ "Address",
+ "Address line 1",
+ "Street",
+ "Home address",
+ "Mailing address",
+ "Residential address",
+ ),
+ ("Address", "Street", "Home address", "Residence", "Address line 1"),
+ lambda r, p: p["street"],
+ group="address",
+ ),
+ C(
+ "unit",
+ ("Address line 2", "Apt / Suite", "Apartment or unit", "Unit number"),
+ ("Apt", "Unit", "Suite", "Address line 2"),
+ lambda r, p: p["unit"],
+ group="address",
+ ),
+ C(
+ "city",
+ ("City", "Town", "City / Town", "Town or city"),
+ ("City", "Town"),
+ lambda r, p: p["city"],
+ group="address",
+ ),
+ C(
+ "state",
+ ("State", "State / Province", "Province", "Region"),
+ ("State", "Province", "Region", "ST"),
+ lambda r, p: p["state"],
+ group="address",
+ ),
+ C(
+ "zip",
+ ("ZIP code", "Postal code", "Zip", "ZIP", "Postcode", "Zip / Postal code"),
+ ("ZIP", "Zip code", "Postal code", "Postcode"),
+ lambda r, p: p["zip"],
+ placeholder=("ZIP", "12345"),
+ group="address",
+ ),
+ C(
+ "country",
+ ("Country", "Country of residence", "Nation"),
+ ("Country", "Country of residence"),
+ lambda r, p: p["country"],
+ group="address",
+ ),
+ C(
+ "insurer",
+ (
+ "Insurance provider",
+ "Insurance company",
+ "Insurer",
+ "Health plan",
+ "Carrier",
+ "Insurance carrier",
+ ),
+ ("Insurer", "Insurance", "Carrier", "Health plan", "Insurance company", "Plan"),
+ lambda r, p: p["insurer"],
+ group="insurance",
+ ),
+ C(
+ "policy",
+ ("Policy number", "Policy #", "Policy no.", "Insurance policy number", "Policy ID"),
+ ("Policy", "Policy #", "Policy no", "Policy number", "Policy ID"),
+ lambda r, p: p["policy"],
+ placeholder=("Policy #",),
+ group="insurance",
+ ),
+ C(
+ "group_no",
+ ("Group number", "Group #", "Plan group number"),
+ ("Group", "Group #", "Group no", "Group number"),
+ lambda r, p: p["group_no"],
+ group="insurance",
+ ),
+ C(
+ "member_id",
+ ("Member ID", "Subscriber ID", "Member number", "Insurance ID"),
+ ("Member ID", "Subscriber", "Member #", "ID number"),
+ lambda r, p: p["member_id"],
+ group="insurance",
+ ),
+ C(
+ "ec_name",
+ (
+ "Emergency contact name",
+ "Emergency contact",
+ "In case of emergency contact",
+ "Next of kin",
+ "Emergency contact (name)",
+ ),
+ (
+ "Emergency contact",
+ "ICE",
+ "Next of kin",
+ "In case of emergency",
+ "Emergency contact name",
+ ),
+ lambda r, p: p["ec_name"],
+ group="emergency",
+ ),
+ C(
+ "ec_phone",
+ (
+ "Emergency contact phone",
+ "Emergency phone",
+ "Emergency contact number",
+ "Next of kin phone",
+ "Emergency contact telephone",
+ ),
+ (
+ "Emergency phone",
+ "ICE phone",
+ "Emergency contact phone",
+ "Next of kin tel",
+ "Emergency number",
+ ),
+ lambda r, p: p["ec_phone"],
+ group="emergency",
+ ),
+ C(
+ "ec_relation",
+ (
+ "Relationship to patient",
+ "Emergency contact relationship",
+ "Relationship",
+ "Relation to applicant",
+ ),
+ ("Relationship", "Relation", "Emergency contact relation"),
+ lambda r, p: p["ec_relation"],
+ group="emergency",
+ ),
+ C(
+ "employer",
+ (
+ "Current employer",
+ "Employer",
+ "Company",
+ "Company name",
+ "Organization",
+ "Current company",
+ ),
+ ("Employer", "Company", "Organization", "Works at", "Current employer"),
+ lambda r, p: p["employer"],
+ group="employment",
+ ),
+ C(
+ "job_title",
+ ("Current job title", "Job title", "Position", "Occupation", "Title", "Role"),
+ ("Title", "Job title", "Occupation", "Position", "Role", "Profession"),
+ lambda r, p: p["job_title"],
+ group="employment",
+ ),
+ C(
+ "years",
+ ("Years of experience", "Experience (years)", "Total years experience", "Years in role"),
+ ("Experience", "Years of experience", "Years", "Yrs experience"),
+ lambda r, p: p["years"],
+ group="employment",
+ ),
+ C(
+ "salary",
+ (
+ "Desired salary",
+ "Expected salary",
+ "Salary expectation",
+ "Current salary",
+ "Annual salary",
+ ),
+ ("Salary", "Expected salary", "Desired compensation", "Compensation", "Annual pay"),
+ lambda r, p: p["salary"],
+ group="employment",
+ ),
+ C(
+ "start_date",
+ (
+ "Earliest start date",
+ "Available from",
+ "Start date",
+ "Availability date",
+ "Date available",
+ ),
+ ("Start date", "Available", "Availability", "Can start", "Earliest start"),
+ lambda r, p: p["start"],
+ group="dates",
+ ),
+ C(
+ "linkedin",
+ ("LinkedIn profile URL", "LinkedIn", "LinkedIn profile", "Professional profile URL"),
+ ("LinkedIn", "Profile", "LinkedIn URL"),
+ lambda r, p: p["linkedin"],
+ group="web",
+ ),
+ C(
+ "website",
+ ("Website", "Personal website", "Portfolio URL", "Homepage", "Web site"),
+ ("Website", "Web", "Portfolio", "URL", "Homepage"),
+ lambda r, p: p["website"],
+ group="web",
+ ),
+ C(
+ "ssn",
+ ("Social Security Number", "SSN", "Social security no.", "National ID number"),
+ ("SSN", "Social Security", "Social security number", "National ID"),
+ lambda r, p: p["ssn"],
+ group="ids",
+ ),
+ C(
+ "license",
+ ("Driver's license number", "Driver license #", "License number", "DL number"),
+ ("License", "DL", "Driver's license", "License no", "Driver license"),
+ lambda r, p: p["license"],
+ group="ids",
+ ),
+ C(
+ "passport",
+ ("Passport number", "Passport #", "Passport no."),
+ ("Passport", "Passport #", "Passport number"),
+ lambda r, p: p["passport"],
+ group="ids",
+ ),
+ C(
+ "car_make",
+ ("Vehicle make", "Make", "Car make", "Manufacturer"),
+ ("Make", "Vehicle make", "Manufacturer"),
+ lambda r, p: p["car_make"],
+ group="vehicle",
+ ),
+ C(
+ "car_model",
+ ("Vehicle model", "Model", "Car model"),
+ ("Model", "Vehicle model"),
+ lambda r, p: p["car_model"],
+ group="vehicle",
+ ),
+ C(
+ "car_year",
+ ("Vehicle year", "Model year", "Year"),
+ ("Year", "Model year", "Vehicle year"),
+ lambda r, p: p["car_year"],
+ group="vehicle",
+ ),
+ C(
+ "plate",
+ ("License plate", "Plate number", "Registration plate", "Plate #"),
+ ("Plate", "License plate", "Registration", "Reg plate"),
+ lambda r, p: p["plate"],
+ group="vehicle",
+ ),
+ C(
+ "vin",
+ ("VIN", "Vehicle identification number", "VIN number"),
+ ("VIN", "Vehicle ID", "Chassis number"),
+ lambda r, p: p["vin"],
+ group="vehicle",
+ ),
+ C(
+ "bank",
+ ("Bank name", "Bank", "Financial institution", "Name of bank"),
+ ("Bank", "Institution", "Bank name"),
+ lambda r, p: p["bank"],
+ group="banking",
+ ),
+ C(
+ "account",
+ ("Account number", "Bank account number", "Account #", "Acct number"),
+ ("Account", "Account #", "Acct", "Account number"),
+ lambda r, p: p["account"],
+ group="banking",
+ ),
+ C(
+ "routing",
+ ("Routing number", "ABA routing number", "Routing #", "Sort code"),
+ ("Routing", "ABA", "Routing number", "Sort code"),
+ lambda r, p: p["routing"],
+ group="banking",
+ ),
+ C(
+ "university",
+ ("University", "School", "Institution attended", "College", "School name"),
+ ("University", "School", "College", "Education", "Alma mater"),
+ lambda r, p: p["university"],
+ group="education",
+ ),
+ C(
+ "degree",
+ ("Degree", "Qualification", "Highest degree", "Degree earned"),
+ ("Degree", "Qualification", "Studied"),
+ lambda r, p: p["degree"],
+ group="education",
+ ),
+ C(
+ "grad_year",
+ ("Graduation year", "Year graduated", "Year of graduation"),
+ ("Graduated", "Class of", "Graduation", "Grad year"),
+ lambda r, p: p["grad_year"],
+ group="education",
+ ),
+ C(
+ "reason",
+ (
+ "Reason for visit",
+ "Chief complaint",
+ "Purpose of visit",
+ "Symptoms",
+ "Describe your concern",
+ ),
+ ("Reason", "Complaint", "Reason for visit", "Presenting problem", "Symptoms"),
+ lambda r, p: p["reason"],
+ kind="textarea",
+ group="medical",
+ ),
+ C(
+ "blood",
+ ("Blood type", "Blood group"),
+ ("Blood type", "Blood group", "Blood"),
+ lambda r, p: p["blood"],
+ group="medical",
+ ),
+ C(
+ "allergies",
+ ("Known allergies", "Allergies", "Drug allergies", "List any allergies"),
+ ("Allergies", "Allergic to", "Known allergies"),
+ lambda r, p: p["allergies"],
+ group="medical",
+ ),
+ C(
+ "medications",
+ ("Current medications", "Medications", "Prescriptions", "Medicines taken"),
+ ("Medications", "Meds", "Prescriptions", "Taking"),
+ lambda r, p: p["medications"],
+ group="medical",
+ ),
+ C(
+ "doctor",
+ ("Primary care physician", "Referring doctor", "Doctor's name", "Family doctor", "GP name"),
+ ("Physician", "Doctor", "Referred by", "PCP", "GP"),
+ lambda r, p: p["doctor"],
+ group="medical",
+ ),
+ C(
+ "sex",
+ ("Sex", "Gender", "Sex assigned at birth"),
+ ("Sex", "Gender"),
+ lambda r, p: p["sex"],
+ group="demographic",
+ ),
+ C(
+ "marital",
+ ("Marital status", "Relationship status"),
+ ("Marital status", "Married?", "Status"),
+ lambda r, p: p["marital"],
+ group="demographic",
+ ),
+ C(
+ "nationality",
+ ("Nationality", "Citizenship"),
+ ("Nationality", "Citizen of", "Citizenship"),
+ lambda r, p: p["nationality"],
+ group="demographic",
+ ),
+ C(
+ "tax_id",
+ ("Tax ID", "Taxpayer identification number", "EIN", "Tax number", "TIN"),
+ ("Tax ID", "EIN", "TIN", "Taxpayer ID"),
+ lambda r, p: p["tax_id"],
+ group="business",
+ ),
+ C(
+ "company_reg",
+ ("Company registration number", "Business registration #", "Registration number"),
+ ("Registration", "Reg no", "Company reg", "Business registration"),
+ lambda r, p: p["company_reg"],
+ group="business",
+ ),
+ C(
+ "claim_no",
+ ("Claim number", "Claim #", "Claim reference", "Case number"),
+ ("Claim", "Claim #", "Reference", "Case", "Claim number"),
+ lambda r, p: p["claim_no"],
+ group="claim",
+ ),
+ C(
+ "incident_date",
+ ("Date of incident", "Incident date", "Date of loss", "Accident date", "Date of accident"),
+ ("Incident", "Date of loss", "Occurred", "Accident date", "Date of incident"),
+ lambda r, p: p["incident_date"],
+ group="dates",
+ ),
+ C(
+ "incident_desc",
+ ("Description of incident", "What happened?", "Describe the incident", "Details of loss"),
+ ("Description", "Incident", "What happened", "Details", "Summary"),
+ lambda r, p: p["incident_desc"],
+ kind="textarea",
+ group="claim",
+ ),
+ C(
+ "cover",
+ (
+ "Cover letter",
+ "Why do you want this job?",
+ "Message to hiring manager",
+ "Additional comments",
+ ),
+ ("Cover letter", "Statement", "Note", "Message"),
+ lambda r, p: p["cover"],
+ kind="textarea",
+ group="employment",
+ ),
+]
+
+CONCEPT_BY_KEY = {c.key: c for c in CONCEPTS}
+
+# Fields that appear in forms but never have a document entity: model should skip.
+OPTIONAL_FIELDS = (
+ "Promo code (optional)",
+ "Referral code (optional)",
+ "Coupon code",
+ "Discount code",
+ "How did you hear about us?",
+ "Additional notes (optional)",
+ "Comments",
+ "Middle name (optional)",
+ "Fax number",
+ "Second email (optional)",
+ "Preferred nickname",
+ "Employee ID (staff only)",
+ "Internal reference",
+ "Agent code",
+ "Confirmation code",
+ "CAPTCHA answer",
+ "Voucher",
+)
+
+# Distractor document entities that match no field on the form (or a field on another form).
+DISTRACTOR_ENTITIES = (
+ ("Document ID", lambda r: f"DOC-{_digits(r, 6)}"),
+ ("Printed", lambda r: gen_date(r, 2026, 2026)),
+ ("Page", lambda r: f"1 of {r.randint(1, 4)}"),
+ ("Prepared by", lambda r: f"{r.choice(FIRST_NAMES)} {r.choice(LAST_NAMES)}"),
+ ("Fax", lambda r: gen_phone(r)),
+ ("Height", lambda r: f"{r.randint(150, 195)} cm"),
+ ("Weight", lambda r: f"{r.randint(48, 120)} kg"),
+ ("Case worker", lambda r: f"{r.choice(FIRST_NAMES)} {r.choice(LAST_NAMES)}"),
+ ("Office", lambda r: r.choice(("Downtown", "Eastside", "North campus"))),
+ ("Confidential", lambda r: "Yes"),
+ ("Reference", lambda r: _alnum(r, 8)),
+ ("Signature", lambda r: "on file"),
+ ("Language", lambda r: r.choice(("English", "Spanish", "French"))),
+)
+
+SUBMIT_LABELS = (
+ "Submit",
+ "Submit registration",
+ "Submit application",
+ "Submit form",
+ "Send",
+ "Continue",
+ "Register",
+ "Apply now",
+ "Save and continue",
+ "Complete registration",
+ "Next",
+ "Finish",
+ "Submit claim",
+ "Confirm and submit",
+ "Sign up",
+ "Book appointment",
+ "Create account",
+ "Done",
+)
+NON_SUBMIT_BUTTONS = (
+ "Clear form",
+ "Cancel",
+ "Reset",
+ "Clear",
+ "Discard",
+ "Back",
+ "Previous",
+ "Go back",
+ "Delete draft",
+ "Log out",
+ "Help",
+ "Print blank form",
+ "Upload file",
+ "Add another",
+ "Remove",
+ "Start over",
+ "Report a problem",
+ "Close",
+ "Exit",
+)
+REQUIRED_CHECKBOXES = (
+ "I consent to treatment and agree to the privacy policy",
+ "I agree to the terms and conditions",
+ "I certify the information above is accurate",
+ "I am legally authorized to work in this country",
+ "I have read and accept the privacy notice",
+ "I confirm the details are correct",
+ "I accept the terms of service",
+ "Consent to electronic communication (required)",
+ "I acknowledge the cancellation policy",
+ "I agree to the HIPAA notice",
+ "I authorize verification of the information provided",
+ "I understand this is a binding application",
+)
+OPTIONAL_CHECKBOXES = (
+ "Subscribe to our newsletter",
+ "Send me promotional offers",
+ "Text me appointment reminders",
+ "Share my data with partners",
+ "Remember me on this device",
+ "Join the loyalty program",
+ "I would like to receive marketing email",
+ "Add me to the mailing list",
+ "Sign up for SMS alerts",
+)
+CHROME_ELEMENTS = (
+ ("Button", "Back"),
+ ("Button", "Forward"),
+ ("Button", "Reload"),
+ ("Edit", "Address bar"),
+ ("Button", "Go"),
+ ("Pane", "Page content"),
+ ("ScrollBar", "Vertical"),
+ ("Button", "Line up"),
+ ("Button", "Line down"),
+ ("Button", "Page down"),
+ ("Button", "Page up"),
+ ("TitleBar", ""),
+ ("Button", "Minimise"),
+ ("Button", "Maximise"),
+ ("Button", "Close"),
+ ("MenuItem", "System"),
+ ("Button", "Minimize"),
+ ("Button", "Maximize"),
+ ("Button", "Bookmark this page"),
+ ("Button", "New tab"),
+ ("Button", "Settings and more"),
+ ("Edit", "Search"),
+ ("Button", "Zoom"),
+)
+FORM_TITLES = (
+ "Example Clinic - New Patient Registration",
+ "Example Robotics - Job Application",
+ "Test Insurance - Auto Claim Form",
+ "Example Library - Membership Sign-up",
+ "Test Bank - Direct Deposit Enrollment",
+ "Example Dental - Patient Intake",
+ "Test University - Graduate Application",
+ "Example Utilities - New Service Request",
+ "Test Freight - Vendor Onboarding",
+ "Example Vet - Pet Owner Registration",
+ "Test Rentals - Tenant Application",
+ "Example Travel - Visa Assistance Form",
+ "Test Camp - Parent Consent Form",
+ "Example Telecom - Account Transfer",
+ "Test Pharmacy - Prescription Transfer",
+ "Example Gym - Member Enrollment",
+)
diff --git a/libs/cua-s1/python/src/cua_s1/driver.py b/libs/cua-s1/python/src/cua_s1/driver.py
new file mode 100644
index 0000000000..5031cef185
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/driver.py
@@ -0,0 +1,675 @@
+"""Synchronous, model-agnostic integration with the public Cua Driver tools."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+import subprocess
+import threading
+import time
+from contextlib import AsyncExitStack
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from .schema import Element
+
+DeliveryMode = Literal["background", "foreground"]
+
+
+class DriverError(RuntimeError):
+ """A structured driver failure suitable for an API response."""
+
+ def __init__(
+ self,
+ code: str,
+ message: str,
+ *,
+ tool: str | None = None,
+ details: dict[str, Any] | None = None,
+ outcome_unknown: bool = False,
+ ) -> None:
+ super().__init__(message)
+ self.code = code
+ self.message = message
+ self.tool = tool
+ self.details = details or {}
+ self.outcome_unknown = outcome_unknown
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "code": self.code,
+ "message": self.message,
+ "tool": self.tool,
+ "outcome_unknown": self.outcome_unknown,
+ "details": self.details,
+ }
+
+
+@dataclass(frozen=True)
+class WindowTarget:
+ pid: int
+ window_id: int
+
+ def __post_init__(self) -> None:
+ if (
+ isinstance(self.pid, bool)
+ or isinstance(self.window_id, bool)
+ or not isinstance(self.pid, int)
+ or not isinstance(self.window_id, int)
+ or self.pid <= 0
+ or self.window_id <= 0
+ ):
+ raise ValueError("pid and window_id must be positive")
+
+ def to_driver_target(self) -> dict[str, Any]:
+ return {"kind": "window", "pid": self.pid, "window_id": self.window_id}
+
+
+@dataclass
+class WindowSnapshot:
+ target: WindowTarget
+ elements: list[Element]
+ snapshot_id: str | None
+ tree_markdown: str
+ elements_complete: bool | None
+ raw: dict[str, Any] = field(repr=False)
+
+ def require_executable(self) -> None:
+ """Refuse element actions unless the observation is complete and bound."""
+
+ if not self.snapshot_id:
+ raise DriverError(
+ "snapshot_id_required",
+ "Execution requires a snapshot-bound window observation",
+ )
+ if self.elements_complete is not True:
+ raise DriverError(
+ "incomplete_window_snapshot",
+ "Execution requires a complete accessibility element snapshot",
+ details={"elements_complete": self.elements_complete},
+ )
+
+ def element_for(self, element: Element) -> Element:
+ """Resolve the planned element in this snapshot without exposing raw state."""
+
+ self.require_executable()
+ matches = [candidate for candidate in self.elements if candidate.index == element.index]
+ if len(matches) != 1:
+ raise DriverError(
+ "element_not_uniquely_resolved",
+ "The planned element is not unique in the fresh window snapshot",
+ details={"element_index": element.index, "matches": len(matches)},
+ )
+ current = matches[0]
+ if current.role != element.role or current.label != element.label:
+ semantic_matches = [
+ candidate
+ for candidate in self.elements
+ if candidate.role == element.role and candidate.label == element.label
+ ]
+ if len(semantic_matches) != 1:
+ raise DriverError(
+ "element_identity_changed",
+ "The planned element could not be uniquely identified after re-observation",
+ details={
+ "element_index": element.index,
+ "role": element.role,
+ "label": element.label,
+ "matches": len(semantic_matches),
+ },
+ )
+ current = semantic_matches[0]
+ return current
+
+ def token_for(self, element: Element) -> str:
+ """Resolve an element only within this snapshot, never by bare index."""
+
+ current = self.element_for(element)
+ if not current.element_token:
+ raise DriverError(
+ "element_token_missing",
+ "Cua Driver did not provide a snapshot-bound token for the element",
+ details={
+ "element_index": current.index,
+ "role": current.role,
+ "label": current.label,
+ },
+ )
+ return current.element_token
+
+
+@dataclass
+class MutationResult:
+ action: dict[str, Any]
+ observation: WindowSnapshot
+
+
+class BaseDriver:
+ def __init__(self, session: str = "cua-s1", timeout_seconds: float = 120.0) -> None:
+ self.session = session
+ self.timeout_seconds = timeout_seconds
+ self.timings: list[dict[str, Any]] = []
+ self._available_tools: set[str] | None = None
+
+ def call(self, tool: str, **args: Any) -> dict[str, Any]: # pragma: no cover - abstract
+ raise NotImplementedError
+
+ def start_session(self) -> dict[str, Any]:
+ return self.call("start_session", session=self.session)
+
+ def end_session(self) -> dict[str, Any]:
+ return self.call("end_session", session=self.session)
+
+ def list_windows(self, pid: int | None = None) -> list[dict[str, Any]]:
+ result = self.call("list_windows", pid=pid, on_screen_only=True)
+ windows = result.get("windows")
+ if not isinstance(windows, list):
+ raise DriverError(
+ "invalid_driver_response",
+ "list_windows did not return a windows array",
+ tool="list_windows",
+ details={"response": _bounded_repr(result)},
+ )
+ return windows
+
+ def find_window(
+ self,
+ title_contains: str | None = None,
+ pid: int | None = None,
+ window_id: int | None = None,
+ ) -> dict[str, Any]:
+ """Return exactly one on-screen window; ambiguity is a hard failure."""
+
+ windows = self.list_windows(pid)
+ if window_id is not None:
+ windows = [window for window in windows if window.get("window_id") == window_id]
+ if title_contains:
+ needle = title_contains.casefold()
+ windows = [
+ window for window in windows if needle in str(window.get("title") or "").casefold()
+ ]
+ windows = [window for window in windows if window.get("is_on_screen", True)]
+ selector = {"title_contains": title_contains, "pid": pid, "window_id": window_id}
+ if not windows:
+ raise DriverError(
+ "window_not_found", "No window matched the requested target", details=selector
+ )
+ if len(windows) != 1:
+ raise DriverError(
+ "ambiguous_window",
+ "More than one window matched; provide an exact pid and window_id",
+ details={
+ **selector,
+ "matches": [
+ {
+ "pid": window.get("pid"),
+ "window_id": window.get("window_id"),
+ "app_name": window.get("app_name"),
+ "title": window.get("title"),
+ }
+ for window in windows
+ ],
+ },
+ )
+ return windows[0]
+
+ def window_state(self, target: WindowTarget) -> WindowSnapshot:
+ state = self.call(
+ "get_window_state",
+ pid=target.pid,
+ window_id=target.window_id,
+ session=self.session,
+ include_accessibility_tree=True,
+ include_screenshot=False,
+ )
+ raw_elements = state.get("elements")
+ if not isinstance(raw_elements, list):
+ raise DriverError(
+ "window_elements_unavailable",
+ "The exact window snapshot did not include structured accessibility elements",
+ tool="get_window_state",
+ details={
+ "target": target.to_driver_target(),
+ "degradation": state.get("degradation"),
+ "response": _bounded_repr(state),
+ },
+ )
+ markdown = str(state.get("tree_markdown") or "")
+ elements = [_element_from_driver(raw, markdown) for raw in raw_elements]
+ return WindowSnapshot(
+ target=target,
+ elements=elements,
+ snapshot_id=_optional_string(state.get("snapshot_id")),
+ tree_markdown=markdown,
+ elements_complete=state.get("elements_complete")
+ if isinstance(state.get("elements_complete"), bool)
+ else None,
+ raw=state,
+ )
+
+ def supports_value_mutation(self) -> bool:
+ """Return whether value mutation is injected or runtime-advertised.
+
+ ``set_value`` is optional and intentionally absent from the portable
+ manifest contract. A subclass override is an explicit host injection;
+ transport drivers fail closed unless live discovery advertises it.
+ """
+
+ if type(self).set_value is not BaseDriver.set_value:
+ return True
+ return self._available_tools is not None and "set_value" in self._available_tools
+
+ def set_value(self, target: WindowTarget, element_token: str, value: str) -> MutationResult:
+ """Replace an AX/UIA/AT-SPI value, then re-observe the exact window.
+
+ The public ``set_value`` tool is an accessibility-addressed background
+ operation and does not expose the pointer delivery-mode field.
+ """
+
+ if not self.supports_value_mutation():
+ raise DriverError(
+ "unsupported_driver_capability",
+ "The connected Cua Driver runtime did not advertise token-based set_value",
+ tool="set_value",
+ )
+ return self._mutate_then_observe(
+ "set_value",
+ target,
+ pid=target.pid,
+ window_id=target.window_id,
+ element_token=_require_token(element_token),
+ value=value,
+ session=self.session,
+ )
+
+ def click(
+ self,
+ target: WindowTarget,
+ element_token: str,
+ *,
+ delivery_mode: DeliveryMode,
+ ) -> MutationResult:
+ if delivery_mode not in ("background", "foreground"):
+ raise DriverError(
+ "invalid_delivery_mode",
+ "delivery_mode must be 'background' or 'foreground'",
+ tool="click",
+ details={"delivery_mode": delivery_mode},
+ )
+ return self._mutate_then_observe(
+ "click",
+ target,
+ target=target.to_driver_target(),
+ element_token=_require_token(element_token),
+ delivery_mode=delivery_mode,
+ session=self.session,
+ button="left",
+ count=1,
+ )
+
+ def _mutate_then_observe(
+ self,
+ tool: str,
+ window_target: WindowTarget,
+ **payload: Any,
+ ) -> MutationResult:
+ try:
+ action = self.call(tool, **payload)
+ except DriverError as exc:
+ # A timeout or transport failure may occur after delivery. Always
+ # refresh state before exposing the unknown outcome to the caller.
+ try:
+ observation = self.window_state(window_target)
+ exc.details["post_action_observation"] = _snapshot_summary(observation)
+ except DriverError as observe_error:
+ exc.details["observation_error"] = observe_error.to_dict()
+ raise
+ observation = self.window_state(window_target)
+ effect = action.get("effect")
+ if effect != "confirmed":
+ raise DriverError(
+ "action_effect_unconfirmed",
+ "Cua Driver did not confirm the action effect",
+ tool=tool,
+ details={
+ "effect": effect if isinstance(effect, str) else "missing",
+ "route": action.get("route"),
+ "escalation": action.get("escalation"),
+ "post_action_observation": _snapshot_summary(observation),
+ },
+ outcome_unknown=effect not in {"refused", "suspected_noop"},
+ )
+ return MutationResult(action=action, observation=observation)
+
+ def close(self) -> None:
+ return None
+
+
+class CliDriver(BaseDriver):
+ def __init__(
+ self,
+ session: str = "cua-s1",
+ binary: str | None = None,
+ timeout_seconds: float = 120.0,
+ ) -> None:
+ super().__init__(session, timeout_seconds)
+ self.binary = binary or shutil.which("cua-driver") or "cua-driver"
+ self._available_tools = self._discover_tools()
+
+ def _discover_tools(self) -> set[str] | None:
+ try:
+ process = subprocess.run(
+ [self.binary, "list-tools"],
+ capture_output=True,
+ text=True,
+ encoding="utf-8",
+ errors="replace",
+ timeout=min(self.timeout_seconds, 30.0),
+ check=False,
+ )
+ except (OSError, subprocess.TimeoutExpired):
+ return None
+ if process.returncode != 0:
+ return None
+ return {
+ line.split(":", 1)[0].strip()
+ for line in process.stdout.splitlines()
+ if line.split(":", 1)[0].strip()
+ }
+
+ def call(self, tool: str, **args: Any) -> dict[str, Any]:
+ payload = {key: value for key, value in args.items() if value is not None}
+ started = time.perf_counter()
+ try:
+ process = subprocess.run(
+ [self.binary, "call", tool],
+ input=json.dumps(payload),
+ capture_output=True,
+ text=True,
+ encoding="utf-8",
+ errors="replace",
+ timeout=self.timeout_seconds,
+ check=False,
+ )
+ except subprocess.TimeoutExpired as exc:
+ raise DriverError(
+ "driver_timeout",
+ f"Cua Driver tool '{tool}' timed out",
+ tool=tool,
+ outcome_unknown=True,
+ ) from exc
+ except OSError as exc:
+ raise DriverError(
+ "driver_unavailable",
+ "Could not start the Cua Driver CLI",
+ tool=tool,
+ details={"binary": self.binary},
+ ) from exc
+ finally:
+ self.timings.append(
+ {"tool": tool, "ms": round((time.perf_counter() - started) * 1000, 1)}
+ )
+
+ stdout = process.stdout.strip()
+ data = _parse(stdout)
+ if process.returncode != 0:
+ raise DriverError(
+ "driver_tool_failed",
+ f"Cua Driver tool '{tool}' failed",
+ tool=tool,
+ details={
+ "returncode": process.returncode,
+ "stderr": process.stderr.strip()[:1000],
+ "response": _bounded_repr(data),
+ },
+ )
+ if _response_is_error(data):
+ raise DriverError(
+ "driver_tool_refused",
+ f"Cua Driver tool '{tool}' refused the request",
+ tool=tool,
+ details={"response": data},
+ )
+ return data
+
+
+class McpDriver(BaseDriver):
+ """One persistent ``cua-driver mcp`` process behind a synchronous facade."""
+
+ def __init__(
+ self,
+ session: str = "cua-s1",
+ binary: str | None = None,
+ timeout_seconds: float = 120.0,
+ ) -> None:
+ super().__init__(session, timeout_seconds)
+ self.binary = binary or shutil.which("cua-driver") or "cua-driver"
+ self._loop = asyncio.new_event_loop()
+ self._thread = threading.Thread(target=self._loop.run_forever, daemon=True)
+ self._thread.start()
+ self._session: Any = None
+ self._stack: AsyncExitStack | None = None
+ try:
+ self._run(self._connect())
+ except Exception:
+ self._loop.call_soon_threadsafe(self._loop.stop)
+ self._thread.join(timeout=1)
+ raise
+
+ def _run(self, coroutine: Any) -> Any:
+ future = asyncio.run_coroutine_threadsafe(coroutine, self._loop)
+ try:
+ return future.result(timeout=self.timeout_seconds)
+ except TimeoutError as exc:
+ future.cancel()
+ raise DriverError("driver_timeout", "Cua Driver MCP operation timed out") from exc
+
+ async def _connect(self) -> None:
+ try:
+ from mcp import ClientSession, StdioServerParameters
+ from mcp.client.stdio import stdio_client
+ except ImportError as exc:
+ raise DriverError(
+ "mcp_dependency_missing",
+ "The MCP transport requires the optional 'mcp' dependency",
+ ) from exc
+
+ self._stack = AsyncExitStack()
+ read, write = await self._stack.enter_async_context(
+ stdio_client(StdioServerParameters(command=self.binary, args=["mcp"]))
+ )
+ self._session = await self._stack.enter_async_context(ClientSession(read, write))
+ await self._session.initialize()
+ tools_result = await self._session.list_tools()
+ self._available_tools = {
+ str(tool.name)
+ for tool in getattr(tools_result, "tools", ())
+ if getattr(tool, "name", None)
+ }
+
+ async def _call(self, tool: str, payload: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+ result = await self._session.call_tool(tool, payload)
+ structured = getattr(result, "structuredContent", None)
+ if structured is None:
+ structured = getattr(result, "structured_content", None)
+ if structured is not None:
+ data = structured if isinstance(structured, dict) else {"data": structured}
+ else:
+ text = "\n".join(
+ str(getattr(content, "text", ""))
+ for content in result.content
+ if getattr(content, "text", None)
+ )
+ data = _parse(text)
+ is_error = bool(getattr(result, "isError", getattr(result, "is_error", False)))
+ return data, is_error
+
+ def call(self, tool: str, **args: Any) -> dict[str, Any]:
+ payload = {key: value for key, value in args.items() if value is not None}
+ started = time.perf_counter()
+ try:
+ data, is_error = self._run(self._call(tool, payload))
+ except DriverError:
+ raise
+ except Exception as exc:
+ raise DriverError(
+ "driver_transport_failed",
+ f"Cua Driver MCP call '{tool}' failed",
+ tool=tool,
+ details={"error_type": type(exc).__name__, "error": str(exc)[:1000]},
+ outcome_unknown=True,
+ ) from exc
+ finally:
+ self.timings.append(
+ {"tool": tool, "ms": round((time.perf_counter() - started) * 1000, 1)}
+ )
+ if is_error or _response_is_error(data):
+ raise DriverError(
+ "driver_tool_refused",
+ f"Cua Driver tool '{tool}' refused the request",
+ tool=tool,
+ details={"response": data},
+ )
+ return data
+
+ def close(self) -> None:
+ if self._stack is not None:
+ try:
+ self._run(self._stack.aclose())
+ except Exception:
+ pass
+ self._loop.call_soon_threadsafe(self._loop.stop)
+ self._thread.join(timeout=1)
+
+
+def CuaDriver(
+ session: str = "cua-s1",
+ transport: Literal["auto", "mcp", "cli"] = "auto",
+ *,
+ binary: str | None = None,
+ timeout_seconds: float = 120.0,
+) -> BaseDriver:
+ """Create a driver without coupling the runtime to any inference model."""
+
+ if transport not in ("auto", "mcp", "cli"):
+ raise ValueError("transport must be 'auto', 'mcp', or 'cli'")
+ if transport in ("auto", "mcp"):
+ try:
+ return McpDriver(session, binary=binary, timeout_seconds=timeout_seconds)
+ except Exception:
+ if transport == "mcp":
+ raise
+ return CliDriver(session, binary=binary, timeout_seconds=timeout_seconds)
+
+
+def target_from_window(window: dict[str, Any]) -> WindowTarget:
+ try:
+ return WindowTarget(pid=int(window["pid"]), window_id=int(window["window_id"]))
+ except (KeyError, TypeError, ValueError) as exc:
+ raise DriverError(
+ "invalid_window_record",
+ "Window record lacks a valid pid and window_id",
+ details={"window": _bounded_repr(window)},
+ ) from exc
+
+
+def _element_from_driver(raw: Any, markdown: str) -> Element:
+ if not isinstance(raw, dict):
+ raise DriverError(
+ "invalid_driver_response",
+ "Window element was not an object",
+ tool="get_window_state",
+ details={"element": _bounded_repr(raw)},
+ )
+ try:
+ index = int(raw["element_index"])
+ except (KeyError, TypeError, ValueError) as exc:
+ raise DriverError(
+ "invalid_driver_response",
+ "Window element lacked a valid element_index",
+ tool="get_window_state",
+ details={"element": _bounded_repr(raw)},
+ ) from exc
+ value = str(raw.get("value") or _value_from_markdown(markdown, index))
+ return Element(
+ role=str(raw.get("role") or ""),
+ label=str(raw.get("label") or ""),
+ value=value,
+ index=index,
+ actions=tuple(str(action) for action in (raw.get("actions") or ())),
+ checked=_checked(raw),
+ frame=_frame(raw),
+ element_token=_optional_string(raw.get("element_token")),
+ )
+
+
+def _parse(text: str) -> dict[str, Any]:
+ if not text.strip():
+ return {}
+ try:
+ value = json.loads(text)
+ except json.JSONDecodeError:
+ return {"text": text.strip()}
+ return value if isinstance(value, dict) else {"data": value}
+
+
+def _response_is_error(data: dict[str, Any]) -> bool:
+ return data.get("isError") is True or data.get("is_error") is True or "error" in data
+
+
+def _frame(raw: dict[str, Any]) -> tuple[int, int, int, int] | None:
+ frame = raw.get("frame") or {}
+ if not isinstance(frame, dict) or not frame:
+ return None
+ width = frame.get("width", frame.get("w", 0))
+ height = frame.get("height", frame.get("h", 0))
+ try:
+ return int(frame.get("x", 0)), int(frame.get("y", 0)), int(width), int(height)
+ except (TypeError, ValueError):
+ return None
+
+
+def _checked(raw: dict[str, Any]) -> bool | None:
+ for key in ("toggle_state", "checked", "selected", "state"):
+ value = raw.get(key)
+ if isinstance(value, bool):
+ return value
+ if isinstance(value, str):
+ lowered = value.casefold()
+ if lowered in {"on", "checked", "true", "selected"}:
+ return True
+ if lowered in {"off", "unchecked", "false", "unselected"}:
+ return False
+ return None
+
+
+def _value_from_markdown(markdown: str, index: int) -> str:
+ tag = f"[{index}] "
+ for line in markdown.splitlines():
+ if tag in line and '[value="' in line:
+ return line.split('[value="', 1)[1].split('"', 1)[0]
+ return ""
+
+
+def _optional_string(value: Any) -> str | None:
+ return value if isinstance(value, str) and value else None
+
+
+def _require_token(token: str) -> str:
+ if not isinstance(token, str) or not token.strip():
+ raise DriverError("element_token_missing", "A snapshot-bound element token is required")
+ return token
+
+
+def _bounded_repr(value: Any, limit: int = 1000) -> str:
+ return repr(value)[:limit]
+
+
+def _snapshot_summary(snapshot: WindowSnapshot) -> dict[str, Any]:
+ return {
+ "target": snapshot.target.to_driver_target(),
+ "snapshot_id": snapshot.snapshot_id,
+ "element_count": len(snapshot.elements),
+ "elements_complete": snapshot.elements_complete,
+ }
diff --git a/libs/cua-s1/python/src/cua_s1/model.py b/libs/cua-s1/python/src/cua_s1/model.py
new file mode 100644
index 0000000000..34fa8c474e
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/model.py
@@ -0,0 +1,324 @@
+"""One-pass option scorers and safe checkpoint integration for Cua-S1."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+from torch import nn
+
+from .checkpoint import load_checkpoint_files, save_checkpoint_files
+
+# AttentionHead, TinyScorer, and the byte collation shape are adapted from
+# jevlike commit 94f5fd1 (MIT, Copyright 2026 Minimal Labs). They live here so
+# Cua-S1 does not depend on an unpinned source checkout at runtime.
+
+TensorBatch = dict[str, torch.Tensor]
+
+
+@dataclass(frozen=True)
+class ChoiceExample:
+ """A context, its available options, and the selected option index."""
+
+ context: str
+ options: tuple[str, ...]
+ label: int
+
+
+def validate_example(payload: Mapping[str, Any]) -> ChoiceExample:
+ """Validate a JSON-compatible choice example."""
+ context = payload.get("context")
+ options = payload.get("options")
+ label = payload.get("label")
+ if not isinstance(context, str):
+ raise ValueError("choice context must be a string")
+ if not isinstance(options, (list, tuple)) or len(options) < 2:
+ raise ValueError("choice options must contain at least two strings")
+ if any(not isinstance(option, str) or not option for option in options):
+ raise ValueError("choice options must be non-empty strings")
+ if not isinstance(label, int) or isinstance(label, bool) or not 0 <= label < len(options):
+ raise ValueError("choice label must be a valid option index")
+ return ChoiceExample(context=context, options=tuple(options), label=label)
+
+
+def _byte_ids(text: str, length: int) -> list[int]:
+ return [byte + 1 for byte in text.encode("utf-8", errors="replace")[:length]]
+
+
+class ByteCollator:
+ """Collate variable-length text choices into padded UTF-8 byte tensors."""
+
+ def __init__(self, context_tokens: int, option_tokens: int) -> None:
+ if context_tokens <= 0 or option_tokens <= 0:
+ raise ValueError("token limits must be positive")
+ self.context_tokens = context_tokens
+ self.option_tokens = option_tokens
+
+ def __call__(self, examples: Sequence[ChoiceExample]) -> TensorBatch:
+ if not examples:
+ raise ValueError("cannot collate an empty batch")
+ contexts = [_byte_ids(item.context, self.context_tokens) for item in examples]
+ option_rows = [
+ [_byte_ids(option, self.option_tokens) for option in item.options] for item in examples
+ ]
+ return _tensor_batch(examples, contexts, option_rows, pad_id=0)
+
+
+def _tensor_batch(
+ examples: Sequence[ChoiceExample],
+ contexts: Sequence[Sequence[int]],
+ option_rows: Sequence[Sequence[Sequence[int]]],
+ pad_id: int,
+) -> TensorBatch:
+ batch = len(examples)
+ max_context = max(1, max(map(len, contexts)))
+ max_options = max(len(row) for row in option_rows)
+ max_option_tokens = max(1, max(len(tokens) for row in option_rows for tokens in row))
+ context_ids = torch.full((batch, max_context), pad_id, dtype=torch.long)
+ option_ids = torch.full((batch, max_options, max_option_tokens), pad_id, dtype=torch.long)
+ option_mask = torch.zeros((batch, max_options), dtype=torch.bool)
+ for row, tokens in enumerate(contexts):
+ if tokens:
+ context_ids[row, : len(tokens)] = torch.tensor(tokens, dtype=torch.long)
+ for row, options in enumerate(option_rows):
+ option_mask[row, : len(options)] = True
+ for column, tokens in enumerate(options):
+ if tokens:
+ option_ids[row, column, : len(tokens)] = torch.tensor(tokens, dtype=torch.long)
+ return {
+ "context_ids": context_ids,
+ "context_mask": context_ids.ne(pad_id),
+ "option_ids": option_ids,
+ "option_token_mask": option_ids.ne(pad_id),
+ "option_mask": option_mask,
+ "labels": torch.tensor([item.label for item in examples], dtype=torch.long),
+ }
+
+
+class AttentionHead(nn.Module):
+ """Turn context tokens and option vectors into one score per option."""
+
+ def __init__(self, input_width: int, rank: int) -> None:
+ super().__init__()
+ if input_width <= 0 or rank <= 0:
+ raise ValueError("input width and attention rank must be positive")
+ self.context_norm = nn.LayerNorm(input_width)
+ self.option_norm = nn.LayerNorm(input_width)
+ self.query = nn.Linear(input_width, rank, bias=False)
+ self.key = nn.Linear(input_width, rank, bias=False)
+ self.value = nn.Linear(input_width, rank, bias=False)
+ self.rank = rank
+
+ def forward(
+ self,
+ context: torch.Tensor,
+ context_mask: torch.Tensor,
+ options: torch.Tensor,
+ option_mask: torch.Tensor,
+ shuffle_context: bool = False,
+ ) -> torch.Tensor:
+ context = self.context_norm(context.float())
+ options = self.option_norm(options.float())
+ if shuffle_context and context.shape[0] > 1:
+ context = context.roll(1, dims=0)
+ context_mask = context_mask.roll(1, dims=0)
+ query = self.query(options)
+ key = self.key(context)
+ value = self.value(context)
+ scores = torch.einsum("bnr,blr->bnl", query, key) / math.sqrt(self.rank)
+ scores = scores.masked_fill(~context_mask[:, None, :], torch.finfo(scores.dtype).min)
+ attended = torch.einsum("bnl,blr->bnr", scores.softmax(-1), value)
+ logits = (query * attended).sum(-1) / math.sqrt(self.rank)
+ return logits.masked_fill(~option_mask, torch.finfo(logits.dtype).min)
+
+
+class TinyScorer(nn.Module):
+ """Byte embedding scorer with mean-pooled option representations."""
+
+ def __init__(self, width: int, rank: int, context_tokens: int) -> None:
+ super().__init__()
+ if context_tokens <= 0:
+ raise ValueError("context token limit must be positive")
+ self.embedding = nn.Embedding(257, width, padding_idx=0)
+ self.position = nn.Embedding(context_tokens, width)
+ self.head = AttentionHead(width, rank)
+
+ def forward(self, batch: TensorBatch, shuffle_context: bool = False) -> torch.Tensor:
+ context_ids = batch["context_ids"]
+ positions = torch.arange(context_ids.shape[1], device=context_ids.device)
+ context = self.embedding(context_ids) + self.position(positions)
+ option_tokens = self.embedding(batch["option_ids"])
+ weights = batch["option_token_mask"].unsqueeze(-1)
+ options = (option_tokens * weights).sum(2) / weights.sum(2).clamp_min(1)
+ return self.head(
+ context,
+ batch["context_mask"],
+ options,
+ batch["option_mask"],
+ shuffle_context,
+ )
+
+
+class TinyTransformerScorer(nn.Module):
+ """Byte scorer with contextual encoders for contexts and options."""
+
+ def __init__(
+ self,
+ width: int,
+ rank: int,
+ context_tokens: int,
+ option_tokens: int,
+ layers: int = 2,
+ heads: int = 4,
+ dropout: float = 0.1,
+ ) -> None:
+ super().__init__()
+ if min(width, rank, context_tokens, option_tokens, layers, heads) <= 0:
+ raise ValueError("model dimensions and layer counts must be positive")
+ if width % heads:
+ raise ValueError("model width must be divisible by attention heads")
+ if not 0.0 <= dropout < 1.0:
+ raise ValueError("dropout must be in [0, 1)")
+ self.embedding = nn.Embedding(257, width, padding_idx=0)
+ self.position = nn.Embedding(max(context_tokens, option_tokens), width)
+ layer = nn.TransformerEncoderLayer(
+ width,
+ heads,
+ width * 4,
+ dropout,
+ batch_first=True,
+ norm_first=True,
+ )
+ self.encoder = nn.TransformerEncoder(layer, layers)
+ option_layer = nn.TransformerEncoderLayer(
+ width,
+ heads,
+ width * 4,
+ dropout,
+ batch_first=True,
+ norm_first=True,
+ )
+ self.option_encoder = nn.TransformerEncoder(option_layer, 1)
+ self.head = AttentionHead(width, rank)
+
+ def _embed(self, ids: torch.Tensor) -> torch.Tensor:
+ positions = torch.arange(ids.shape[-1], device=ids.device)
+ return self.embedding(ids) + self.position(positions)
+
+ def forward(self, batch: TensorBatch, shuffle_context: bool = False) -> torch.Tensor:
+ context_mask = batch["context_mask"]
+ safe_context_mask = context_mask.clone()
+ safe_context_mask[:, 0] = True
+ context = self.encoder(
+ self._embed(batch["context_ids"]),
+ src_key_padding_mask=~safe_context_mask,
+ )
+ option_ids = batch["option_ids"]
+ batch_size, option_count, token_count = option_ids.shape
+ flat_ids = option_ids.reshape(batch_size * option_count, token_count)
+ flat_mask = batch["option_token_mask"].reshape(batch_size * option_count, token_count)
+ safe_mask = flat_mask.clone()
+ safe_mask[:, 0] = True
+ hidden = self.option_encoder(self._embed(flat_ids), src_key_padding_mask=~safe_mask)
+ weights = flat_mask.unsqueeze(-1).float()
+ pooled = (hidden * weights).sum(1) / weights.sum(1).clamp_min(1)
+ options = pooled.reshape(batch_size, option_count, -1)
+ return self.head(
+ context,
+ context_mask,
+ options,
+ batch["option_mask"],
+ shuffle_context,
+ )
+
+
+def select_device(name: str = "auto") -> torch.device:
+ """Resolve an explicit device or select the best available local device."""
+ if name != "auto":
+ return torch.device(name)
+ if torch.cuda.is_available():
+ return torch.device("cuda")
+ if torch.backends.mps.is_available():
+ return torch.device("mps")
+ return torch.device("cpu")
+
+
+def _positive_int(config: Mapping[str, Any], key: str) -> int:
+ value = config.get(key)
+ if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+ raise ValueError(f"model config field {key!r} must be a positive integer")
+ return value
+
+
+def make_system(
+ config: Mapping[str, Any], device: torch.device | str
+) -> tuple[nn.Module, ByteCollator]:
+ """Construct a scorer and matching collator from validated configuration."""
+ target = select_device(device) if isinstance(device, str) else device
+ encoder = config.get("encoder")
+ rank = _positive_int(config, "rank")
+ context_tokens = _positive_int(config, "context_tokens")
+ option_tokens = _positive_int(config, "option_tokens")
+ if encoder == "tiny":
+ model: nn.Module = TinyScorer(_positive_int(config, "width"), rank, context_tokens)
+ collator = ByteCollator(context_tokens, option_tokens)
+ elif encoder == "tinyx":
+ model = TinyTransformerScorer(
+ _positive_int(config, "width"),
+ rank,
+ context_tokens,
+ option_tokens,
+ int(config.get("layers", 2)),
+ int(config.get("heads", 4)),
+ float(config.get("dropout", 0.1)),
+ )
+ collator = ByteCollator(context_tokens, option_tokens)
+ else:
+ raise ValueError("model config field 'encoder' must be 'tiny' or 'tinyx'")
+ return model.to(target), collator
+
+
+def trainable_state(model: nn.Module) -> dict[str, torch.Tensor]:
+ """Copy trainable parameters to contiguous CPU tensors."""
+ return {
+ name: parameter.detach().cpu().contiguous()
+ for name, parameter in model.named_parameters()
+ if parameter.requires_grad
+ }
+
+
+def save_checkpoint(
+ directory_or_path: str | Path,
+ model: nn.Module,
+ config: Mapping[str, Any],
+ metadata: Mapping[str, Any] | None = None,
+) -> tuple[Path, Path]:
+ """Save trainable model state as safetensors with a JSON configuration."""
+ return save_checkpoint_files(directory_or_path, trainable_state(model), config, metadata)
+
+
+def load_checkpoint(
+ directory_or_path: str | Path, device: torch.device | str
+) -> tuple[nn.Module, ByteCollator, dict[str, Any]]:
+ """Load a model from safetensors and JSON without executing serialized code."""
+ state_dict, config, _metadata = load_checkpoint_files(directory_or_path)
+ model, collator = make_system(config, device)
+ try:
+ missing, unexpected = model.load_state_dict(state_dict, strict=False)
+ except RuntimeError as exc:
+ raise ValueError(f"checkpoint tensor mismatch: {exc}") from exc
+ if missing or unexpected:
+ raise ValueError(
+ f"checkpoint mismatch: missing={list(missing)}, unexpected={list(unexpected)}"
+ )
+ model.eval()
+ return model, collator, config
+
+
+def parameter_count(model: nn.Module) -> int:
+ """Return the number of trainable scalar parameters."""
+ return sum(parameter.numel() for parameter in model.parameters() if parameter.requires_grad)
diff --git a/libs/cua-s1/python/src/cua_s1/pdf.py b/libs/cua-s1/python/src/cua_s1/pdf.py
new file mode 100644
index 0000000000..88e793d782
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/pdf.py
@@ -0,0 +1,241 @@
+"""Bounded extraction of labelled entities from PDF documents."""
+
+from __future__ import annotations
+
+import io
+import os
+import re
+import stat
+from pathlib import Path
+from typing import Any, Iterable
+
+from .schema import Entity
+
+DEFAULT_MAX_BYTES = 25 * 1024 * 1024
+DEFAULT_MAX_PAGES = 100
+DEFAULT_MAX_VALUE_LENGTH = 120
+
+LINE = re.compile(r"^\s*([A-Za-z][A-Za-z0-9 .'/#&()-]{1,40}?)\s*[:\u2013-]\s+(.+?)\s*$")
+
+
+class PdfError(RuntimeError):
+ """A stable, serializable PDF validation or extraction failure."""
+
+ def __init__(self, code: str, message: str, **details: Any) -> None:
+ super().__init__(message)
+ self.code = code
+ self.message = message
+ self.details = details
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "code": self.code,
+ "message": self.message,
+ "details": self.details,
+ }
+
+
+def resolve_pdf_path(
+ pdf_path: str | Path,
+ *,
+ allowed_roots: Iterable[str | Path] | None = None,
+ base_dir: str | Path | None = None,
+ max_bytes: int = DEFAULT_MAX_BYTES,
+) -> Path:
+ """Resolve a PDF below an allowed root and enforce basic resource bounds.
+
+ With no explicit roots, access is confined to ``base_dir`` or the current
+ working directory. Symlinks are resolved before the containment check.
+ """
+
+ if max_bytes <= 0:
+ raise PdfError("invalid_limit", "max_bytes must be positive", max_bytes=max_bytes)
+
+ base = Path(base_dir or Path.cwd()).expanduser().resolve()
+ roots = tuple(Path(root).expanduser().resolve() for root in (allowed_roots or (base,)))
+ if not roots:
+ raise PdfError("no_allowed_roots", "At least one allowed PDF root is required")
+
+ candidate = Path(pdf_path).expanduser()
+ if not candidate.is_absolute():
+ candidate = base / candidate
+ try:
+ candidate = candidate.resolve(strict=True)
+ except (OSError, RuntimeError) as exc:
+ raise PdfError(
+ "pdf_not_found", "PDF path could not be resolved", path=str(pdf_path)
+ ) from exc
+
+ if not any(candidate == root or candidate.is_relative_to(root) for root in roots):
+ raise PdfError(
+ "pdf_path_not_allowed",
+ "PDF path is outside the configured allowed roots",
+ path=str(candidate),
+ allowed_roots=[str(root) for root in roots],
+ )
+ if candidate.suffix.lower() != ".pdf":
+ raise PdfError("invalid_pdf_extension", "Only .pdf files are accepted", path=str(candidate))
+ if not candidate.is_file():
+ raise PdfError("pdf_not_file", "PDF path is not a regular file", path=str(candidate))
+
+ try:
+ size = candidate.stat().st_size
+ except OSError as exc:
+ raise PdfError(
+ "pdf_stat_failed", "Could not inspect PDF size", path=str(candidate)
+ ) from exc
+ if size > max_bytes:
+ raise PdfError(
+ "pdf_too_large",
+ "PDF exceeds the configured byte limit",
+ path=str(candidate),
+ size_bytes=size,
+ max_bytes=max_bytes,
+ )
+ return candidate
+
+
+def extract_entities(
+ pdf_path: str | Path,
+ *,
+ allowed_roots: Iterable[str | Path] | None = None,
+ base_dir: str | Path | None = None,
+ max_bytes: int = DEFAULT_MAX_BYTES,
+ max_pages: int = DEFAULT_MAX_PAGES,
+ max_value_length: int = DEFAULT_MAX_VALUE_LENGTH,
+) -> list[Entity]:
+ """Extract ``Label: value`` pairs without allowing unbounded file access."""
+
+ if max_pages <= 0 or max_value_length <= 0:
+ raise PdfError(
+ "invalid_limit",
+ "max_pages and max_value_length must be positive",
+ max_pages=max_pages,
+ max_value_length=max_value_length,
+ )
+ path = resolve_pdf_path(
+ pdf_path,
+ allowed_roots=allowed_roots,
+ base_dir=base_dir,
+ max_bytes=max_bytes,
+ )
+
+ try:
+ import pdfplumber
+ except ImportError as exc: # pragma: no cover - depends on optional runtime extra
+ raise PdfError(
+ "pdf_dependency_missing",
+ "PDF extraction requires the optional 'pdfplumber' dependency",
+ ) from exc
+
+ data = _read_validated_pdf(path, max_bytes=max_bytes)
+ entities: list[Entity] = []
+ seen: set[tuple[str, str]] = set()
+ try:
+ with pdfplumber.open(io.BytesIO(data)) as pdf:
+ if len(pdf.pages) > max_pages:
+ raise PdfError(
+ "pdf_too_many_pages",
+ "PDF exceeds the configured page limit",
+ path=str(path),
+ pages=len(pdf.pages),
+ max_pages=max_pages,
+ )
+ for page in pdf.pages:
+ for line in (page.extract_text() or "").splitlines():
+ match = LINE.match(line)
+ if not match:
+ continue
+ label, value = match.group(1).strip(), match.group(2).strip()
+ pair = (label, value)
+ if len(value) > max_value_length or pair in seen:
+ continue
+ seen.add(pair)
+ entities.append(Entity(label, value))
+ except PdfError:
+ raise
+ except Exception as exc: # pdfplumber surfaces parser-specific exceptions
+ raise PdfError(
+ "pdf_extract_failed", "Could not extract text from PDF", path=str(path)
+ ) from exc
+ return derive_entities(entities)
+
+
+def _read_validated_pdf(path: Path, *, max_bytes: int) -> bytes:
+ """Read a regular non-symlink file into bounded bytes before parsing."""
+
+ try:
+ expected = path.stat(follow_symlinks=False)
+ except OSError as exc:
+ raise PdfError("pdf_stat_failed", "Could not inspect PDF", path=str(path)) from exc
+ if not stat.S_ISREG(expected.st_mode):
+ raise PdfError("pdf_not_file", "PDF path is not a regular file", path=str(path))
+
+ flags = os.O_RDONLY
+ if hasattr(os, "O_CLOEXEC"):
+ flags |= os.O_CLOEXEC
+ if hasattr(os, "O_NOFOLLOW"):
+ flags |= os.O_NOFOLLOW
+ try:
+ descriptor = os.open(path, flags)
+ except OSError as exc:
+ raise PdfError("pdf_open_failed", "Could not safely open PDF", path=str(path)) from exc
+ try:
+ metadata = os.fstat(descriptor)
+ if not stat.S_ISREG(metadata.st_mode):
+ raise PdfError("pdf_not_file", "PDF path is not a regular file", path=str(path))
+ if (metadata.st_dev, metadata.st_ino) != (expected.st_dev, expected.st_ino):
+ raise PdfError(
+ "pdf_changed_before_open",
+ "PDF changed while it was being opened",
+ path=str(path),
+ )
+ if metadata.st_size > max_bytes:
+ raise PdfError(
+ "pdf_too_large",
+ "PDF exceeds the configured byte limit",
+ path=str(path),
+ size_bytes=metadata.st_size,
+ max_bytes=max_bytes,
+ )
+ with os.fdopen(descriptor, "rb", closefd=False) as stream:
+ data = stream.read(max_bytes + 1)
+ if len(data) > max_bytes:
+ raise PdfError(
+ "pdf_too_large",
+ "PDF exceeds the configured byte limit",
+ path=str(path),
+ size_bytes=len(data),
+ max_bytes=max_bytes,
+ )
+ return data
+ finally:
+ os.close(descriptor)
+
+
+def derive_entities(entities: list[Entity]) -> list[Entity]:
+ """Add conservative first/last/full-name variants."""
+
+ labels = {entity.label.lower(): entity for entity in entities}
+ output = list(entities)
+ name = next(
+ (
+ entity
+ for label, entity in labels.items()
+ if label in {"name", "full name", "patient", "applicant", "patient name", "legal name"}
+ ),
+ None,
+ )
+ if name and " " in name.value.strip() and "first name" not in labels:
+ first, _, last = name.value.strip().partition(" ")
+ output.append(Entity("First name", first))
+ output.append(Entity("Last name", last.strip()))
+ if "first name" in labels and "last name" in labels and not name:
+ output.append(
+ Entity("Full name", f"{labels['first name'].value} {labels['last name'].value}")
+ )
+ return output
+
+
+# Compatibility with the initial research prototype.
+derive = derive_entities
diff --git a/libs/cua-s1/python/src/cua_s1/planner.py b/libs/cua-s1/python/src/cua_s1/planner.py
new file mode 100644
index 0000000000..938686c497
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/planner.py
@@ -0,0 +1,446 @@
+"""Model-agnostic planning and explicitly authorized form execution."""
+
+from __future__ import annotations
+
+import math
+import re
+import time
+from collections.abc import Callable, Sequence
+from dataclasses import asdict, is_dataclass
+from typing import Any, Protocol
+
+from .driver import BaseDriver, DeliveryMode, DriverError, WindowSnapshot, WindowTarget
+from .schema import ACTION_ORDER, Decision, Element, Entity
+
+ACTIONABLE_ROLES = {
+ "button",
+ "checkbox",
+ "combobox",
+ "edit",
+ "textfield",
+ "axbutton",
+ "axcheckbox",
+ "axcombobox",
+ "axtextfield",
+}
+ALLOWED_ACTIONS = {"fill", "check", "click", "skip"}
+SUBMIT_CONTROL_ROLES = {"button", "axbutton"}
+SUBMIT_CONTROL_LABELS = {"submit", "submit form"}
+APP_SUFFIXES = (
+ " - Google Chrome",
+ " - Microsoft Edge",
+ " - Mozilla Firefox",
+ " - Brave",
+ " - Safari",
+)
+
+
+class PlannerError(RuntimeError):
+ def __init__(self, code: str, message: str, **details: Any) -> None:
+ super().__init__(message)
+ self.code = code
+ self.message = message
+ self.details = details
+
+ def to_dict(self) -> dict[str, Any]:
+ return {"code": self.code, "message": self.message, "details": self.details}
+
+
+class PlanningBackend(Protocol):
+ """Minimal interface implemented by local, remote, or test scorers."""
+
+ def plan(
+ self,
+ form_title: str,
+ elements: list[Element],
+ entities: list[Entity],
+ ) -> Sequence[Decision]: ...
+
+
+class Planner:
+ """Validate decisions from an injected backend without owning a model."""
+
+ def __init__(
+ self,
+ backend: PlanningBackend | Callable[[str, list[Element], list[Entity]], Sequence[Decision]],
+ ) -> None:
+ self.backend = backend
+
+ def plan(
+ self,
+ form_title: str,
+ elements: list[Element],
+ entities: list[Entity],
+ ) -> list[Decision]:
+ normalized = normalize_title(form_title)
+ if hasattr(self.backend, "plan"):
+ decisions = self.backend.plan(normalized, elements, entities) # type: ignore[union-attr]
+ else:
+ decisions = self.backend(normalized, elements, entities) # type: ignore[operator]
+ supplied = {_element_identity(element): element for element in elements}
+ if len(supplied) != len(elements):
+ raise PlannerError(
+ "duplicate_element_identity",
+ "Supplied actionable elements must have unique identities",
+ elements=len(elements),
+ identities=len(supplied),
+ )
+
+ output = []
+ decided: set[tuple[str, str | int]] = set()
+ for index, decision in enumerate(decisions):
+ identity = _element_identity(decision.element)
+ element = supplied.get(identity)
+ if element is None:
+ raise PlannerError(
+ "foreign_element",
+ "Decision refers to an element outside the supplied snapshot",
+ decision_index=index,
+ )
+ if identity in decided:
+ raise PlannerError(
+ "duplicate_decision",
+ "Planning backend returned more than one decision for an element",
+ decision_index=index,
+ element_index=element.index,
+ )
+ if decision.action not in ALLOWED_ACTIONS:
+ raise PlannerError(
+ "invalid_action",
+ "Planning backend returned an unsupported action",
+ decision_index=index,
+ action=decision.action,
+ )
+ if (
+ isinstance(decision.probability, bool)
+ or not isinstance(decision.probability, (int, float))
+ or not math.isfinite(decision.probability)
+ or not 0 <= decision.probability <= 1
+ ):
+ raise PlannerError(
+ "invalid_probability",
+ "Decision probability must be finite and between zero and one",
+ decision_index=index,
+ probability=decision.probability,
+ )
+ if decision.action == "fill":
+ if decision.entity_index is None or not 0 <= decision.entity_index < len(entities):
+ raise PlannerError(
+ "invalid_entity_index",
+ "Fill decision does not identify a supplied entity",
+ decision_index=index,
+ entity_index=decision.entity_index,
+ )
+ decided.add(identity)
+ output.append(
+ Decision(
+ element=element,
+ action=decision.action,
+ entity_index=decision.entity_index,
+ probability=decision.probability,
+ distribution=decision.distribution,
+ )
+ )
+ missing = [
+ element.index for identity, element in supplied.items() if identity not in decided
+ ]
+ if missing:
+ raise PlannerError(
+ "missing_decisions",
+ "Planning backend omitted decisions for supplied actionable elements",
+ missing_element_indices=missing,
+ elements=len(elements),
+ decisions=len(output),
+ )
+ return output
+
+
+def normalize_title(title: str) -> str:
+ for suffix in APP_SUFFIXES:
+ if title.endswith(suffix):
+ return title[: -len(suffix)]
+ return title
+
+
+def filter_elements(elements: list[Element]) -> list[Element]:
+ return [element for element in elements if _normalized_role(element.role) in ACTIONABLE_ROLES]
+
+
+def order_decisions(
+ decisions: list[Decision],
+ min_confidence: float,
+ *,
+ allow_submit: bool = False,
+) -> list[Decision]:
+ """Order bounded actions and retain at most one recognized submit click."""
+
+ if (
+ isinstance(min_confidence, bool)
+ or not isinstance(min_confidence, (int, float))
+ or not math.isfinite(min_confidence)
+ or not 0 <= min_confidence <= 1
+ ):
+ raise PlannerError(
+ "invalid_min_confidence",
+ "min_confidence must be finite and between zero and one",
+ min_confidence=min_confidence,
+ )
+ keep = [
+ decision
+ for decision in decisions
+ if decision.action != "skip" and decision.probability >= min_confidence
+ ]
+ submit_clicks = sorted(
+ (
+ decision
+ for decision in keep
+ if decision.action == "click" and _is_submit_control(decision.element)
+ ),
+ key=lambda decision: -decision.probability,
+ )
+ keep = [decision for decision in keep if decision.action != "click"]
+ if allow_submit and submit_clicks:
+ keep.append(submit_clicks[0])
+ return sorted(
+ keep,
+ key=lambda decision: (ACTION_ORDER[decision.action], decision.element.index),
+ )
+
+
+def run_form(
+ planner: Planner,
+ driver: BaseDriver,
+ entities: list[Entity],
+ *,
+ target: WindowTarget,
+ form_title: str,
+ min_confidence: float = 0.5,
+ execute: bool = False,
+ submit: bool = False,
+ delivery_mode: DeliveryMode = "background",
+ log: Callable[[dict[str, Any]], None] | None = None,
+) -> dict[str, Any]:
+ """Plan by default; mutate only with explicit execute and submit flags.
+
+ Every action uses an opaque token from the latest exact-window snapshot.
+ The window is re-observed after every mutation before another token is used.
+ """
+
+ if not isinstance(execute, bool) or not isinstance(submit, bool):
+ raise PlannerError(
+ "invalid_authorization",
+ "execute and submit authorization flags must be booleans",
+ execute_type=type(execute).__name__,
+ submit_type=type(submit).__name__,
+ )
+ if submit and not execute:
+ # This is a valid preview of a submit-authorized run, but make the lack
+ # of execution explicit in the report rather than silently mutating.
+ authorization_note = "submit requested, but execute is false; no actions ran"
+ else:
+ authorization_note = None
+ if delivery_mode not in ("background", "foreground"):
+ raise PlannerError(
+ "invalid_delivery_mode",
+ "delivery_mode must be 'background' or 'foreground'",
+ delivery_mode=delivery_mode,
+ )
+
+ started = time.perf_counter()
+ snapshot = driver.window_state(target)
+ actionable = filter_elements(snapshot.elements)
+ observed_at = time.perf_counter()
+ decisions = planner.plan(form_title, actionable, entities)
+ planned_at = time.perf_counter()
+ ordered = order_decisions(decisions, min_confidence, allow_submit=submit)
+ if execute and any(decision.action == "fill" for decision in ordered):
+ supports_value_mutation = getattr(driver, "supports_value_mutation", None)
+ if not callable(supports_value_mutation) or not supports_value_mutation():
+ raise PlannerError(
+ "unsupported_driver_capability",
+ "The connected driver does not advertise token-based value mutation",
+ capability="set_value",
+ )
+
+ executed: list[dict[str, Any]] = []
+ current_snapshot = snapshot
+ stopped_after_error = False
+ for decision in ordered:
+ entry = _describe_decision(decision, entities)
+ entry.update(
+ {
+ "executed": False,
+ "target": target.to_driver_target(),
+ "delivery_mode": "background" if decision.action == "fill" else delivery_mode,
+ "snapshot_id": current_snapshot.snapshot_id,
+ }
+ )
+ if not execute:
+ entry["status"] = "planned"
+ executed.append(entry)
+ if log:
+ log(entry)
+ continue
+
+ try:
+ current = current_snapshot.element_for(decision.element)
+ if decision.action == "check":
+ if _normalized_role(current.role) not in {"checkbox", "axcheckbox"}:
+ raise DriverError(
+ "check_requires_checkbox",
+ "A check action requires a checkbox element",
+ details={"element_index": current.index, "role": current.role},
+ )
+ if current.checked is None:
+ raise DriverError(
+ "checkbox_state_unknown",
+ "The checkbox state is unknown; refusing to toggle it",
+ details={"element_index": current.index},
+ )
+ if current.checked:
+ entry["status"] = "already_satisfied"
+ executed.append(entry)
+ if log:
+ log(entry)
+ continue
+ token = current_snapshot.token_for(decision.element)
+ if decision.action == "fill":
+ assert decision.entity_index is not None
+ mutation = driver.set_value(
+ target,
+ token,
+ entities[decision.entity_index].value,
+ )
+ else:
+ mutation = driver.click(
+ target,
+ token,
+ delivery_mode=delivery_mode,
+ )
+ _require_confirmed_action(decision.action, mutation.action, mutation.observation)
+ entry["executed"] = True
+ entry["status"] = "delivered"
+ entry["action_result"] = mutation.action
+ entry["post_snapshot_id"] = mutation.observation.snapshot_id
+ current_snapshot = mutation.observation
+ if decision.action == "check":
+ post_element = current_snapshot.element_for(decision.element)
+ if post_element.checked is not True:
+ raise DriverError(
+ "checkbox_postcondition_failed",
+ "The checkbox was not confirmed checked after the action",
+ details={
+ "element_index": post_element.index,
+ "checked": post_element.checked,
+ },
+ )
+ except DriverError as exc:
+ entry["status"] = "error"
+ entry["error"] = exc.to_dict()
+ stopped_after_error = True
+ executed.append(entry)
+ if log:
+ log(entry)
+ if stopped_after_error:
+ break
+
+ finished = time.perf_counter()
+ return {
+ "form": form_title,
+ "target": target.to_driver_target(),
+ "authorization": {
+ "execute": execute,
+ "submit": submit,
+ "delivery_mode": delivery_mode,
+ "note": authorization_note,
+ },
+ "entities": [_serialize(entity) for entity in entities],
+ "elements_scored": len(actionable),
+ "snapshot": _snapshot_report(snapshot),
+ "all_decisions": [_describe_decision(decision, entities) for decision in decisions],
+ "execution_order": executed,
+ "stopped_after_error": stopped_after_error,
+ "final_snapshot": _snapshot_report(current_snapshot),
+ "timings_ms": {
+ "snapshot": round((observed_at - started) * 1000, 1),
+ "plan": round((planned_at - observed_at) * 1000, 1),
+ "execute": round((finished - planned_at) * 1000, 1),
+ "total": round((finished - started) * 1000, 1),
+ },
+ "driver_calls": driver.timings[-100:],
+ }
+
+
+def _describe_decision(decision: Decision, entities: list[Entity]) -> dict[str, Any]:
+ entity = (
+ _serialize(entities[decision.entity_index])
+ if decision.entity_index is not None and 0 <= decision.entity_index < len(entities)
+ else None
+ )
+ return {
+ "element_index": decision.element.index,
+ "role": decision.element.role,
+ "label": decision.element.label,
+ "action": decision.action,
+ "confidence": round(decision.probability, 4),
+ "entity": entity,
+ }
+
+
+def _snapshot_report(snapshot: WindowSnapshot) -> dict[str, Any]:
+ return {
+ "snapshot_id": snapshot.snapshot_id,
+ "element_count": len(snapshot.elements),
+ "elements_complete": snapshot.elements_complete,
+ }
+
+
+def _serialize(value: Any) -> Any:
+ if is_dataclass(value):
+ return asdict(value)
+ if hasattr(value, "__dict__"):
+ return dict(value.__dict__)
+ return value
+
+
+def _normalized_role(role: str) -> str:
+ return role.replace("_", "").replace(" ", "").casefold()
+
+
+def _normalized_control_label(label: str) -> str:
+ return " ".join(re.findall(r"[a-z0-9]+", label.casefold()))
+
+
+def _is_submit_control(element: Element) -> bool:
+ return (
+ _normalized_role(element.role) in SUBMIT_CONTROL_ROLES
+ and _normalized_control_label(element.label) in SUBMIT_CONTROL_LABELS
+ )
+
+
+def _element_identity(element: Element) -> tuple[str, str | int]:
+ if element.element_token:
+ return ("token", element.element_token)
+ return ("object", id(element))
+
+
+def _require_confirmed_action(
+ action_name: str,
+ action: dict[str, Any],
+ observation: WindowSnapshot,
+) -> None:
+ effect = action.get("effect")
+ if effect == "confirmed":
+ return
+ raise DriverError(
+ "action_effect_unconfirmed",
+ "Cua Driver did not confirm the action effect",
+ tool="set_value" if action_name == "fill" else "click",
+ details={
+ "effect": effect if isinstance(effect, str) else "missing",
+ "route": action.get("route"),
+ "escalation": action.get("escalation"),
+ "post_action_observation": _snapshot_report(observation),
+ },
+ outcome_unknown=effect not in {"refused", "suspected_noop"},
+ )
diff --git a/libs/cua-s1/python/src/cua_s1/schema.py b/libs/cua-s1/python/src/cua_s1/schema.py
new file mode 100644
index 0000000000..ae6b912bd0
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/schema.py
@@ -0,0 +1,103 @@
+"""Typed inputs and pointer-action encoding for form-filling decisions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+Action = Literal["fill", "check", "click", "skip"]
+FIXED_ACTIONS: tuple[Action, ...] = ("check", "click", "skip")
+
+
+@dataclass
+class Entity:
+ """A labeled source-document value that the model may point to."""
+
+ label: str
+ value: str
+
+ def option(self) -> str:
+ """Render this entity as one scorer option."""
+ return f"fill {self.label}: {self.value}"
+
+
+@dataclass
+class Element:
+ """A normalized UI element observation.
+
+ ``element_token`` is the stable runtime action target. ``index`` is retained
+ only as observation metadata and must not be used to target an action.
+ """
+
+ role: str
+ label: str
+ value: str = ""
+ index: int = -1
+ actions: tuple[str, ...] = ()
+ checked: bool | None = None
+ frame: tuple[int, int, int, int] | None = None
+ element_token: str | None = None
+
+
+@dataclass
+class Decision:
+ """A decoded action, including its confidence and option distribution."""
+
+ element: Element
+ action: Action
+ entity_index: int | None
+ probability: float
+ distribution: list[float] = field(default_factory=list)
+
+
+def render_context(form_title: str, element: Element, placeholder: str = "") -> str:
+ """Render the compact byte-level context used to score one element."""
+ if element.role == "CheckBox":
+ state = "checked" if element.checked else "unchecked"
+ else:
+ state = f'value="{element.value[:48]}"'
+ hint = f' hint="{placeholder[:72]}"' if placeholder else ""
+ return (
+ "TASK fill the form from the document, then submit\n"
+ f"FORM {form_title[:64]}\n"
+ f'ELEMENT {element.role} "{element.label[:72]}" {state}{hint}'
+ )
+
+
+# Execution order for a single-pass plan: fills, checkboxes, then clicks.
+ACTION_ORDER: dict[Action, int] = {"fill": 0, "check": 1, "click": 2, "skip": 3}
+
+
+def render_options(entities: list[Entity]) -> list[str]:
+ """Render entity pointer options followed by the fixed actions."""
+ return [entity.option() for entity in entities] + list(FIXED_ACTIONS)
+
+
+def decode(option_index: int, entities: list[Entity]) -> tuple[Action, int | None]:
+ """Decode a scorer option index into an action and optional entity pointer."""
+ option_count = len(entities) + len(FIXED_ACTIONS)
+ if isinstance(option_index, bool) or not 0 <= option_index < option_count:
+ raise ValueError(
+ f"option index {option_index!r} is outside the valid range 0..{option_count - 1}"
+ )
+ if option_index < len(entities):
+ return "fill", option_index
+ return FIXED_ACTIONS[option_index - len(entities)], None
+
+
+def encode(action: Action, entity_index: int | None, entities: list[Entity]) -> int:
+ """Encode an action and optional entity pointer as a scorer option index."""
+ if action == "fill":
+ if (
+ entity_index is None
+ or isinstance(entity_index, bool)
+ or not 0 <= entity_index < len(entities)
+ ):
+ raise ValueError("fill actions require a valid entity index")
+ return entity_index
+ if entity_index is not None:
+ raise ValueError(f"{action!r} actions must not include an entity index")
+ try:
+ return len(entities) + FIXED_ACTIONS.index(action)
+ except ValueError as exc:
+ raise ValueError(f"unsupported action: {action!r}") from exc
diff --git a/libs/cua-s1/python/src/cua_s1/server.py b/libs/cua-s1/python/src/cua_s1/server.py
new file mode 100644
index 0000000000..5c0616ca84
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/server.py
@@ -0,0 +1,345 @@
+"""Optional MCP surface for safe Cua-S1 form planning and execution."""
+
+from __future__ import annotations
+
+import functools
+import importlib
+import ntpath
+import os
+from pathlib import Path
+from typing import Any, Callable, Iterable
+
+from .driver import (
+ BaseDriver,
+ CuaDriver,
+ DriverError,
+ WindowTarget,
+ target_from_window,
+)
+from .pdf import PdfError, extract_entities
+from .planner import Planner, PlannerError, run_form
+from .schema import Entity
+
+DEFAULT_SESSION = f"cua-s1-{os.getpid()}"
+
+
+class ServerError(RuntimeError):
+ def __init__(self, code: str, message: str, **details: Any) -> None:
+ super().__init__(message)
+ self.code = code
+ self.message = message
+ self.details = details
+
+ def to_dict(self) -> dict[str, Any]:
+ return {"code": self.code, "message": self.message, "details": self.details}
+
+
+def structured_errors(function: Callable[..., dict[str, Any]]) -> Callable[..., dict[str, Any]]:
+ """Return stable error objects instead of leaking transport exceptions."""
+
+ @functools.wraps(function)
+ def wrapper(*args: Any, **kwargs: Any) -> dict[str, Any]:
+ try:
+ return function(*args, **kwargs)
+ except (DriverError, PdfError, PlannerError, ServerError) as exc:
+ return {"ok": False, "error": _sanitize_public_error(exc.to_dict())}
+ except Exception as exc: # keep unexpected internals out of public responses
+ return {
+ "ok": False,
+ "error": {
+ "code": "internal_error",
+ "message": "The Cua-S1 runtime encountered an unexpected error",
+ "details": {"error_type": type(exc).__name__},
+ },
+ }
+
+ return wrapper
+
+
+class RuntimeService:
+ def __init__(
+ self,
+ planner: Planner,
+ driver: BaseDriver,
+ *,
+ allowed_pdf_roots: Iterable[str | Path],
+ pdf_base_dir: str | Path | None = None,
+ ) -> None:
+ roots = tuple(Path(root).expanduser().resolve() for root in allowed_pdf_roots)
+ if not roots:
+ raise ServerError("no_allowed_pdf_roots", "At least one allowed PDF root is required")
+ self.planner = planner
+ self.driver = driver
+ self.allowed_pdf_roots = roots
+ self.pdf_base_dir = Path(pdf_base_dir or roots[0]).expanduser().resolve()
+
+ @structured_errors
+ def extract_pdf_entities(self, pdf_path: str) -> dict[str, Any]:
+ entities = self._entities(pdf_path, None)
+ return {"ok": True, "entities": [_entity_dict(entity) for entity in entities]}
+
+ @structured_errors
+ def plan_form(
+ self,
+ pdf_path: str,
+ *,
+ pid: int | None = None,
+ window_id: int | None = None,
+ window_title: str | None = None,
+ extra_entities: dict[str, str] | None = None,
+ min_confidence: float = 0.5,
+ submit: bool = False,
+ delivery_mode: str = "background",
+ ) -> dict[str, Any]:
+ target, title, window = self._target(pid, window_id, window_title)
+ report = run_form(
+ self.planner,
+ self.driver,
+ self._entities(pdf_path, extra_entities),
+ target=target,
+ form_title=title,
+ min_confidence=min_confidence,
+ execute=False,
+ submit=submit,
+ delivery_mode=delivery_mode, # type: ignore[arg-type]
+ )
+ return {"ok": True, "window": window, "report": report}
+
+ @structured_errors
+ def fill_form(
+ self,
+ pdf_path: str,
+ *,
+ pid: int | None = None,
+ window_id: int | None = None,
+ window_title: str | None = None,
+ extra_entities: dict[str, str] | None = None,
+ min_confidence: float = 0.5,
+ execute: bool = False,
+ submit: bool = False,
+ delivery_mode: str = "background",
+ ) -> dict[str, Any]:
+ """Plan by default; execution and submission are separate opt-ins."""
+
+ target, title, window = self._target(pid, window_id, window_title)
+ report = run_form(
+ self.planner,
+ self.driver,
+ self._entities(pdf_path, extra_entities),
+ target=target,
+ form_title=title,
+ min_confidence=min_confidence,
+ execute=execute,
+ submit=submit,
+ delivery_mode=delivery_mode, # type: ignore[arg-type]
+ )
+ return {"ok": True, "window": window, "report": report}
+
+ def _entities(
+ self,
+ pdf_path: str,
+ extra_entities: dict[str, str] | None,
+ ) -> list[Entity]:
+ entities = extract_entities(
+ pdf_path,
+ allowed_roots=self.allowed_pdf_roots,
+ base_dir=self.pdf_base_dir,
+ )
+ if extra_entities is not None and not isinstance(extra_entities, dict):
+ raise ServerError(
+ "invalid_extra_entities",
+ "extra_entities must be an object mapping labels to values",
+ )
+ for label, value in (extra_entities or {}).items():
+ if not isinstance(label, str) or not isinstance(value, str):
+ raise ServerError(
+ "invalid_extra_entity",
+ "Extra entity labels and values must be strings",
+ )
+ entities.append(Entity(label, value))
+ return entities
+
+ def _target(
+ self,
+ pid: int | None,
+ window_id: int | None,
+ window_title: str | None,
+ ) -> tuple[WindowTarget, str, dict[str, Any]]:
+ if (pid is None) != (window_id is None):
+ raise ServerError(
+ "incomplete_window_target",
+ "pid and window_id must be supplied together",
+ pid=pid,
+ window_id=window_id,
+ )
+ if pid is not None and window_id is not None:
+ window = self.driver.find_window(pid=pid, window_id=window_id)
+ if (
+ window_title
+ and window_title.casefold() not in str(window.get("title") or "").casefold()
+ ):
+ raise ServerError(
+ "window_title_mismatch",
+ "The exact window does not match the requested title constraint",
+ pid=pid,
+ window_id=window_id,
+ requested_title=window_title,
+ observed_title=window.get("title"),
+ )
+ elif window_title:
+ window = self.driver.find_window(title_contains=window_title)
+ else:
+ raise ServerError(
+ "window_target_required",
+ "Provide an exact pid/window_id pair or a title that resolves to one window",
+ )
+ target = target_from_window(window)
+ return target, str(window.get("title") or window_title or ""), _public_window(window)
+
+
+def create_service_from_environment() -> RuntimeService:
+ """Build the runtime from explicit host configuration.
+
+ ``CUA_S1_PLANNER_FACTORY`` must be ``module:attribute``. The referenced
+ trusted host callable may return either a ``Planner`` or a planning backend.
+ No model implementation or checkpoint location is embedded here.
+ """
+
+ planner_spec = os.environ.get("CUA_S1_PLANNER_FACTORY")
+ if not planner_spec:
+ raise ServerError(
+ "planner_not_configured",
+ "Set CUA_S1_PLANNER_FACTORY to a trusted module:attribute factory",
+ )
+ planner = _load_planner(planner_spec)
+ roots = _allowed_roots_from_environment()
+ driver = CuaDriver(
+ session=os.environ.get("CUA_S1_SESSION", DEFAULT_SESSION),
+ transport=os.environ.get("CUA_S1_DRIVER_TRANSPORT", "auto"), # type: ignore[arg-type]
+ binary=os.environ.get("CUA_S1_DRIVER_BINARY"),
+ )
+ driver.start_session()
+ return RuntimeService(planner, driver, allowed_pdf_roots=roots)
+
+
+def create_mcp_server(service: RuntimeService | None = None) -> Any:
+ try:
+ from mcp.server.fastmcp import FastMCP
+ except ImportError as exc:
+ raise ServerError(
+ "mcp_dependency_missing",
+ "The MCP server requires the optional 'mcp' dependency",
+ ) from exc
+
+ runtime = service or create_service_from_environment()
+ server = FastMCP(
+ "cua-s1",
+ instructions=(
+ "Plan form actions from a bounded PDF. plan_form and fill_form are dry-run by "
+ "default. Set execute=true to authorize mutations and submit=true separately "
+ "to authorize one recognized submit-control click. Always identify one exact window."
+ ),
+ )
+ server.tool()(runtime.extract_pdf_entities)
+ server.tool()(runtime.plan_form)
+ server.tool()(runtime.fill_form)
+ return server
+
+
+def main() -> None:
+ server = create_mcp_server()
+ server.run(transport="stdio")
+
+
+def _load_planner(spec: str) -> Planner:
+ module_name, separator, attribute_name = spec.partition(":")
+ if not separator or not module_name or not attribute_name:
+ raise ServerError(
+ "invalid_planner_factory",
+ "CUA_S1_PLANNER_FACTORY must use module:attribute syntax",
+ )
+ try:
+ attribute = getattr(importlib.import_module(module_name), attribute_name)
+ candidate = attribute() if callable(attribute) else attribute
+ except Exception as exc:
+ raise ServerError(
+ "planner_factory_failed",
+ "The configured planner factory could not be loaded",
+ module=module_name,
+ attribute=attribute_name,
+ error_type=type(exc).__name__,
+ ) from exc
+ return candidate if isinstance(candidate, Planner) else Planner(candidate)
+
+
+def _allowed_roots_from_environment() -> tuple[Path, ...]:
+ configured = os.environ.get("CUA_S1_ALLOWED_PDF_ROOTS")
+ if not configured:
+ return (Path.cwd().resolve(),)
+ roots = tuple(
+ Path(value).expanduser().resolve()
+ for value in configured.split(os.pathsep)
+ if value.strip()
+ )
+ if not roots:
+ raise ServerError(
+ "no_allowed_pdf_roots",
+ "CUA_S1_ALLOWED_PDF_ROOTS did not contain a usable path",
+ )
+ return roots
+
+
+def _entity_dict(entity: Entity) -> dict[str, str]:
+ return {"label": entity.label, "value": entity.value}
+
+
+def _public_window(window: dict[str, Any]) -> dict[str, Any]:
+ return {
+ "pid": window.get("pid"),
+ "window_id": window.get("window_id"),
+ "app_name": window.get("app_name"),
+ "title": window.get("title"),
+ "is_on_screen": window.get("is_on_screen"),
+ "minimized": window.get("minimized"),
+ }
+
+
+_SENSITIVE_ERROR_KEYS = {
+ "allowed_roots",
+ "binary",
+ "element",
+ "label",
+ "observed_title",
+ "path",
+ "requested_title",
+ "response",
+ "stderr",
+ "title",
+ "tree_markdown",
+ "value",
+ "window",
+}
+
+
+def _sanitize_public_error(error: dict[str, Any]) -> dict[str, Any]:
+ """Remove host paths and raw accessibility content from public errors."""
+
+ return _sanitize_error_value(error)
+
+
+def _sanitize_error_value(value: Any, *, key: str | None = None) -> Any:
+ if key in _SENSITIVE_ERROR_KEYS:
+ return "<redacted>"
+ if isinstance(value, dict):
+ return {name: _sanitize_error_value(item, key=name) for name, item in value.items()}
+ if isinstance(value, list):
+ return [_sanitize_error_value(item) for item in value]
+ if isinstance(value, tuple):
+ return [_sanitize_error_value(item) for item in value]
+ if isinstance(value, str) and (os.path.isabs(value) or ntpath.isabs(value)):
+ return "<redacted-path>"
+ return value
+
+
+if __name__ == "__main__":
+ main()
diff --git a/libs/cua-s1/python/src/cua_s1/synth.py b/libs/cua-s1/python/src/cua_s1/synth.py
new file mode 100644
index 0000000000..51c9221f5e
--- /dev/null
+++ b/libs/cua-s1/python/src/cua_s1/synth.py
@@ -0,0 +1,383 @@
+"""Deterministic synthetic training data for the Cua-S1 form specialist.
+
+Each episode describes one form, one person, and document-style entities. Every
+actionable element becomes a choice-classification row. Splits are assigned by
+the form's concept signature, so the same field set cannot cross split
+boundaries.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Sequence
+
+from .concepts import (
+ CHROME_ELEMENTS,
+ CONCEPT_BY_KEY,
+ CONCEPTS,
+ DISTRACTOR_ENTITIES,
+ FORM_TITLES,
+ NON_SUBMIT_BUTTONS,
+ OPTIONAL_CHECKBOXES,
+ OPTIONAL_FIELDS,
+ REQUIRED_CHECKBOXES,
+ SUBMIT_LABELS,
+ person,
+)
+from .schema import Element, Entity, encode, render_context, render_options
+
+SPLIT_NAMES = ("train", "validation", "test")
+DATASET_FORMAT = "cua-s1-choice-jsonl"
+DATASET_FORMAT_VERSION = 1
+
+
+@dataclass(frozen=True)
+class SynthesisConfig:
+ """Controls stochastic data features while preserving seeded replay."""
+
+ missing_entity_probability: float = 0.12
+ partial_form_probability: float = 0.30
+ filled_field_probability: float = 0.60
+ stale_value_probability: float = 0.05
+ hard_negative_probability: float = 0.35
+ max_extra_entities: int = 5
+ max_distractor_entities: int = 3
+
+ def validate(self) -> None:
+ probabilities = (
+ self.missing_entity_probability,
+ self.partial_form_probability,
+ self.filled_field_probability,
+ self.stale_value_probability,
+ self.hard_negative_probability,
+ )
+ if any(probability < 0.0 or probability > 1.0 for probability in probabilities):
+ raise ValueError("synthesis probabilities must be between 0 and 1")
+ if self.max_extra_entities < 0 or self.max_distractor_entities < 0:
+ raise ValueError("entity limits must be non-negative")
+
+
+def _stable_fraction(text: str) -> float:
+ digest = hashlib.sha256(text.encode("utf-8")).digest()
+ return int.from_bytes(digest[:8], "big") / 2**64
+
+
+def _validate_ratios(ratios: Sequence[float]) -> tuple[float, float, float]:
+ if len(ratios) != len(SPLIT_NAMES):
+ raise ValueError("ratios must contain train, validation, and test values")
+ normalized = tuple(float(ratio) for ratio in ratios)
+ if any(ratio < 0 for ratio in normalized):
+ raise ValueError("split ratios must be non-negative")
+ total = sum(normalized)
+ if total <= 0:
+ raise ValueError("at least one split ratio must be positive")
+ return tuple(ratio / total for ratio in normalized) # type: ignore[return-value]
+
+
+def sample_form(rng: random.Random, config: SynthesisConfig | None = None) -> dict:
+ """Create a form with confusable labels, optional fields, and one submit."""
+
+ config = config or SynthesisConfig()
+ groups = sorted({concept.group for concept in CONCEPTS})
+ chosen_groups = rng.sample(groups, rng.randint(2, min(5, len(groups))))
+ pool = [concept for concept in CONCEPTS if concept.group in chosen_groups]
+ concepts = rng.sample(pool, min(len(pool), rng.randint(4, 16)))
+
+ # Co-locate look-alike concepts so matching requires the complete label.
+ hard_negatives = (
+ ("email", "street"),
+ ("phone", "ec_phone"),
+ ("full_name", "ec_name"),
+ ("first_name", "ec_name"),
+ ("phone", "work_phone"),
+ ("dob", "start_date"),
+ ("dob", "incident_date"),
+ ("zip", "policy"),
+ ("state", "university"),
+ ("city", "country"),
+ ("employer", "insurer"),
+ ("account", "policy"),
+ )
+ for first, second in hard_negatives:
+ if rng.random() < config.hard_negative_probability:
+ for key in (first, second):
+ if all(concept.key != key for concept in concepts):
+ concepts.append(CONCEPT_BY_KEY[key])
+
+ keys = {concept.key for concept in concepts}
+ if "full_name" in keys and {"first_name", "last_name"} & keys and rng.random() < 0.8:
+ concepts = [concept for concept in concepts if concept.key != "full_name"]
+
+ fields = [
+ {
+ "concept": concept.key,
+ "label": rng.choice(concept.form_labels),
+ "kind": concept.kind,
+ "placeholder": (
+ rng.choice(concept.placeholder)
+ if concept.placeholder and rng.random() < 0.5
+ else ""
+ ),
+ }
+ for concept in concepts
+ ]
+ for _ in range(rng.choice((0, 0, 1, 1, 2))):
+ fields.append(
+ {
+ "concept": None,
+ "label": rng.choice(OPTIONAL_FIELDS),
+ "kind": "text",
+ "placeholder": "",
+ }
+ )
+ rng.shuffle(fields)
+
+ checkboxes = [(rng.choice(REQUIRED_CHECKBOXES), True) for _ in range(rng.choice((0, 1, 1, 2)))]
+ checkboxes.extend(
+ (rng.choice(OPTIONAL_CHECKBOXES), False) for _ in range(rng.choice((0, 0, 1)))
+ )
+ rng.shuffle(checkboxes)
+
+ buttons = [(rng.choice(NON_SUBMIT_BUTTONS), False) for _ in range(rng.choice((0, 1, 1, 2)))]
+ buttons.append((rng.choice(SUBMIT_LABELS), True))
+ if rng.random() < 0.3:
+ buttons.reverse()
+
+ title = rng.choice(FORM_TITLES)
+ if rng.random() < 0.5:
+ title += rng.choice(
+ (" - Google Chrome", " - Microsoft Edge", " - Mozilla Firefox", " - Safari", "")
+ )
+ if rng.random() < 0.2:
+ title = rng.choice(("", "Untitled", "Form", "Page 2 of 3"))
+ return {"title": title, "fields": fields, "checkboxes": checkboxes, "buttons": buttons}
+
+
+def form_signature(form: dict) -> str:
+ """Return the form identity used to keep train and evaluation disjoint."""
+
+ fields = sorted(field["concept"] or f"optional:{field['label']}" for field in form["fields"])
+ return "|".join(fields)
+
+
+def sample_document(
+ rng: random.Random,
+ form: dict,
+ profile: dict,
+ config: SynthesisConfig | None = None,
+) -> tuple[list[Entity], dict[str, int]]:
+ """Generate document entities and a form-concept-to-entity index."""
+
+ config = config or SynthesisConfig()
+ entities: list[Entity] = []
+ concept_to_entity: dict[str, int] = {}
+ present = [field["concept"] for field in form["fields"] if field["concept"]]
+ for key in present:
+ if rng.random() < config.missing_entity_probability:
+ continue
+ concept = CONCEPT_BY_KEY[key]
+ concept_to_entity[key] = len(entities)
+ entities.append(Entity(rng.choice(concept.doc_labels), concept.value(rng, profile)))
+
+ absent = [concept for concept in CONCEPTS if concept.key not in present]
+ extra_count = rng.randint(0, min(config.max_extra_entities, len(absent)))
+ for concept in rng.sample(absent, extra_count):
+ entities.append(Entity(rng.choice(concept.doc_labels), concept.value(rng, profile)))
+
+ distractor_count = rng.randint(0, min(config.max_distractor_entities, len(DISTRACTOR_ENTITIES)))
+ for label, generate in rng.sample(DISTRACTOR_ENTITIES, distractor_count):
+ entities.append(Entity(label, generate(rng)))
+
+ order = list(range(len(entities)))
+ rng.shuffle(order)
+ entities = [entities[index] for index in order]
+ remap = {old: new for new, old in enumerate(order)}
+ concept_to_entity = {key: remap[index] for key, index in concept_to_entity.items()}
+ return entities, concept_to_entity
+
+
+def episode_rows(seed: int, config: SynthesisConfig | None = None) -> list[dict]:
+ """Generate all element decisions for a single replayable episode."""
+
+ config = config or SynthesisConfig()
+ config.validate()
+ rng = random.Random(seed)
+ form = sample_form(rng, config)
+ signature = form_signature(form)
+ entities, concept_to_entity = sample_document(rng, form, person(rng), config)
+ options = render_options(entities)
+ partially_filled = rng.random() < config.partial_form_probability
+ rows: list[dict] = []
+
+ def add(
+ element: Element,
+ action: str,
+ entity_index: int | None = None,
+ placeholder: str = "",
+ ) -> None:
+ rows.append(
+ {
+ "context": render_context(form["title"], element, placeholder),
+ "options": options,
+ "label": encode(action, entity_index, entities),
+ "meta": {
+ "seed": seed,
+ "form_signature": signature,
+ "role": element.role,
+ "action": action,
+ },
+ }
+ )
+
+ for field in form["fields"]:
+ entity_index = concept_to_entity.get(field["concept"]) if field["concept"] else None
+ filled = (
+ entity_index is not None
+ and partially_filled
+ and rng.random() < config.filled_field_probability
+ )
+ value = entities[entity_index].value if filled and entity_index is not None else ""
+ if filled and rng.random() < config.stale_value_probability:
+ value = "stale value"
+ element = Element("Edit", field["label"], value, actions=("set_value",))
+ if entity_index is not None and (not value or value == "stale value"):
+ add(element, "fill", entity_index, field["placeholder"])
+ else:
+ add(element, "skip", placeholder=field["placeholder"])
+
+ for label, required in form["checkboxes"]:
+ checked = partially_filled and rng.random() < 0.5
+ element = Element("CheckBox", label, checked=checked, actions=("toggle",))
+ add(element, "check" if required and not checked else "skip")
+
+ for label, is_submit in form["buttons"]:
+ add(Element("Button", label, actions=("invoke",)), "click" if is_submit else "skip")
+
+ chrome_count = rng.randint(3, min(10, len(CHROME_ELEMENTS)))
+ for role, label in rng.sample(CHROME_ELEMENTS, chrome_count):
+ value = "https://example.invalid/form" if label == "Address bar" else ""
+ add(Element(role, label or form["title"], value), "skip")
+ return rows
+
+
+def signature(rows: list[dict]) -> str:
+ """Recover an episode signature from generated rows."""
+
+ if not rows:
+ raise ValueError("an episode must contain at least one row")
+ return str(rows[0]["meta"]["form_signature"])
+
+
+def write_splits(
+ output: str | Path,
+ episodes: int,
+ seed: int,
+ ratios: Sequence[float] = (0.8, 0.1, 0.1),
+ config: SynthesisConfig | None = None,
+) -> dict:
+ """Write deterministic JSONL splits and return row and episode counts."""
+
+ if episodes < 0:
+ raise ValueError("episodes must be non-negative")
+ config = config or SynthesisConfig()
+ config.validate()
+ normalized_ratios = _validate_ratios(ratios)
+ train_ratio, validation_ratio, _ = normalized_ratios
+ output_path = Path(output)
+ output_path.mkdir(parents=True, exist_ok=True)
+ handles = {
+ name: (output_path / f"{name}.jsonl").open("w", encoding="utf-8") for name in SPLIT_NAMES
+ }
+ counts = {name: 0 for name in SPLIT_NAMES}
+ episodes_per_split = {name: 0 for name in SPLIT_NAMES}
+ try:
+ for episode_index in range(episodes):
+ rows = episode_rows(seed + episode_index * 7919, config)
+ bucket = _stable_fraction(signature(rows))
+ if bucket < train_ratio:
+ split = "train"
+ elif bucket < train_ratio + validation_ratio:
+ split = "validation"
+ else:
+ split = "test"
+ for row in rows:
+ handles[split].write(
+ json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+ + "\n"
+ )
+ counts[split] += len(rows)
+ episodes_per_split[split] += 1
+ finally:
+ for handle in handles.values():
+ handle.close()
+
+ split_manifest = {}
+ for name in SPLIT_NAMES:
+ split_path = output_path / f"{name}.jsonl"
+ split_manifest[name] = {
+ "file": split_path.name,
+ "sha256": hashlib.sha256(split_path.read_bytes()).hexdigest(),
+ "rows": counts[name],
+ "episodes": episodes_per_split[name],
+ }
+ manifest = {
+ "format": DATASET_FORMAT,
+ "format_version": DATASET_FORMAT_VERSION,
+ "generator": {
+ "format": "cua_s1.synth",
+ "config": asdict(config),
+ },
+ "ratios": dict(zip(SPLIT_NAMES, normalized_ratios, strict=True)),
+ "seed": seed,
+ "episodes": episodes,
+ "splits": split_manifest,
+ }
+ manifest_path = output_path / "manifest.json"
+ temporary = output_path / ".manifest.json.tmp"
+ temporary.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+ temporary.replace(manifest_path)
+ return {"rows": counts, "episodes": episodes_per_split}
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--output", type=Path, default=Path("data/cua-s1"))
+ parser.add_argument("--episodes", type=int, default=6000)
+ parser.add_argument("--seed", type=int, default=2026)
+ parser.add_argument("--train-ratio", type=float, default=0.8)
+ parser.add_argument("--validation-ratio", type=float, default=0.1)
+ parser.add_argument("--test-ratio", type=float, default=0.1)
+ parser.add_argument("--missing-entity-probability", type=float, default=0.12)
+ parser.add_argument("--partial-form-probability", type=float, default=0.30)
+ parser.add_argument("--filled-field-probability", type=float, default=0.60)
+ parser.add_argument("--stale-value-probability", type=float, default=0.05)
+ parser.add_argument("--hard-negative-probability", type=float, default=0.35)
+ parser.add_argument("--max-extra-entities", type=int, default=5)
+ parser.add_argument("--max-distractor-entities", type=int, default=3)
+ args = parser.parse_args()
+ config = SynthesisConfig(
+ missing_entity_probability=args.missing_entity_probability,
+ partial_form_probability=args.partial_form_probability,
+ filled_field_probability=args.filled_field_probability,
+ stale_value_probability=args.stale_value_probability,
+ hard_negative_probability=args.hard_negative_probability,
+ max_extra_entities=args.max_extra_entities,
+ max_distractor_entities=args.max_distractor_entities,
+ )
+ result = write_splits(
+ args.output,
+ args.episodes,
+ args.seed,
+ (args.train_ratio, args.validation_ratio, args.test_ratio),
+ config,
+ )
+ print(json.dumps(result, sort_keys=True))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/libs/cua-s1/python/tests/conftest.py b/libs/cua-s1/python/tests/conftest.py
new file mode 100644
index 0000000000..3354b59ad0
--- /dev/null
+++ b/libs/cua-s1/python/tests/conftest.py
@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+COMPONENT_ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ROOT = COMPONENT_ROOT / "python" / "src"
+
+sys.path.insert(0, str(SOURCE_ROOT))
+sys.path.insert(0, str(COMPONENT_ROOT))
diff --git a/libs/cua-s1/python/tests/test_autoresearch.py b/libs/cua-s1/python/tests/test_autoresearch.py
new file mode 100644
index 0000000000..5362df2517
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_autoresearch.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+TRAINING_ROOT = Path(__file__).resolve().parents[2] / "training"
+sys.path.insert(0, str(TRAINING_ROOT))
+
+from autoresearch import build_manifest, select_best # noqa: E402
+from train import configure_determinism # noqa: E402
+
+
+def _record(name: str, top1: float, nll: float, test_top1: float = 0.99) -> dict:
+ return {
+ "name": name,
+ "best_validation": {"top1": top1, "nll": nll},
+ "test": {"top1": test_top1},
+ }
+
+
+def test_select_best_uses_validation_metrics_and_deterministic_tiebreaks():
+ records = [
+ _record("higher-test-only", 0.8, 0.3, test_top1=1.0),
+ _record("lower-nll", 0.9, 0.2, test_top1=0.1),
+ _record("higher-nll", 0.9, 0.4),
+ _record("z-name-tiebreak", 0.9, 0.2),
+ ]
+
+ assert select_best(records)["name"] == "z-name-tiebreak"
+
+
+def test_build_manifest_records_selection_and_replay_settings():
+ records = [_record("first", 0.7, 0.5), _record("winner", 0.8, 0.4)]
+
+ assert build_manifest(records, base_seed=17, deterministic=True) == {
+ "base_seed": 17,
+ "deterministic": True,
+ "best": "winner",
+ "best_checkpoint": "best",
+ "experiments": records,
+ }
+
+
+def test_deterministic_configuration_does_not_allow_warning_only(monkeypatch):
+ calls = []
+ monkeypatch.setattr(
+ "train.torch.use_deterministic_algorithms",
+ lambda enabled, **kwargs: calls.append((enabled, kwargs)),
+ )
+
+ configure_determinism(seed=5, deterministic=True)
+
+ assert calls == [(True, {})]
+
+
+def test_select_best_rejects_empty_records():
+ with pytest.raises(ValueError, match="empty result set"):
+ select_best([])
diff --git a/libs/cua-s1/python/tests/test_checkpoint.py b/libs/cua-s1/python/tests/test_checkpoint.py
new file mode 100644
index 0000000000..789ac9f6d2
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_checkpoint.py
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from cua_s1.checkpoint import (
+ load_checkpoint_files,
+ resolve_checkpoint_paths,
+ save_checkpoint_files,
+)
+
+
[email protected]("suffix", [".pt", ".pth", ".bin", ".pkl", ".pickle"])
+def test_pickle_based_checkpoints_are_rejected(suffix, tmp_path):
+ with pytest.raises(ValueError, match="pickle-based"):
+ resolve_checkpoint_paths(tmp_path / f"model{suffix}")
+
+
+def test_checkpoint_path_resolution_is_explicit(tmp_path):
+ assert resolve_checkpoint_paths(tmp_path / "run") == (
+ tmp_path / "run" / "model.safetensors",
+ tmp_path / "run" / "config.json",
+ )
+ assert resolve_checkpoint_paths(tmp_path / "named.safetensors") == (
+ tmp_path / "named.safetensors",
+ tmp_path / "named.json",
+ )
+
+
+def test_safetensors_checkpoint_round_trip_uses_data_only_files(tmp_path):
+ torch = pytest.importorskip("torch")
+ pytest.importorskip("safetensors")
+ state = {
+ "projection.weight": torch.arange(6, dtype=torch.float32).reshape(2, 3),
+ "projection.bias": torch.tensor([0.25, -0.5]),
+ }
+
+ weights_path, config_path = save_checkpoint_files(
+ tmp_path / "checkpoint",
+ state,
+ {"encoder": "tiny", "width": 3},
+ {"epoch": 2},
+ )
+ loaded_state, config, metadata = load_checkpoint_files(tmp_path / "checkpoint")
+
+ assert weights_path.suffix == ".safetensors"
+ assert config_path.suffix == ".json"
+ assert config == {"encoder": "tiny", "width": 3}
+ assert metadata == {"epoch": 2}
+ assert set(loaded_state) == set(state)
+ for name, tensor in state.items():
+ assert torch.equal(loaded_state[name], tensor)
+
+
+def test_checkpoint_rejects_malformed_or_wrong_format_json(tmp_path):
+ pytest.importorskip("safetensors")
+ weights_path, config_path = resolve_checkpoint_paths(tmp_path / "checkpoint")
+ weights_path.parent.mkdir()
+ weights_path.write_bytes(b"not safetensors")
+ config_path.write_text("not json", encoding="utf-8")
+
+ with pytest.raises(ValueError, match="invalid checkpoint JSON"):
+ load_checkpoint_files(tmp_path / "checkpoint")
+
+ config_path.write_text(
+ json.dumps({"format": "other", "format_version": 1, "config": {}}),
+ encoding="utf-8",
+ )
+ with pytest.raises(ValueError, match="unsupported checkpoint format"):
+ load_checkpoint_files(tmp_path / "checkpoint")
+
+
+def test_checkpoint_requires_json_serializable_metadata(tmp_path):
+ torch = pytest.importorskip("torch")
+ pytest.importorskip("safetensors")
+
+ with pytest.raises(ValueError, match="JSON serializable"):
+ save_checkpoint_files(
+ tmp_path / "checkpoint",
+ {"weight": torch.ones(1)},
+ {"encoder": "tiny"},
+ {"bad": object()},
+ )
+
+
+def test_checkpoint_rejects_mismatched_weight_and_config_pairs(tmp_path):
+ torch = pytest.importorskip("torch")
+ pytest.importorskip("safetensors")
+ first = tmp_path / "first"
+ second = tmp_path / "second"
+ save_checkpoint_files(first, {"weight": torch.ones(2)}, {"width": 2})
+ save_checkpoint_files(second, {"weight": torch.zeros(3)}, {"width": 3})
+
+ (first / "config.json").write_bytes((second / "config.json").read_bytes())
+
+ with pytest.raises(ValueError, match="state signature mismatch"):
+ load_checkpoint_files(first)
+
+
+def test_checkpoint_rejects_config_tampering_even_when_shapes_match(tmp_path):
+ torch = pytest.importorskip("torch")
+ pytest.importorskip("safetensors")
+ checkpoint = tmp_path / "checkpoint"
+ save_checkpoint_files(checkpoint, {"weight": torch.ones(2)}, {"width": 2})
+ config_path = checkpoint / "config.json"
+ document = json.loads(config_path.read_text(encoding="utf-8"))
+ document["config"]["width"] = 9
+ config_path.write_text(json.dumps(document), encoding="utf-8")
+
+ with pytest.raises(ValueError, match="state signature mismatch"):
+ load_checkpoint_files(checkpoint)
diff --git a/libs/cua-s1/python/tests/test_driver.py b/libs/cua-s1/python/tests/test_driver.py
new file mode 100644
index 0000000000..930b8e833b
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_driver.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from cua_s1.driver import BaseDriver, DriverError, WindowSnapshot, WindowTarget
+from cua_s1.schema import Element
+
+
+class StubDriver(BaseDriver):
+ def __init__(self, windows):
+ super().__init__(session="test")
+ self.windows = windows
+
+ def call(self, tool, **args):
+ assert tool == "list_windows"
+ return {"windows": self.windows}
+
+
+class MutationDriver(BaseDriver):
+ def __init__(self, action):
+ super().__init__(session="test")
+ self.action = action
+
+ def call(self, tool, **args):
+ if tool == "click":
+ return self.action
+ if tool == "get_window_state":
+ return {
+ "snapshot_id": "snapshot-2",
+ "elements_complete": True,
+ "elements": [],
+ }
+ raise AssertionError(tool)
+
+
+def test_find_window_rejects_ambiguous_and_missing_targets():
+ driver = StubDriver(
+ [
+ {"pid": 10, "window_id": 20, "title": "Application form", "is_on_screen": True},
+ {"pid": 10, "window_id": 21, "title": "Application form", "is_on_screen": True},
+ ]
+ )
+
+ with pytest.raises(DriverError) as ambiguous:
+ driver.find_window(title_contains="application")
+ assert ambiguous.value.code == "ambiguous_window"
+ assert len(ambiguous.value.details["matches"]) == 2
+
+ with pytest.raises(DriverError) as missing:
+ driver.find_window(window_id=999)
+ assert missing.value.code == "window_not_found"
+
+ assert driver.find_window(pid=10, window_id=21)["window_id"] == 21
+
+
+def test_snapshot_requires_a_unique_fresh_element_token():
+ planned = Element("Edit", "Email", index=4)
+ target = WindowTarget(10, 20)
+ snapshot = WindowSnapshot(
+ target=target,
+ elements=[Element("Edit", "Email", index=4, element_token="snapshot-token")],
+ snapshot_id="snapshot-1",
+ tree_markdown="",
+ elements_complete=True,
+ raw={},
+ )
+ assert snapshot.token_for(planned) == "snapshot-token"
+
+ duplicate = WindowSnapshot(
+ target=target,
+ elements=[
+ Element("Edit", "Email", index=4, element_token="one"),
+ Element("Edit", "Email", index=4, element_token="two"),
+ ],
+ snapshot_id="snapshot-2",
+ tree_markdown="",
+ elements_complete=True,
+ raw={},
+ )
+ with pytest.raises(DriverError) as caught:
+ duplicate.token_for(planned)
+ assert caught.value.code == "element_not_uniquely_resolved"
+
+
[email protected]("action", [{}, {"effect": "unverifiable", "route": "accessibility"}])
+def test_mutation_requires_a_confirmed_driver_effect(action):
+ driver = MutationDriver(action)
+
+ with pytest.raises(DriverError) as caught:
+ driver.click(WindowTarget(10, 20), "token", delivery_mode="background")
+
+ assert caught.value.code == "action_effect_unconfirmed"
+ assert caught.value.outcome_unknown is True
+ assert caught.value.details["post_action_observation"]["snapshot_id"] == "snapshot-2"
+
+
+def test_set_value_is_optional_and_fails_closed_without_discovery():
+ driver = MutationDriver({"effect": "confirmed", "route": "accessibility"})
+
+ assert driver.supports_value_mutation() is False
+ with pytest.raises(DriverError) as caught:
+ driver.set_value(WindowTarget(10, 20), "token", "value")
+ assert caught.value.code == "unsupported_driver_capability"
+
+
+def test_click_payload_and_effect_expectations_conform_to_portable_manifest():
+ manifest_path = Path(__file__).parents[3] / "cua-driver" / "contract" / "manifest.json"
+ manifest = json.loads(manifest_path.read_text())
+ click = next(tool for tool in manifest["tools"] if tool["name"] == "click")
+
+ assert {"target", "delivery_mode"} <= set(click["input_schema"]["required"])
+ effect = click["success_output_schema"]["properties"]["effect"]
+ assert "effect" in click["success_output_schema"]["required"]
+ assert set(effect["enum"]) == {
+ "confirmed",
+ "partial",
+ "unverifiable",
+ "suspected_noop",
+ "refused",
+ }
+ assert all(tool["name"] != "set_value" for tool in manifest["tools"])
diff --git a/libs/cua-s1/python/tests/test_eval_metrics.py b/libs/cua-s1/python/tests/test_eval_metrics.py
new file mode 100644
index 0000000000..919f47ce76
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_eval_metrics.py
@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import pytest
+from evals.metrics import evaluate_predictions
+
+
+def test_metrics_separate_abstention_wrong_action_and_wrong_target():
+ gold = [
+ {"id": "name", "action": "fill", "target": 0},
+ {"id": "consent", "action": "check"},
+ {"id": "promo", "action": "abstain"},
+ {"id": "city", "action": "fill", "target": 3},
+ ]
+ predictions = [
+ {"id": "name", "action": "fill", "target": 0},
+ {"id": "consent", "action": "click"},
+ {"id": "promo", "action": "fill", "target": 1},
+ {"id": "city", "action": "fill", "target": 2},
+ ]
+
+ report = evaluate_predictions(gold, predictions)
+
+ assert report["accuracy"] == pytest.approx(0.25)
+ assert report["wrong_action_rate"] == pytest.approx(0.5)
+ assert report["wrong_target_rate"] == pytest.approx(0.25)
+ assert report["unsafe_action_rate"] == pytest.approx(0.25)
+ assert report["coverage"] == 1.0
+
+
+def test_metrics_accept_equivalent_targets_and_treat_missing_as_abstention():
+ gold = [
+ {
+ "id": "phone",
+ "acceptable": [
+ {"action": "fill", "target": "mobile"},
+ {"action": "fill", "target": "telephone"},
+ ],
+ },
+ {"id": "unknown", "action": "abstain"},
+ ]
+
+ report = evaluate_predictions(gold, [{"id": "phone", "action": "fill", "target": "telephone"}])
+
+ assert report["accuracy"] == 1.0
+ assert report["abstention_rate"] == pytest.approx(0.5)
+ assert report["selective_accuracy"] == 1.0
+
+
+def test_skip_and_abstain_are_equivalent_safety_choices():
+ report = evaluate_predictions(
+ [{"id": "optional", "action": "skip"}],
+ [{"id": "optional", "action": "abstain"}],
+ )
+
+ assert report["accuracy"] == 1.0
+ assert report["abstention_rate"] == 1.0
+ assert report["unsafe_action_rate"] == 0.0
+
+
+def test_metrics_reject_predictions_for_unknown_cases():
+ with pytest.raises(ValueError, match="unknown ids"):
+ evaluate_predictions([], [{"id": "surprise", "action": "click"}])
diff --git a/libs/cua-s1/python/tests/test_model.py b/libs/cua-s1/python/tests/test_model.py
new file mode 100644
index 0000000000..0d9c6ae47e
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_model.py
@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import pytest
+
+torch = pytest.importorskip("torch")
+
+from cua_s1.model import ( # noqa: E402
+ ByteCollator,
+ ChoiceExample,
+ load_checkpoint,
+ make_system,
+ save_checkpoint,
+ validate_example,
+)
+
+TINY_CONFIG = {
+ "encoder": "tiny",
+ "width": 8,
+ "rank": 4,
+ "context_tokens": 32,
+ "option_tokens": 16,
+}
+
+
+def test_choice_example_validation_rejects_invalid_labels():
+ example = validate_example({"context": "field", "options": ["fill value", "skip"], "label": 1})
+ assert example == ChoiceExample("field", ("fill value", "skip"), 1)
+
+ with pytest.raises(ValueError, match="valid option index"):
+ validate_example({"context": "field", "options": ["a", "b"], "label": 2})
+ with pytest.raises(ValueError, match="at least two"):
+ validate_example({"context": "field", "options": ["skip"], "label": 0})
+
+
+def test_byte_collator_masks_variable_option_counts():
+ batch = ByteCollator(context_tokens=8, option_tokens=6)(
+ [
+ ChoiceExample("abc", ("one", "two"), 0),
+ ChoiceExample("xy", ("one", "two", "three"), 2),
+ ]
+ )
+
+ assert batch["context_ids"].shape == (2, 3)
+ assert batch["option_ids"].shape == (2, 3, 5)
+ assert batch["option_mask"].tolist() == [[True, True, False], [True, True, True]]
+ assert batch["labels"].tolist() == [0, 2]
+
+
+def test_tiny_model_scores_options_without_downloading_weights():
+ model, collator = make_system(TINY_CONFIG, "cpu")
+ batch = collator(
+ [
+ ChoiceExample("email field", ("fill email", "skip"), 0),
+ ChoiceExample("button", ("click", "skip", "check"), 1),
+ ]
+ )
+
+ logits = model(batch)
+
+ assert logits.shape == (2, 3)
+ assert torch.isfinite(logits[0, :2]).all()
+ assert torch.isneginf(logits[0, 2]) or logits[0, 2] < -1e20
+ assert torch.isfinite(logits[1]).all()
+
+
+def test_make_system_rejects_unknown_or_invalid_configs():
+ with pytest.raises(ValueError, match="encoder"):
+ make_system({**TINY_CONFIG, "encoder": "unknown"}, "cpu")
+ with pytest.raises(ValueError, match="'tiny' or 'tinyx'"):
+ make_system({**TINY_CONFIG, "encoder": "hf", "hf_model": "remote/model"}, "cpu")
+ with pytest.raises(ValueError, match="positive integer"):
+ make_system({**TINY_CONFIG, "width": 0}, "cpu")
+
+
+def test_model_checkpoint_round_trip_preserves_logits(tmp_path):
+ pytest.importorskip("safetensors")
+ torch.manual_seed(7)
+ model, collator = make_system(TINY_CONFIG, "cpu")
+ model.eval()
+ examples = [ChoiceExample("city", ("fill city", "skip", "click"), 0)]
+ expected = model(collator(examples)).detach()
+
+ save_checkpoint(tmp_path / "checkpoint", model, TINY_CONFIG, {"synthetic": True})
+ restored, restored_collator, restored_config = load_checkpoint(tmp_path / "checkpoint", "cpu")
+ actual = restored(restored_collator(examples)).detach()
+
+ assert restored_config == TINY_CONFIG
+ assert torch.equal(actual, expected)
diff --git a/libs/cua-s1/python/tests/test_pdf.py b/libs/cua-s1/python/tests/test_pdf.py
new file mode 100644
index 0000000000..4b20019d8f
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_pdf.py
@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+import sys
+from types import SimpleNamespace
+
+import pytest
+
+from cua_s1.pdf import PdfError, derive_entities, extract_entities, resolve_pdf_path
+from cua_s1.schema import Entity
+
+
+def test_pdf_path_is_confined_to_allowed_roots(tmp_path):
+ allowed = tmp_path / "allowed"
+ allowed.mkdir()
+ inside = allowed / "record.pdf"
+ inside.write_bytes(b"%PDF-1.4\n")
+ outside = tmp_path / "outside.pdf"
+ outside.write_bytes(b"%PDF-1.4\n")
+
+ assert resolve_pdf_path(inside, allowed_roots=[allowed]) == inside.resolve()
+ with pytest.raises(PdfError) as caught:
+ resolve_pdf_path(outside, allowed_roots=[allowed])
+ assert caught.value.code == "pdf_path_not_allowed"
+
+
+def test_pdf_path_rejects_symlink_escape_and_oversized_file(tmp_path):
+ allowed = tmp_path / "allowed"
+ allowed.mkdir()
+ outside = tmp_path / "outside.pdf"
+ outside.write_bytes(b"%PDF-1.4\n")
+ link = allowed / "linked.pdf"
+ try:
+ link.symlink_to(outside)
+ except OSError:
+ pytest.skip("symlinks are not available")
+
+ with pytest.raises(PdfError) as escaped:
+ resolve_pdf_path(link, allowed_roots=[allowed])
+ assert escaped.value.code == "pdf_path_not_allowed"
+
+ local = allowed / "large.pdf"
+ local.write_bytes(b"12345")
+ with pytest.raises(PdfError) as oversized:
+ resolve_pdf_path(local, allowed_roots=[allowed], max_bytes=4)
+ assert oversized.value.code == "pdf_too_large"
+ assert oversized.value.details["size_bytes"] == 5
+
+
+def test_extract_entities_enforces_page_bound_before_text_extraction(monkeypatch, tmp_path):
+ path = tmp_path / "record.pdf"
+ path.write_bytes(b"%PDF-1.4\n")
+
+ class Page:
+ def extract_text(self):
+ raise AssertionError("text extraction must not begin after the page limit is exceeded")
+
+ class Document:
+ pages = [Page(), Page()]
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *_args):
+ return None
+
+ monkeypatch.setitem(sys.modules, "pdfplumber", SimpleNamespace(open=lambda _stream: Document()))
+
+ with pytest.raises(PdfError) as caught:
+ extract_entities(path, allowed_roots=[tmp_path], max_pages=1)
+ assert caught.value.code == "pdf_too_many_pages"
+ assert caught.value.details == {"path": str(path), "pages": 2, "max_pages": 1}
+
+
+def test_extract_entities_refuses_a_symlink_swap_before_open(monkeypatch, tmp_path):
+ path = tmp_path / "record.pdf"
+ path.write_bytes(b"%PDF-1.4\n")
+ outside = tmp_path.parent / "outside.pdf"
+ outside.write_bytes(b"%PDF-1.4\nsecret")
+ real_open = os.open
+ swapped = False
+
+ def swap_then_open(candidate, flags):
+ nonlocal swapped
+ if not swapped and candidate == path.resolve():
+ swapped = True
+ path.unlink()
+ path.symlink_to(outside)
+ return real_open(candidate, flags)
+
+ monkeypatch.setattr(os, "open", swap_then_open)
+
+ with pytest.raises(PdfError) as caught:
+ extract_entities(path, allowed_roots=[tmp_path])
+ assert caught.value.code == "pdf_open_failed"
+
+
+def test_derive_entities_adds_only_missing_name_variants():
+ derived = derive_entities([Entity("Full name", "Avery Chen")])
+ assert derived == [
+ Entity("Full name", "Avery Chen"),
+ Entity("First name", "Avery"),
+ Entity("Last name", "Chen"),
+ ]
+
+ combined = derive_entities([Entity("First name", "Avery"), Entity("Last name", "Chen")])
+ assert combined[-1] == Entity("Full name", "Avery Chen")
diff --git a/libs/cua-s1/python/tests/test_planner.py b/libs/cua-s1/python/tests/test_planner.py
new file mode 100644
index 0000000000..b1b3ddd834
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_planner.py
@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+from cua_s1.driver import BaseDriver, MutationResult, WindowSnapshot, WindowTarget
+from cua_s1.planner import Planner, PlannerError, order_decisions, run_form
+from cua_s1.schema import Decision, Element, Entity
+
+TARGET = WindowTarget(42, 7)
+ENTITIES = [Entity("Email", "[email protected]")]
+
+
+def _elements(generation: int = 1):
+ return [
+ Element("Edit", "Email", index=1, element_token=f"email-{generation}"),
+ Element(
+ "CheckBox",
+ "I agree",
+ index=2,
+ checked=generation >= 3,
+ element_token=f"agree-{generation}",
+ ),
+ Element("Button", "Submit", index=3, element_token=f"submit-{generation}"),
+ Element("Button", "Cancel", index=4, element_token=f"cancel-{generation}"),
+ Element("StaticText", "Heading", index=5, element_token=f"heading-{generation}"),
+ ]
+
+
+def _snapshot(generation: int):
+ return WindowSnapshot(
+ target=TARGET,
+ elements=_elements(generation),
+ snapshot_id=f"snapshot-{generation}",
+ tree_markdown="",
+ elements_complete=True,
+ raw={},
+ )
+
+
+class RecordingDriver(BaseDriver):
+ def __init__(self):
+ super().__init__(session="test")
+ self.generation = 1
+ self.mutations = []
+
+ def window_state(self, target):
+ assert target == TARGET
+ return _snapshot(self.generation)
+
+ def set_value(self, target, element_token, value):
+ self.mutations.append(("fill", element_token, value))
+ self.generation += 1
+ return MutationResult(
+ {"effect": "confirmed", "route": "accessibility"}, _snapshot(self.generation)
+ )
+
+ def click(self, target, element_token, *, delivery_mode):
+ self.mutations.append(("click", element_token, delivery_mode))
+ self.generation += 1
+ return MutationResult(
+ {"effect": "confirmed", "route": "accessibility"}, _snapshot(self.generation)
+ )
+
+
+def backend(_title, elements, _entities):
+ actions = {
+ "Email": ("fill", 0, 0.99),
+ "I agree": ("check", None, 0.95),
+ "Submit": ("click", None, 0.90),
+ "Cancel": ("click", None, 0.98),
+ }
+ return [Decision(element, *actions[element.label]) for element in elements]
+
+
+def test_run_form_is_dry_run_by_default_and_submit_stays_gated():
+ driver = RecordingDriver()
+
+ report = run_form(Planner(backend), driver, ENTITIES, target=TARGET, form_title="Example form")
+
+ assert driver.mutations == []
+ assert [entry["action"] for entry in report["execution_order"]] == ["fill", "check"]
+ assert all(entry["status"] == "planned" for entry in report["execution_order"])
+ assert report["authorization"] == {
+ "execute": False,
+ "submit": False,
+ "delivery_mode": "background",
+ "note": None,
+ }
+
+
+def test_execution_reobserves_before_each_mutation_and_requires_submit_opt_in():
+ driver = RecordingDriver()
+
+ report = run_form(
+ Planner(backend),
+ driver,
+ ENTITIES,
+ target=TARGET,
+ form_title="Example form",
+ execute=True,
+ submit=True,
+ )
+
+ assert driver.mutations == [
+ ("fill", "email-1", "[email protected]"),
+ ("click", "agree-2", "background"),
+ ("click", "submit-3", "background"),
+ ]
+ assert [entry["post_snapshot_id"] for entry in report["execution_order"]] == [
+ "snapshot-2",
+ "snapshot-3",
+ "snapshot-4",
+ ]
+ assert report["final_snapshot"]["snapshot_id"] == "snapshot-4"
+
+
+def test_order_decisions_keeps_one_submit_and_applies_confidence_threshold():
+ email, checkbox, submit, cancel, _ = _elements()
+ decisions = [
+ Decision(submit, "click", None, 0.8),
+ Decision(email, "fill", 0, 0.9),
+ Decision(cancel, "click", None, 0.7),
+ Decision(checkbox, "check", None, 0.4),
+ ]
+
+ ordered = order_decisions(decisions, 0.5, allow_submit=True)
+
+ assert [(decision.action, decision.element.label) for decision in ordered] == [
+ ("fill", "Email"),
+ ("click", "Submit"),
+ ]
+
+
+ ("role", "label"),
+ [
+ ("Button", "Cancel"),
+ ("Button", "Delete"),
+ ("Button", "Continue"),
+ ("Edit", "Submit"),
+ ],
+)
+def test_submit_authorization_never_executes_non_submit_clicks(role, label):
+ element = Element(role, label, index=1, element_token="target-1")
+
+ class SingleElementDriver(RecordingDriver):
+ def window_state(self, target):
+ return WindowSnapshot(target, [element], "snapshot-1", "", True, {})
+
+ planner = Planner(
+ lambda _title, elements, _entities: [Decision(elements[0], "click", None, 1.0)]
+ )
+ driver = SingleElementDriver()
+
+ report = run_form(
+ planner,
+ driver,
+ [],
+ target=TARGET,
+ form_title="Form",
+ execute=True,
+ submit=True,
+ )
+
+ assert driver.mutations == []
+ assert report["execution_order"] == []
+
+
+def test_planner_rejects_foreign_elements_and_invalid_entity_pointers():
+ element = Element("Edit", "Email", index=1)
+ foreign = replace(element)
+
+ with pytest.raises(PlannerError) as caught:
+ Planner(lambda *_args: [Decision(foreign, "fill", 0, 0.9)]).plan(
+ "form", [element], ENTITIES
+ )
+ assert caught.value.code == "foreign_element"
+
+ with pytest.raises(PlannerError) as caught:
+ Planner(lambda *_args: [Decision(element, "fill", 9, 0.9)]).plan(
+ "form", [element], ENTITIES
+ )
+ assert caught.value.code == "invalid_entity_index"
+
+
+def test_planner_rejects_duplicate_decisions_even_when_count_matches():
+ first = Element("Edit", "First", index=1, element_token="first")
+ second = Element("Edit", "Second", index=2, element_token="second")
+
+ with pytest.raises(PlannerError) as caught:
+ Planner(
+ lambda *_args: [
+ Decision(first, "skip", None, 1.0),
+ Decision(first, "skip", None, 1.0),
+ ]
+ ).plan("form", [first, second], [])
+
+ assert caught.value.code == "duplicate_decision"
+ assert caught.value.details["element_index"] == 1
+
+
+def test_planner_rejects_omitted_element_decisions():
+ first = Element("Edit", "First", index=1, element_token="first")
+ second = Element("Edit", "Second", index=2, element_token="second")
+
+ with pytest.raises(PlannerError) as caught:
+ Planner(lambda *_args: [Decision(first, "skip", None, 1.0)]).plan(
+ "form", [first, second], []
+ )
+
+ assert caught.value.code == "missing_decisions"
+ assert caught.value.details["missing_element_indices"] == [2]
+
+
+def test_planner_matches_recreated_decisions_by_stable_element_token():
+ supplied = Element("Button", "Submit", index=1, element_token="submit-token")
+ recreated = replace(supplied, label="untrusted replacement")
+
+ decisions = Planner(lambda *_args: [Decision(recreated, "click", None, 1.0)]).plan(
+ "form", [supplied], []
+ )
+
+ assert decisions[0].element is supplied
+
+
+def test_check_is_idempotent_when_checkbox_is_already_checked():
+ driver = RecordingDriver()
+ driver.generation = 3
+
+ report = run_form(
+ Planner(backend),
+ driver,
+ ENTITIES,
+ target=TARGET,
+ form_title="Example form",
+ execute=True,
+ )
+
+ assert driver.mutations == [("fill", "email-3", "[email protected]")]
+ check = next(entry for entry in report["execution_order"] if entry["action"] == "check")
+ assert check["status"] == "already_satisfied"
+ assert check["executed"] is False
+
+
+ ("element", "code"),
+ [
+ (
+ Element("Button", "I agree", index=2, checked=False, element_token="token"),
+ "check_requires_checkbox",
+ ),
+ (
+ Element("CheckBox", "I agree", index=2, checked=None, element_token="token"),
+ "checkbox_state_unknown",
+ ),
+ ],
+)
+def test_check_refuses_non_checkbox_or_unknown_state(element, code):
+ class RefusingDriver(RecordingDriver):
+ def window_state(self, target):
+ return WindowSnapshot(target, [element], "snapshot", "", True, {})
+
+ planner = Planner(
+ lambda _title, elements, _entities: [Decision(elements[0], "check", None, 1.0)]
+ )
+ report = run_form(planner, RefusingDriver(), [], target=TARGET, form_title="Form", execute=True)
+
+ assert report["execution_order"][0]["error"]["code"] == code
+ assert report["stopped_after_error"] is True
+
+
+def test_execution_refuses_incomplete_or_unbound_snapshots():
+ class IncompleteDriver(RecordingDriver):
+ def __init__(self, snapshot_id, complete):
+ super().__init__()
+ self.snapshot_id = snapshot_id
+ self.complete = complete
+
+ def window_state(self, target):
+ return WindowSnapshot(target, _elements(), self.snapshot_id, "", self.complete, {})
+
+ for snapshot_id, complete, code in [
+ (None, True, "snapshot_id_required"),
+ ("snapshot", False, "incomplete_window_snapshot"),
+ ]:
+ report = run_form(
+ Planner(backend),
+ IncompleteDriver(snapshot_id, complete),
+ ENTITIES,
+ target=TARGET,
+ form_title="Form",
+ execute=True,
+ )
+ assert report["execution_order"][0]["error"]["code"] == code
+
+
+def test_check_verifies_checked_postcondition():
+ class FailedCheckboxDriver(RecordingDriver):
+ def click(self, target, element_token, *, delivery_mode):
+ self.mutations.append(("click", element_token, delivery_mode))
+ observation = WindowSnapshot(
+ TARGET,
+ [Element("CheckBox", "I agree", index=2, checked=False, element_token="next")],
+ "snapshot-next",
+ "",
+ True,
+ {},
+ )
+ return MutationResult({"effect": "confirmed", "route": "accessibility"}, observation)
+
+ def window_state(self, target):
+ return WindowSnapshot(
+ TARGET,
+ [Element("CheckBox", "I agree", index=2, checked=False, element_token="token")],
+ "snapshot",
+ "",
+ True,
+ {},
+ )
+
+ planner = Planner(
+ lambda _title, elements, _entities: [Decision(elements[0], "check", None, 1.0)]
+ )
+ report = run_form(
+ planner, FailedCheckboxDriver(), [], target=TARGET, form_title="Form", execute=True
+ )
+
+ assert report["execution_order"][0]["error"]["code"] == "checkbox_postcondition_failed"
+
+
+def test_execution_refuses_legacy_action_response_without_effect():
+ class LegacyDriver(RecordingDriver):
+ def set_value(self, target, element_token, value):
+ return MutationResult({}, _snapshot(2))
+
+ report = run_form(
+ Planner(backend),
+ LegacyDriver(),
+ ENTITIES,
+ target=TARGET,
+ form_title="Form",
+ execute=True,
+ )
+
+ error = report["execution_order"][0]["error"]
+ assert error["code"] == "action_effect_unconfirmed"
+ assert error["outcome_unknown"] is True
diff --git a/libs/cua-s1/python/tests/test_schema.py b/libs/cua-s1/python/tests/test_schema.py
new file mode 100644
index 0000000000..cd09300a5c
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_schema.py
@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import pytest
+
+from cua_s1.schema import (
+ FIXED_ACTIONS,
+ Element,
+ Entity,
+ decode,
+ encode,
+ render_context,
+ render_options,
+)
+
+
+def test_options_are_entity_pointers_followed_by_fixed_actions():
+ entities = [Entity("Primary email", "[email protected]"), Entity("City", "Oslo")]
+
+ options = render_options(entities)
+
+ assert options[:2] == [
+ "fill Primary email: [email protected]",
+ "fill City: Oslo",
+ ]
+ assert options[2:] == list(FIXED_ACTIONS)
+
+
+def test_action_encoding_round_trips_without_copying_entity_values():
+ entities = [Entity("Account", "synthetic-001"), Entity("Account", "synthetic-002")]
+
+ for entity_index in range(len(entities)):
+ encoded = encode("fill", entity_index, entities)
+ assert decode(encoded, entities) == ("fill", entity_index)
+ for action in FIXED_ACTIONS:
+ encoded = encode(action, None, entities)
+ assert decode(encoded, entities) == (action, None)
+
+
+def test_invalid_action_encodings_are_rejected():
+ entities = [Entity("Name", "Example Person")]
+
+ with pytest.raises((ValueError, IndexError)):
+ encode("fill", 4, entities)
+ with pytest.raises((ValueError, IndexError)):
+ encode("unknown", None, entities)
+ with pytest.raises((ValueError, IndexError)):
+ decode(len(entities) + len(FIXED_ACTIONS), entities)
+ with pytest.raises((ValueError, IndexError)):
+ decode(-1, entities)
+
+
+def test_context_is_bounded_and_represents_checkbox_state():
+ long_text = "x" * 500
+ context = render_context(
+ long_text,
+ Element("CheckBox", long_text, checked=True),
+ placeholder=long_text,
+ )
+
+ assert "checked" in context
+ assert "unchecked" not in context
+ assert len(context.encode("utf-8")) < 400
diff --git a/libs/cua-s1/python/tests/test_server.py b/libs/cua-s1/python/tests/test_server.py
new file mode 100644
index 0000000000..d1cf532ec8
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_server.py
@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from cua_s1.pdf import PdfError
+from cua_s1.server import structured_errors
+
+
+def test_structured_errors_redact_paths_and_accessibility_values():
+ @structured_errors
+ def fail():
+ raise PdfError(
+ "failed",
+ "Failure",
+ path="/private/records/person.pdf",
+ allowed_roots=["/private/records"],
+ response={
+ "tree_markdown": '[1] AXTextField "Secret" [value="private"]',
+ "element": {"label": "Secret", "value": "private"},
+ },
+ host_location=r"C:\Users\person\record.pdf",
+ safe_count=2,
+ )
+
+ error = fail()["error"]
+
+ assert error["details"] == {
+ "path": "<redacted>",
+ "allowed_roots": "<redacted>",
+ "response": "<redacted>",
+ "host_location": "<redacted-path>",
+ "safe_count": 2,
+ }
+ assert "/private" not in repr(error)
+ assert "Secret" not in repr(error)
diff --git a/libs/cua-s1/python/tests/test_synth.py b/libs/cua-s1/python/tests/test_synth.py
new file mode 100644
index 0000000000..b2007432ff
--- /dev/null
+++ b/libs/cua-s1/python/tests/test_synth.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import hashlib
+import json
+
+import pytest
+
+from cua_s1.synth import SynthesisConfig, episode_rows, write_splits
+
+
+def test_episode_generation_is_seed_deterministic():
+ assert episode_rows(2026) == episode_rows(2026)
+ assert episode_rows(2026) != episode_rows(2027)
+
+
+def test_generated_rows_are_self_consistent_choice_examples():
+ rows = episode_rows(41)
+
+ assert rows
+ signatures = {row["meta"]["form_signature"] for row in rows}
+ assert len(signatures) == 1
+ assert {row["meta"]["seed"] for row in rows} == {41}
+ for row in rows:
+ assert row["context"]
+ assert len(row["options"]) >= 3
+ assert 0 <= row["label"] < len(row["options"])
+ assert row["meta"]["action"] in {"fill", "check", "click", "skip"}
+
+
+def test_split_files_are_reproducible_and_form_disjoint(tmp_path):
+ first = tmp_path / "first"
+ second = tmp_path / "second"
+
+ assert write_splits(first, episodes=120, seed=1234) == write_splits(
+ second, episodes=120, seed=1234
+ )
+
+ signatures_by_split = {}
+ for split in ("train", "validation", "test"):
+ first_bytes = (first / f"{split}.jsonl").read_bytes()
+ assert first_bytes == (second / f"{split}.jsonl").read_bytes()
+ rows = [json.loads(line) for line in first_bytes.splitlines()]
+ signatures_by_split[split] = {row["meta"]["form_signature"] for row in rows}
+
+ assert signatures_by_split["train"].isdisjoint(signatures_by_split["validation"])
+ assert signatures_by_split["train"].isdisjoint(signatures_by_split["test"])
+ assert signatures_by_split["validation"].isdisjoint(signatures_by_split["test"])
+
+ first_manifest = json.loads((first / "manifest.json").read_text(encoding="utf-8"))
+ second_manifest = json.loads((second / "manifest.json").read_text(encoding="utf-8"))
+ assert first_manifest == second_manifest
+ assert first_manifest["format"] == "cua-s1-choice-jsonl"
+ assert first_manifest["format_version"] == 1
+ assert first_manifest["generator"]["format"] == "cua_s1.synth"
+ assert first_manifest["generator"]["config"] == {
+ "filled_field_probability": 0.6,
+ "hard_negative_probability": 0.35,
+ "max_distractor_entities": 3,
+ "max_extra_entities": 5,
+ "missing_entity_probability": 0.12,
+ "partial_form_probability": 0.3,
+ "stale_value_probability": 0.05,
+ }
+ assert first_manifest["ratios"] == {"train": 0.8, "validation": 0.1, "test": 0.1}
+ assert first_manifest["seed"] == 1234
+ assert first_manifest["episodes"] == 120
+ for split in ("train", "validation", "test"):
+ split_bytes = (first / f"{split}.jsonl").read_bytes()
+ assert first_manifest["splits"][split]["sha256"] == hashlib.sha256(split_bytes).hexdigest()
+
+
+ "config",
+ [
+ SynthesisConfig(missing_entity_probability=-0.01),
+ SynthesisConfig(partial_form_probability=1.01),
+ SynthesisConfig(max_extra_entities=-1),
+ ],
+)
+def test_invalid_synthesis_limits_are_rejected(config):
+ with pytest.raises(ValueError):
+ episode_rows(1, config)
diff --git a/libs/cua-s1/python/uv.lock b/libs/cua-s1/python/uv.lock
new file mode 100644
index 0000000000..4839ccc3f4
--- /dev/null
+++ b/libs/cua-s1/python/uv.lock
@@ -0,0 +1,1390 @@
+version = 1
+revision = 3
+requires-python = ">=3.11, <3.14"
+resolution-markers = [
+ "python_full_version >= '3.12'",
+ "python_full_version < '3.12'",
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "idna" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.7.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/70/d2/16d99a0c4948febc0ebd133a13b2f688ff7f8cb04da971e1128872ce0c03/cffi-2.1.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12", size = 183838, upload-time = "2026-08-03T21:19:29.637Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/95/31b535a9f0220ae9f357de4a08d57ce89cb417653c2fd9f075f50822a388/cffi-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1", size = 184168, upload-time = "2026-08-03T21:19:30.764Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/92/500760486c8baab49a7a8a58ba7fc3355ec3974b454b8a09e528efde9e1d/cffi-2.1.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990", size = 205569, upload-time = "2026-08-03T21:19:34.142Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/a7/a67c733254d6e7373f7822f8082d8d6beade791e0cf12a7611f376fa61c7/cffi-2.1.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af", size = 204907, upload-time = "2026-08-03T21:19:35.174Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" },
+ { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" },
+ { url = "https://files.pythonhosted.org/packages/db/e2/7e8109f65445bdc673a7b54f02c677de462db75674220fd1335efc8eb598/cffi-2.1.1-cp311-cp311-win32.whl", hash = "sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3", size = 174470, upload-time = "2026-08-03T21:19:41.246Z" },
+ { url = "https://files.pythonhosted.org/packages/73/c0/77ba02423c2f7d7091143c45cd49e0e6575c4c1967394bb542bd923a9b74/cffi-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0", size = 185096, upload-time = "2026-08-03T21:19:42.615Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/47/9f1f85f9672ceda4984dc6c4f8824e8558992a2972c3d3c81fb8eb28d4ba/cffi-2.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455", size = 179941, upload-time = "2026-08-03T21:19:43.747Z" },
+ { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" },
+ { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" },
+ { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" },
+ { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" },
+ { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" },
+ { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" },
+ { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" },
+ { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" },
+ { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" },
+ { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" },
+ { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" },
+ { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" },
+ { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" },
+ { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" },
+ { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" },
+ { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" },
+ { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" },
+ { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" },
+ { url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" },
+ { url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" },
+ { url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" },
+ { url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" },
+ { url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" },
+ { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" },
+ { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" },
+ { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" },
+ { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" },
+ { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" },
+ { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" },
+ { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" },
+ { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" },
+ { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" },
+ { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" },
+ { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" },
+ { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" },
+ { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" },
+ { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" },
+ { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" },
+ { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" },
+ { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" },
+ { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" },
+ { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" },
+ { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" },
+ { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" },
+ { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "50.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/ad/5d6702db60b1e40b41ef513b6967ff5848f307d50f8449baf1634f5908f1/cryptography-50.0.1.tar.gz", hash = "sha256:5dd9bda1c12b4162f6ff568eeb5e0ff956c28d14406e875cfe8a63a2d414ff20", size = 880381, upload-time = "2026-08-25T19:45:45.499Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ba/19/797e2aaac9df6a66f1550f49979dc1b1e39ecd2077501c30efa81e8d5d67/cryptography-50.0.1-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:b8f852c65863251b9e3a1b8c150ce21e59b522dbb6a7d4bc80e680d38388e986", size = 4010153, upload-time = "2026-08-25T19:44:03.155Z" },
+ { url = "https://files.pythonhosted.org/packages/90/34/9ce9a62ed9dc82ca9fd6a34445b6904af56e5f38b3eae2ed32e49c36053d/cryptography-50.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:53e279950892dc102c6b4e52af03ae5ea92fac572a1ddab78ca73a997f62b69f", size = 4723133, upload-time = "2026-08-25T19:44:05.461Z" },
+ { url = "https://files.pythonhosted.org/packages/57/26/e6d4fc8512a51a5f9ee7bfdbfb853bce1197087df40c9ad993ad370b846f/cryptography-50.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ff838d62ec1bfce4f9ba7fa16f4a7b554cd8d0c299e6be37502161a660c84eef", size = 4712478, upload-time = "2026-08-25T19:44:07.375Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/de/d3cdc2815697aae84126cbd6a030ca7b6b452e28a88b501b836bd3aa7a86/cryptography-50.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e74591e283fe6eb956416c929eb58262a719fe0311fd9054c62c3350ed8760d8", size = 4730726, upload-time = "2026-08-25T19:44:09.294Z" },
+ { url = "https://files.pythonhosted.org/packages/55/32/38c0d344b98c06d34b5df8946565a9c0d6dbf32c8e0730a7f05f0a3c6cab/cryptography-50.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5fe002589592ed749ce77fe0695fcbd3500dd61d7d6db5858a7544c612fa8e45", size = 5353524, upload-time = "2026-08-25T19:44:11.96Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/1b/82f0f0d8858d4432be1af790477edf62aef90324041aa07c57e57bef1af7/cryptography-50.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:51593d180cf6d179bde5c5d065bed81386b1f381656ae7d042b7ffc87a9895ad", size = 4746720, upload-time = "2026-08-25T19:44:14.051Z" },
+ { url = "https://files.pythonhosted.org/packages/29/ba/042ca458b8c64348c768284b5d23e69b92ed53d057ab779fee628564676d/cryptography-50.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:359e62deae718bce96170e223fdcb6357e4fbd3bb7a3a75f4430763532560e49", size = 4361866, upload-time = "2026-08-25T19:44:16.167Z" },
+ { url = "https://files.pythonhosted.org/packages/39/3b/e96c1ef71edef71057c7e3c3d982ce8fda554e0c52d0cc19c18845cde3eb/cryptography-50.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e2ca8fd1b6b4b82a1c4cb02841d0837e3c12336c2e24b520ab8ab3b969733d8f", size = 4730028, upload-time = "2026-08-25T19:44:18.085Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/38/45abd72ef63f2e7d0754a6cacf97bd8b69512ace7f6130d24c39ece65da2/cryptography-50.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:76de83fbd91ac49c0feaaa983d0748fd7a53176afac5fb3bf7478d244f0eb527", size = 5308405, upload-time = "2026-08-25T19:44:20.197Z" },
+ { url = "https://files.pythonhosted.org/packages/85/66/6ccca4722987ddedaa7fc9c3f4708af7431f5535666c174350830888c6b7/cryptography-50.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:51afcfceb15597cf2635068e4ac9a56b2abde622edde17f37d85fd7b5306497a", size = 4746230, upload-time = "2026-08-25T19:44:22.376Z" },
+ { url = "https://files.pythonhosted.org/packages/13/0e/b1f92e013228111413f2e6743948b80bc24dfd3c1b87ba98ceea16f5df89/cryptography-50.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:be224a65493ec5b74a158ff22a5522ce4a5ca1e543c647a3a4730d4a09e5f959", size = 4862596, upload-time = "2026-08-25T19:44:24.472Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/22/c3654cccc856e9d682817b04ac3ee79731cb09ca6f95996a95c904de2883/cryptography-50.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9ebcdd5519be9b652a46f507817a74591774fc3d6923ac364e4dfa64e36b291b", size = 5014082, upload-time = "2026-08-25T19:44:26.709Z" },
+ { url = "https://files.pythonhosted.org/packages/42/8b/cb12b1b60c91b074ca6bf0fdd59aa8f10d8bc5f73af8faece86ef0421b37/cryptography-50.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:aed8db4f6d71c51efb89530e12d9464e7bf2923d46c3205dc794a2a93f8c0648", size = 3842826, upload-time = "2026-08-25T19:44:28.784Z" },
+ { url = "https://files.pythonhosted.org/packages/84/a9/ee16a903f13755e914d1eecc482fe64d1f10761c3960e5d8fa6837377aff/cryptography-50.0.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ca83d00d9e69cd5eb63f2e69c3a5a59e0cecae5ae14c6ae0b35830fe3b37bad0", size = 4035307, upload-time = "2026-08-25T19:44:58.305Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/a5/9ec7e81e8526c0d7a387d73386b2daed3f39e10d81a85930bd1b6bfba65c/cryptography-50.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:05ba322c4da95b262a212c345af888ef2c37c88c0509756ea00a0e6d68850f23", size = 4751900, upload-time = "2026-08-25T19:45:00.401Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/3c/0e77bd5ffcf078e9dd27d3074aad6c030d9b10d0bf69329d573c927a188c/cryptography-50.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e22dfed744bd4002e909464cb23d2f0b05c6f3113a79ef2e9864a53db737c733", size = 4738357, upload-time = "2026-08-25T19:45:02.786Z" },
+ { url = "https://files.pythonhosted.org/packages/27/3a/3c5f80daa4dcd47323c7af8a2fcb90de27a33564d4fcac69846c0972691a/cryptography-50.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4c4188f7c0cf655be5c06342b817ed0f9595b69ffa2b12026e5353eed29dea88", size = 4758474, upload-time = "2026-08-25T19:45:04.889Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/2b/214cf0cf93db9628c3c20c896b229f327f6fb1b20e4b3743d8ad3f00af8b/cryptography-50.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2ebbfb0f1fed745e91796e3e1080a1440423fdae8ece1b995a1d80883a409054", size = 5375862, upload-time = "2026-08-25T19:45:07.163Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/51/3f9701867a46b6c1740c9b52fc4d3bed6cbdcfedcc9b6e64305c07f39cff/cryptography-50.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:407fe2b6db00939c05c0e945e9914238f2f0a430974839429dafc82b1ee6bee5", size = 4772942, upload-time = "2026-08-25T19:45:09.396Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/5c/13ea642e08e2544d0f5396122055f4820cfacb3203562197b5967125ea97/cryptography-50.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:2b34d76a652ea2b6faf777c35df230c5637842cd904e04f16230c3f9f03e4361", size = 4383347, upload-time = "2026-08-25T19:45:11.659Z" },
+ { url = "https://files.pythonhosted.org/packages/84/d5/7d1fe1cb93f91c428093ff234e128c89ba8ea61a6f26aab406081f9b996e/cryptography-50.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:01f41478cf33fc605a6a089cd56d28b45c6c0b45a1928b61797f2621a04bac71", size = 4758050, upload-time = "2026-08-25T19:45:13.745Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/04/557fc5ead96a829e0bc812a3b9dc4a52a2f27e4f7f5950da7ff27653a805/cryptography-50.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:fc3ed7ebd2a8c96f5b166de0ab9b624996bef3b07bbeb19364dfb78222c22c80", size = 5332955, upload-time = "2026-08-25T19:45:16.193Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/eb/5d7124083e8d8cda8f5b348f544b71ad6f707ad63193758ef4d8e569da02/cryptography-50.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dde0a357190eb3b1da1bb9ab750e9c85cba82ca5977aa0836cbb94e92611239", size = 4772694, upload-time = "2026-08-25T19:45:18.315Z" },
+ { url = "https://files.pythonhosted.org/packages/63/8e/f1f955e0921dd2b6d22eae7e8d24a4c4b638d10735ffbf6a71f99eb0fcb8/cryptography-50.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd3718b960d0b5dd213cdf03f3bcb7000e69dda0de8b956061947ff6bcff5558", size = 4888413, upload-time = "2026-08-25T19:45:20.4Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/ab/89e2b798d2c3925f82e2bb72d5979f3d2f6da2dd22ef4a8cd8b70d920039/cryptography-50.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2a93d05e34d5f67fba6f891fe85d929999baa7195e853923ea6d7576c9e68c5e", size = 5044355, upload-time = "2026-08-25T19:45:22.353Z" },
+ { url = "https://files.pythonhosted.org/packages/99/89/87ef49ffe383ef4e147d27b7bf2088fb0b54ea409dd87b5a89442e5828a5/cryptography-50.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:55d16b1ef3ee0958d893a977b19777887e546c9954ea81b200c3301a864013f2", size = 3875429, upload-time = "2026-08-25T19:45:24.418Z" },
+ { url = "https://files.pythonhosted.org/packages/c7/27/8d207af749c453ee17ea087340b3f2b4adef75aadd1d277b1b129bdda84e/cryptography-50.0.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9cb3cb952cf5a8abd50c782a98a89d71699715e802fe349704b47f2425b42a94", size = 3974350, upload-time = "2026-08-25T19:45:26.551Z" },
+ { url = "https://files.pythonhosted.org/packages/14/9a/6d3a4d7852e22d657438b7bf51f66102c7d71c0e1fafeec652281d0403e5/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5fe939deeb161024a6be98229c953b6591fef1f41214497a78fe793a244c017f", size = 4698675, upload-time = "2026-08-25T19:45:28.658Z" },
+ { url = "https://files.pythonhosted.org/packages/73/35/5c3717edf9e68a0550ce04e28eab493fe545eccd81742af03f6a75fe260b/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:fb4b9672d389c738b175c4166e78310f8a70358886aacd9173ee03a85ffdc671", size = 4707410, upload-time = "2026-08-25T19:45:30.816Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/e0/e786934472e3ac4ecdecc7b129a0ca1a2a40dffdafcf2c3ea9d4397f8def/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d63ae8f6481fec907ac0f588eee8a90aefde112c633131fe540e5711ddbb5a4e", size = 4698378, upload-time = "2026-08-25T19:45:33.043Z" },
+ { url = "https://files.pythonhosted.org/packages/51/cf/5b3f53a0b74d122f023476ede40ba5d3e70d5cf475f73b899740d26a4fb2/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:804728ce710890870f3aaa344b2e161172d258d768ac139d02cfd9092d0d94e6", size = 4706889, upload-time = "2026-08-25T19:45:35.086Z" },
+ { url = "https://files.pythonhosted.org/packages/71/44/711e61f7d014be825ef79b285b047292d1bf893732ac1bc030a351fb517f/cryptography-50.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:693c99b49bd37d0d096e4334c10232c77248c415b98d35236094cdf96d57258b", size = 3824006, upload-time = "2026-08-25T19:45:37.281Z" },
+]
+
+[[package]]
+name = "cua-s1"
+version = "0.0.0"
+source = { editable = "." }
+dependencies = [
+ { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+ { name = "numpy", version = "2.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+ { name = "safetensors" },
+ { name = "torch" },
+]
+
+[package.optional-dependencies]
+all = [
+ { name = "mcp" },
+ { name = "pdfplumber" },
+]
+mcp = [
+ { name = "mcp" },
+]
+pdf = [
+ { name = "pdfplumber" },
+]
+
+[package.dev-dependencies]
+test = [
+ { name = "pytest" },
+ { name = "pytest-asyncio" },
+ { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+ { name = "mcp", marker = "extra == 'all'", specifier = ">=1,<2" },
+ { name = "mcp", marker = "extra == 'mcp'", specifier = ">=1,<2" },
+ { name = "numpy", specifier = ">=1.26" },
+ { name = "pdfplumber", marker = "extra == 'all'", specifier = ">=0.11,<1" },
+ { name = "pdfplumber", marker = "extra == 'pdf'", specifier = ">=0.11,<1" },
+ { name = "safetensors", specifier = ">=0.4,<1" },
+ { name = "torch", specifier = ">=2.2,<3" },
+]
+provides-extras = ["pdf", "mcp", "all"]
+
+[package.metadata.requires-dev]
+test = [
+ { name = "pytest", specifier = ">=8,<10" },
+ { name = "pytest-asyncio", specifier = ">=0.24,<2" },
+ { name = "ruff", specifier = ">=0.12,<1" },
+]
+
+[[package]]
+name = "cuda-bindings"
+version = "13.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cuda-pathfinder" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/19/6f/e00ffcebcad6405a2326a52612eff98240a67c637dfed516e61b881e2db3/cuda_bindings-13.4.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc0a18f65b26459cd3c49c0250a44b419cdf790cffcb096ff4d46a1973f6f4b7", size = 6484069, upload-time = "2026-09-17T22:05:52.594Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/4c/743b8d6dc28f8db80811b04b2c2dde877cd13a93a227e6f3c925a5cd3a00/cuda_bindings-13.4.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c0415cf8fb98fbae3eb65079f151e10b9764ac2d5970027a49dc5a627c2af9d", size = 7159298, upload-time = "2026-09-17T22:05:54.664Z" },
+ { url = "https://files.pythonhosted.org/packages/27/df/281aa982f033426d59c6276b6643637746b6bf0a883186443daa89717291/cuda_bindings-13.4.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bb2e91717c83ea550ef1b19ebafd25c9fe805478f479d04b3fc798cc6d29d453", size = 6479822, upload-time = "2026-09-17T22:06:01.3Z" },
+ { url = "https://files.pythonhosted.org/packages/83/d6/10b7031f23052e95a60d4d5e4bffdd0bbdd2ae9fa5b1c6fcb7099325fbb4/cuda_bindings-13.4.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:40c811caf26976eb319462db614422112438f1d02b4f3df3a4a96f9bbcc77b6d", size = 7170860, upload-time = "2026-09-17T22:06:03.841Z" },
+ { url = "https://files.pythonhosted.org/packages/99/33/8c4b5274ecca4adfbe51d01694c5fca3e962e80fc5ba85ba6f441c6d2019/cuda_bindings-13.4.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:251057d5cee0e015c6586332684f66c4f6e1af5cac91b99520fca44250d877a8", size = 6313558, upload-time = "2026-09-17T22:06:10.828Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/cb/1f2719be03546aa9940bfab7ad6941335ec3326b48fe4e256d07d6d6bbc5/cuda_bindings-13.4.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50e68c36222a58d271fbd2e23149497d35450a911d792d49a029e58519abb7e5", size = 6924257, upload-time = "2026-09-17T22:06:13.065Z" },
+]
+
+[[package]]
+name = "cuda-pathfinder"
+version = "1.8.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/98/59/239c7259e669c46ddbcac0aa60e3a0ef00bfeaaa687f905b24dd6a7a10fe/cuda_pathfinder-1.8.2-py3-none-any.whl", hash = "sha256:4e65059febdb4d19d5cbc4798677e19db2b582f2f702f457b609e571690d357e", size = 62551, upload-time = "2026-09-17T22:19:09.396Z" },
+]
+
+[[package]]
+name = "cuda-toolkit"
+version = "13.0.3.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/c7/a79086a62c98befcdb8349656c6f114e2db3b8b2422f6e25c97a7f2a9a3c/cuda_toolkit-13.0.3.0-py2.py3-none-any.whl", hash = "sha256:d693caaa261214ddd7dbb60d68e71cbed884e68c2be7509778f3051da0b91c3f", size = 2512, upload-time = "2026-04-14T00:50:08.173Z" },
+]
+
+[package.optional-dependencies]
+cublas = [
+ { 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 = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
+]
+cufft = [
+ { 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' or platform_machine == 'x86_64'" },
+]
+cupti = [
+ { name = "nvidia-cuda-cupti", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
+]
+curand = [
+ { name = "nvidia-curand", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
+]
+cusolver = [
+ { 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 = "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 = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
+]
+nvrtc = [
+ { name = "nvidia-cuda-nvrtc", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
+]
+nvtx = [
+ { name = "nvidia-nvtx", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" },
+]
+
+[[package]]
+name = "filelock"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/ac/8c98b17ee3900147b38ef7884a1e590b070b63f0d59fd8b46ef0205f4576/filelock-4.0.0.tar.gz", hash = "sha256:3611eca5d818ca9b00ec3cc7db1dcfe1e2aafc8d44fb4920d8cf60ad1f6bfda6", size = 237935, upload-time = "2026-09-17T03:59:02.967Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/01/fb/0e4489505dac46a0487ba925ea4b046612f1a40f432d63a000421de78549/filelock-4.0.0-py3-none-any.whl", hash = "sha256:a850aa9ec2acba8db9ca2e9fcf8a327fbc2f85e432725715b37bd76b7dd1f798", size = 106036, upload-time = "2026-09-17T03:59:01.336Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/00/78/f34251dadb8f3921264a1d9b8946f5e542014ee2614b285261b4e40e6775/fsspec-2026.7.0.tar.gz", hash = "sha256:c803c40f4cf860b49dea58ee3e1c33cb9c790520e233537e1340049f89b82a88", size = 317040, upload-time = "2026-07-28T16:34:51.052Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl", hash = "sha256:b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279", size = 206583, upload-time = "2026-07-28T16:34:49.538Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "certifi" },
+ { name = "httpcore" },
+ { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "attrs" },
+ { name = "jsonschema-specifications" },
+ { name = "referencing" },
+ { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+ { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+ { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+ { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+ { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+ { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+ { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+ { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+ { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+ { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+ { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+ { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+ { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+ { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+ { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+ { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+ { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.30.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "httpx" },
+ { name = "httpx-sse" },
+ { name = "jsonschema" },
+ { name = "pydantic" },
+ { name = "pydantic-settings" },
+ { name = "pyjwt", extra = ["crypto"] },
+ { name = "python-multipart" },
+ { name = "pywin32", marker = "sys_platform == 'win32'" },
+ { name = "sse-starlette" },
+ { name = "starlette" },
+ { name = "typing-extensions" },
+ { name = "typing-inspection" },
+ { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/93/0142dc84a666daf8ad51a34268f34c12fd6fda4f3810c4be2504eecc8212/mcp-1.30.0.tar.gz", hash = "sha256:445414625fce5c295faa505bb11bacece661ab6f4028d57c935db57820b7a3e4", size = 680511, upload-time = "2026-09-07T14:34:15.845Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f5/f4/e58bc33317c92a0203664daaf00bf6f41166cc0149e5d6870a03f7cd004a/mcp-1.30.0-py3-none-any.whl", hash = "sha256:666edb5009503e1047c9d60346a756f94b261f05cc2625f23d41c728ffc484d0", size = 234581, upload-time = "2026-09-07T14:34:14.266Z" },
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.12'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" },
+ { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" },
+ { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" },
+ { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" },
+ { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" },
+ { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" },
+ { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+ { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+ { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
+ { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
+ { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
+ { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
+ { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
+ { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
+ { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
+ { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
+ { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
+ { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
+ { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" },
+ { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" },
+ { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.5.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.12'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d6/50/8fdbb16af64895706a45f06a4068e29db732ec180f3c1375f14123359138/numpy-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9", size = 16994982, upload-time = "2026-09-06T16:24:29.244Z" },
+ { url = "https://files.pythonhosted.org/packages/60/39/789131c1188c078dcb3a1692e72e1e050c68b88ffe72c9ccaac9bcd7a9cd/numpy-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c", size = 12009327, upload-time = "2026-09-06T16:24:32.491Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/59/a312e95696e5f601914dd8b6dd844692ba61670807417e24b68e337b5c70/numpy-2.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0", size = 5445405, upload-time = "2026-09-06T16:24:35.071Z" },
+ { url = "https://files.pythonhosted.org/packages/30/d0/5623a1707ed4fe16e3909fe3cf5ee3da004ae677ad23d83bbf3adf1a6faf/numpy-2.5.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e", size = 6783213, upload-time = "2026-09-06T16:24:37.253Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/32/84146fc020ad3c25f805f70ab60da46fe3c540a21369754a7e4369754b6f/numpy-2.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58", size = 15687872, upload-time = "2026-09-06T16:24:39.751Z" },
+ { url = "https://files.pythonhosted.org/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/24/faa79d865e69a97ba17473b23a1b74094b2259c03e820c70297293b9ea49/numpy-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff", size = 17040975, upload-time = "2026-09-06T16:24:45.961Z" },
+ { url = "https://files.pythonhosted.org/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/db/35e1c2d38b04cbd5b731f9d71495e055e813197669d22b612f11748d2ff9/numpy-2.5.3-cp312-cp312-win32.whl", hash = "sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4", size = 6133378, upload-time = "2026-09-06T16:24:51.915Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/a1/accf6d4f0c80c5d9ba9735d6b1550e444180599f34dec69ca01360f717ad/numpy-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def", size = 12567828, upload-time = "2026-09-06T16:24:54.255Z" },
+ { url = "https://files.pythonhosted.org/packages/22/43/1764aff32e4652526ae2f71fa8b3efd8d25c8a3d6926914454e47138ed1e/numpy-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034", size = 10485432, upload-time = "2026-09-06T16:24:57.278Z" },
+ { url = "https://files.pythonhosted.org/packages/79/e5/8fb89cd46d14e35699d13bf943a5f5f441ecee8667120a1f6105ab89e349/numpy-2.5.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034", size = 16991061, upload-time = "2026-09-06T16:25:00.411Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/06/9dc9e48b5e5e941c8b10350c5ff2d721da42a20517d911d15544246775ff/numpy-2.5.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e", size = 12003676, upload-time = "2026-09-06T16:25:03.475Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/2a/98282aa5b8f58b1157d440bb6282eed47e3632a5de53a714fbab17e659fe/numpy-2.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09", size = 5439695, upload-time = "2026-09-06T16:25:05.978Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/f9/b6533d777be9d6ffd29dc1be0867e563e6e8cc9a220ff1b716adc317f060/numpy-2.5.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958", size = 6779395, upload-time = "2026-09-06T16:25:08.599Z" },
+ { url = "https://files.pythonhosted.org/packages/73/85/735720d04ec197c5dcfacdfc9922667c7f1f5f496a279b7ba4d7c74c4cc7/numpy-2.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b", size = 15681750, upload-time = "2026-09-06T16:25:11.173Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/1b/3b16a9bc514a440a7a0883684111dcb1ef1aee960af2ca95da8fc775f124/numpy-2.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321", size = 16708577, upload-time = "2026-09-06T16:25:14.171Z" },
+ { url = "https://files.pythonhosted.org/packages/69/c4/386f397831b07328b639c96c5b62719346cf4baf07c68d927239752b1534/numpy-2.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231", size = 17042047, upload-time = "2026-09-06T16:25:17.582Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/3e/a700ecbf36e85ae8328fd3b0e12eeddc22ed6358a64cb2bd913e0d195d65/numpy-2.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0", size = 18465724, upload-time = "2026-09-06T16:25:20.949Z" },
+ { url = "https://files.pythonhosted.org/packages/41/ee/38e785e88a4045f6ad1d1f2808dcdfafdca48c760260c0587bf171e29fc9/numpy-2.5.3-cp313-cp313-win32.whl", hash = "sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f", size = 6129003, upload-time = "2026-09-06T16:25:23.664Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/ec/100f2b1794ede74a9b3d7ec6b9736927f56713414c1dfe19ab6c383494bf/numpy-2.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec", size = 12560965, upload-time = "2026-09-06T16:25:26.602Z" },
+ { url = "https://files.pythonhosted.org/packages/80/b1/7dc825ca94c12acebbce4c37caa5e198695eb31424bc579679f32b1bb49d/numpy-2.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204", size = 10482343, upload-time = "2026-09-06T16:25:29.772Z" },
+]
+
+[[package]]
+name = "nvidia-cublas"
+version = "13.1.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { 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" },
+ { url = "https://files.pythonhosted.org/packages/3b/cd/154ca20c38269e05eff77c1464e6c1da89f50a6390b565e9d82e06bc11e1/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:37936a16db8fe4ac1f065c2139360608a543a09275cb1a1af612e08cfa065436", size = 423138758, upload-time = "2026-04-08T18:46:58.655Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti"
+version = "13.0.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" },
+ { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc"
+version = "13.0.88"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime"
+version = "13.0.96"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu13"
+version = "9.24.0.43"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "nvidia-cublas" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ca/30/7c257e3d5cb4fecb147b93895c66e29c93f8e76d74b45bb418ff0587c4ec/nvidia_cudnn_cu13-9.24.0.43-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:a6812a554a1ff0413e9c52b84c26c050380649ab9615f9c16bded368ce9f421f", size = 650976863, upload-time = "2026-07-02T16:23:39.248Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/ba/791cffd048fe5b044e620df55267e3e95c0e6e07d50b41e377c03dfc910f/nvidia_cudnn_cu13-9.24.0.43-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:71f181cd810e90f9b6023b01186fe82d13d65f0ec098581ee201d39fad769e4b", size = 553099438, upload-time = "2026-07-02T16:27:42.58Z" },
+]
+
+[[package]]
+name = "nvidia-cufft"
+version = "12.0.0.61"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { 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" },
+ { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" },
+]
+
+[[package]]
+name = "nvidia-cufile"
+version = "1.15.1.6"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" },
+]
+
+[[package]]
+name = "nvidia-curand"
+version = "10.4.0.35"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver"
+version = "12.0.4.66"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { 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" },
+ { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse"
+version = "12.6.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { 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" },
+ { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu13"
+version = "0.8.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/46/e1/cdc1797eadf82d3a9a575a19b33fdc871a97edbec42c00b5b5e914f4aff4/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4dca476c50bf4780d46cd0bfbd82e2bc10a08e4fef7950917ce8d7578d22a23f", size = 221051344, upload-time = "2025-09-05T18:49:51.289Z" },
+ { url = "https://files.pythonhosted.org/packages/34/7d/2661f2fb3ac4302f3a246f5fc030213ac60c1fe0bce84f9783dbd831dbb7/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:786ce87568c303fadb5afcc7102d454cd3040d75f6f8626f5db460d1871f4dd0", size = 170148586, upload-time = "2025-09-05T18:50:50.248Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu13"
+version = "2.30.7"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/21/a73174c6157101bdf1ffc22b517f76ff0082613989dd9bc8f43e8034caac/nvidia_nccl_cu13-2.30.7-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:ca786ffa5a647c75d4d1f5cc72a6c4f537947e2ba8823d7c8aaf768e7a7b9f77", size = 215983881, upload-time = "2026-06-09T03:23:15.633Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/34/c500f90c7ae641b8e0f98965b36b8a7ac79cc8b296e8d251fe3eb592ee54/nvidia_nccl_cu13-2.30.7-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:cefa7fdb9710efd0f39c5f1be1d61ff6fc9a996c451265bd7fbdcf9455ed4b50", size = 215965170, upload-time = "2026-06-09T03:23:39.73Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink"
+version = "13.4.92"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1d/6b/eef7a9e32872b8f41e145bf10cddc9af26e153c338852811fe9a9baddf9e/nvidia_nvjitlink-13.4.92-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:e0391f24ed94ec879b84e3da4d4ec320c879aff681f2c7a638462f7199284323", size = 42452378, upload-time = "2026-09-16T20:45:29.042Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/a8/1cbd4014898af8b419e69b0d7dbc63da2121ee92d92b47d59f4fe9075349/nvidia_nvjitlink-13.4.92-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:25f74fad0d654271c921ac4dca614bd6258bc21791242fc7b2289dad7ae9c099", size = 40420120, upload-time = "2026-09-16T20:45:19.163Z" },
+]
+
+[[package]]
+name = "nvidia-nvshmem-cu13"
+version = "3.4.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" },
+]
+
+[[package]]
+name = "nvidia-nvtx"
+version = "13.0.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pdfminer-six"
+version = "20260107"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "charset-normalizer" },
+ { name = "cryptography" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/a4/5cec1112009f0439a5ca6afa8ace321f0ab2f48da3255b7a1c8953014670/pdfminer_six-20260107.tar.gz", hash = "sha256:96bfd431e3577a55a0efd25676968ca4ce8fd5b53f14565f85716ff363889602", size = 8512094, upload-time = "2026-01-07T13:29:12.937Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/20/8b/28c4eaec9d6b036a52cb44720408f26b1a143ca9bce76cc19e8f5de00ab4/pdfminer_six-20260107-py3-none-any.whl", hash = "sha256:366585ba97e80dffa8f00cebe303d2f381884d8637af4ce422f1df3ef38111a9", size = 6592252, upload-time = "2026-01-07T13:29:10.742Z" },
+]
+
+[[package]]
+name = "pdfplumber"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pdfminer-six" },
+ { name = "pillow" },
+ { name = "pypdfium2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/56/6f450312ba05a27d7713b73857c1a25100dbda04fbc1331b13fb227a607d/pdfplumber-0.11.10.tar.gz", hash = "sha256:b95b2d28c66efb0a794a83b88c6c6aea5987532a445d20a1cbcfa657022e6e57", size = 102892, upload-time = "2026-06-15T03:31:31.035Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a2/9a/07d658e1e7fad860f1c541ab941348125dbdab773be3a0afaf32361866c7/pdfplumber-0.11.10-py3-none-any.whl", hash = "sha256:7741ea81bf165b474b153e6789d10d18e06b6ddcf3ec84289c3ef2fed6802580", size = 60047, upload-time = "2026-06-15T03:31:29.702Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" },
+ { url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" },
+ { url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" },
+ { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" },
+ { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" },
+ { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" },
+ { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" },
+ { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" },
+ { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" },
+ { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" },
+ { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" },
+ { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" },
+ { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" },
+ { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" },
+ { url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" },
+ { url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" },
+ { url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" },
+ { url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.13.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "annotated-types" },
+ { name = "pydantic-core" },
+ { name = "typing-extensions" },
+ { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a2/b6/81d2d19ea0be2c03664381b59f65fa72fc7969decedae00bc2c4ad835708/pydantic_core-2.46.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a1dee1b804ff4d11c663636cf15d2ea47e9f79cd56c033fb1cbf08924842a48f", size = 2074737, upload-time = "2026-08-28T09:57:57.711Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/18/b70da8300e292df4099684ea11b1958043580d2f50d2dc8bf7e542bdd84a/pydantic_core-2.46.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d625a186a65201c23a9e3b8ed9c47e90a026e03256608cc91851c6709096844f", size = 1921751, upload-time = "2026-08-28T09:57:59.265Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/1a/0d590341b6ffa4b4aca83508e6b8db4761aaeacfc15a25ca3815876d4797/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f8507560a9284e1370bb048ed4282012fbef4e8d109875b95e884d228552061", size = 1948231, upload-time = "2026-08-28T09:58:00.678Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/1d/02eb35761c51f2f7b1b042d6ab4cda6600f0c8c88a2243b3f734376201e5/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f93c5fe914d75fbec9a49209b00da5f08e9e467d69da2b1510c81940cfd10be", size = 2020708, upload-time = "2026-08-28T09:58:02.267Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/ea/f86073830e35d508cc8ddf9c3d9e6e6840fcb88d34bf726b0b4710186f27/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c767f552b21b10f774aeac128e828eafb796adfa1b666a18bf6321453c3a", size = 2194914, upload-time = "2026-08-28T09:58:03.934Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/d7/fc36240d7791ce90939e51608568c33bfdae26202016f9770c229a487d86/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:701b2e04b560eeb4bddf7a25ab8ca476176e34fdbd9a0e18196f0d12d4685f0b", size = 2235622, upload-time = "2026-08-28T09:58:05.516Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/bc/3fa2d76b83162820a17da7f645b28d1cba99fc8e1e5fc6517067ec450fa1/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49776eab08766a08dfff7012f8b422dcd7e25e43b316eedf0477c24fcfa84b7c", size = 2062091, upload-time = "2026-08-28T09:58:07.135Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/9a/095d557bb492c90cd8a70a6dd048bf793d433d03d86c81c11e912e4cd049/pydantic_core-2.46.5-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:a2468d93d181667a7abd66e1b64bb9f76f361b0fef8faddf687456453576f5ee", size = 2089904, upload-time = "2026-08-28T09:58:08.814Z" },
+ { url = "https://files.pythonhosted.org/packages/24/98/7b76b1ad10a19a617a52aaa1d80e159115af939b095e86f8e756fd52e0df/pydantic_core-2.46.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:53feb344243bb9510a9dec7bf3cf1b64d88a98af5dc7872a5160465f8b198c8e", size = 2132244, upload-time = "2026-08-28T09:58:10.435Z" },
+ { url = "https://files.pythonhosted.org/packages/20/32/7d6ca365fadba186a0c8f85de1a701663bce81efd309d9479be58687622f/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:cd5214352ae68f3b5e9af7768bdc5253695ee069675db3480518420b3be881f2", size = 2143901, upload-time = "2026-08-28T09:58:12.033Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/09/eb9a6aa57f22fd1541a9c0aa2a1f3aeef3ec65347d33e10a6da2f43e0ee9/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:9432f3598db432cb51c5b37fdbf29a60fcccc79e30d37a05022776a6bc4ab689", size = 2299425, upload-time = "2026-08-28T09:58:13.614Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/f9/548a5bb9d4ba8cd26e26daf48052236f6b38bb61e7b7241fbc3c995719eb/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8feeac04b5794e513e710af2f9c87d49f31a6dc47967bb264a1fed61a8989bec", size = 2318566, upload-time = "2026-08-28T09:58:15.199Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/20/06454d18834c02c406c9133f1a3b485305fd9ee984f9636c2f730bef6a9d/pydantic_core-2.46.5-cp311-cp311-win32.whl", hash = "sha256:892a881d5f68c2b9ea304b7a6c2c60d9343df578a311b0f86b94bc8f1ffe8129", size = 1954258, upload-time = "2026-08-28T09:58:16.813Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/c2/718b9deb4b72453b5d8c7447a3b14cb77bef36917ef5f514e0948a4096a0/pydantic_core-2.46.5-cp311-cp311-win_amd64.whl", hash = "sha256:40375c2d05acec10323e45dfe2077ac44bc74659008614af5069034e2cfc781c", size = 2041030, upload-time = "2026-08-28T09:58:18.288Z" },
+ { url = "https://files.pythonhosted.org/packages/67/ea/c1d1a5b72d6e1ff7f377a4d9199f6591f095beb5b409a8a5d89f7238d939/pydantic_core-2.46.5-cp311-cp311-win_arm64.whl", hash = "sha256:28a6a556cd3b6066bea827857f9d9cce027c96f776e512f544a581f9e42161f8", size = 2009234, upload-time = "2026-08-28T09:58:19.929Z" },
+ { url = "https://files.pythonhosted.org/packages/82/3f/76358795aa7a8c6d4f36e2cb828ad1c90ee118e1393a9281664f5aade9d4/pydantic_core-2.46.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d", size = 2076516, upload-time = "2026-08-28T09:58:21.576Z" },
+ { url = "https://files.pythonhosted.org/packages/db/50/26b091836076ce4cb2fac264186936acc069e0595772cfd02a563bc4761a/pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e", size = 1922874, upload-time = "2026-08-28T09:58:23.766Z" },
+ { url = "https://files.pythonhosted.org/packages/09/f0/2a8ce3849e299d44e2d2c196b6082643a3235565a735cb51db7a6261f614/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29", size = 1951772, upload-time = "2026-08-28T09:58:25.435Z" },
+ { url = "https://files.pythonhosted.org/packages/87/46/ac0dc8bdd9e6048183a14eb127764e7ad9240021c17513074a4711b0e31e/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4", size = 2031832, upload-time = "2026-08-28T09:58:27.102Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/c2/339de5bef7be36301a2231eaa52e62163742c2281f11b5f4892bc79785cd/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a", size = 2208645, upload-time = "2026-08-28T09:58:28.948Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/a0/9ff22b797724262da14427abaed4dd1d864a139693fc5e7809114376a716/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62", size = 2265935, upload-time = "2026-08-28T09:58:30.625Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/a4/eb9409ec0736e50aa70a412f16c204ed149516846912f7e6724d4c73ee53/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2", size = 2066284, upload-time = "2026-08-28T09:58:32.289Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/02/7f6156ffc926857f1c37c07d9a388682865a81830ab6a1b637082c25e399/pydantic_core-2.46.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869", size = 2105889, upload-time = "2026-08-28T09:58:33.986Z" },
+ { url = "https://files.pythonhosted.org/packages/92/b1/e781d357ebe09fc929f995700f1b3503e8897f1cece183ecb1300d4d67e9/pydantic_core-2.46.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5", size = 2158006, upload-time = "2026-08-28T09:58:35.647Z" },
+ { url = "https://files.pythonhosted.org/packages/70/0a/644597d84ab400e50609c192120b85c9681c22d3a20461b9060a79be0a7a/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3", size = 2158408, upload-time = "2026-08-28T09:58:37.38Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/ee/ca3b7b3a4b3769ffe9ce9432a7c9be755de9593a46d3b0d54d0409323e44/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b", size = 2309609, upload-time = "2026-08-28T09:58:39.22Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/52/39fa1f451486019524ca685020390e7ca351832fd874530ba30c8628e6dc/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0", size = 2342618, upload-time = "2026-08-28T09:58:40.89Z" },
+ { url = "https://files.pythonhosted.org/packages/81/5e/468fc630568c61dcef3cd47ad32ffbeed9af643f49208d1ea86ab4f890c4/pydantic_core-2.46.5-cp312-cp312-win32.whl", hash = "sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b", size = 1939475, upload-time = "2026-08-28T09:58:42.591Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/c9/4c19f41b84cf6b622a72fbeed7665b25d47a187d68d47d0d430c07f23268/pydantic_core-2.46.5-cp312-cp312-win_amd64.whl", hash = "sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8", size = 2043140, upload-time = "2026-08-28T09:58:44.272Z" },
+ { url = "https://files.pythonhosted.org/packages/af/dd/0c1a050299147c746e5256db16d645ab5efd4f78c59937d581a0524e74a2/pydantic_core-2.46.5-cp312-cp312-win_arm64.whl", hash = "sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084", size = 1997729, upload-time = "2026-08-28T09:58:46.13Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/37/5abe39a8372a61d3dc3c1338fc504281c01b32fdb3169cd7187153b56d3e/pydantic_core-2.46.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0", size = 2075885, upload-time = "2026-08-28T09:58:47.856Z" },
+ { url = "https://files.pythonhosted.org/packages/21/43/6323b1f8b217780454c61304bcd2b38ae4762f50754414124603ccc90bb2/pydantic_core-2.46.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff", size = 1922768, upload-time = "2026-08-28T09:58:49.58Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/a3/c05ca796e1197618a774b01e596aeedfefc2f7d8c01ae3054e910b120e8a/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931", size = 1951241, upload-time = "2026-08-28T09:58:51.511Z" },
+ { url = "https://files.pythonhosted.org/packages/68/32/33bc39ac705c52cffc908e8389f9754fdb208aea5c69cceddf4eb3ce99af/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f", size = 2031975, upload-time = "2026-08-28T09:58:53.166Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/70/2333e885c0f6a67bc105c5916965dac9b57f2718ee20d81d1a06a4ebdc13/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038", size = 2208542, upload-time = "2026-08-28T09:58:55.017Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/ea/296debfb4264207bbda5936133892e027c0a58875ad53ebd512fba8ec3a2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f", size = 2264692, upload-time = "2026-08-28T09:58:56.767Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/f2/9e4de77a6271e07a76d2d58b11c091a979c191ed2939bf80067568b369d2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1", size = 2066633, upload-time = "2026-08-28T09:58:58.531Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/db/f9e9d0c97445987b2084823d5c240de88087338f04fc2cfaa2df186b8049/pydantic_core-2.46.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761", size = 2105235, upload-time = "2026-08-28T09:59:00.421Z" },
+ { url = "https://files.pythonhosted.org/packages/07/c5/79169b047b3b2c3e99e04bc76372af9637e0bf6db638274fa927df96369e/pydantic_core-2.46.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5", size = 2157367, upload-time = "2026-08-28T09:59:02.442Z" },
+ { url = "https://files.pythonhosted.org/packages/26/b5/ba6057afb7c291bd449f51b867f95aef2072941c4ce4e5c31d6ffd132d3b/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e", size = 2158420, upload-time = "2026-08-28T09:59:04.2Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/28/2057abecaafdc22912afa819603a51f0a62d40643b7c4871c51721fea9be/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed", size = 2309588, upload-time = "2026-08-28T09:59:06.048Z" },
+ { url = "https://files.pythonhosted.org/packages/71/9d/881156dc404e27479c4246128d73538464cab4a239bec61995e227644c30/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519", size = 2341866, upload-time = "2026-08-28T09:59:08.539Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/38/d66f443a259f84d13babdceae568e572b0ed26da17ca5d0a649ebb110a67/pydantic_core-2.46.5-cp313-cp313-win32.whl", hash = "sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea", size = 1938580, upload-time = "2026-08-28T09:59:10.402Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/1e/1d5371213f4cc9a7ed70c0bfcc7911de22311ee99a662a56077d7292d2ac/pydantic_core-2.46.5-cp313-cp313-win_amd64.whl", hash = "sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5", size = 2041980, upload-time = "2026-08-28T09:59:12.396Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/48/4222d90b1c67568bace4dec6dca6271449c66de3595d72b6d098f5fde597/pydantic_core-2.46.5-cp313-cp313-win_arm64.whl", hash = "sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575", size = 1997213, upload-time = "2026-08-28T09:59:14.245Z" },
+ { url = "https://files.pythonhosted.org/packages/af/1e/ecca01fce348f7e8afa9572441ff6f7d1cc70d21e4859f33944d10877e1e/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:c14ad3bdc85ee7f318742c457ca3968a92126d144b15721c759033bfb06296c2", size = 2075342, upload-time = "2026-08-28T10:00:51.353Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/4c/af80c7a8032dfc897040ad5cb772bebde529a381186499e6e29987f23f8c/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0bddb4020d8f04175865ccd17eff3040874fc11fb593f424edb452653b4b947c", size = 1907219, upload-time = "2026-08-28T10:00:53.438Z" },
+ { url = "https://files.pythonhosted.org/packages/be/3e/54d89e2b092e778716bf6153634ef479e955f48c261090be23aa1e0fb0b5/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2471fd51c61c610e1dcf7de44d7299283661654d11264ab4802b303368d69c47", size = 1953393, upload-time = "2026-08-28T10:00:55.58Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/89/828ee90cda28ce17bdefaa3a6eaf74fe430e113295a10e6126beca559d6c/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10ec717381bdbfafef34607824db4c91de69ff085e4fca3b2af91b4fa17e68a", size = 2099024, upload-time = "2026-08-28T10:00:57.794Z" },
+ { url = "https://files.pythonhosted.org/packages/df/dd/053c2e4303f791f3b8f8a14ab0b22008e8eb21d868c0c90b4f9be705b76a/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942", size = 2062540, upload-time = "2026-08-28T10:01:00.318Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/dd/a18df751a5e37dd51bfad7f68e766999125bebe68c9e1d10a493ad01bd63/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f", size = 1902040, upload-time = "2026-08-28T10:01:02.529Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/13/01d40f9d07ce8a779fd6e0bd8ad4fba91309500dd67b869e2e219d261a6d/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433", size = 1967479, upload-time = "2026-08-28T10:01:05.004Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" },
+ { url = "https://files.pythonhosted.org/packages/20/21/22102e9950b3049526d20e811b95396508377d87651edd2b80d2b3d28659/pydantic_core-2.46.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ab4b66edffb32d9e951efb3814bd104b8367a7501b81b955cacb5726d897389f", size = 2071333, upload-time = "2026-08-28T10:01:09.636Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/18/87aefa427d191e6d3ab1447f1efc1cdcac86af1069239b133e8a0fd7f7c9/pydantic_core-2.46.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:337639ba62a11acde6ef3aeb08c8ea755f8ef1fe5e513356c0f36a2b0d7568b0", size = 1912713, upload-time = "2026-08-28T10:01:12.285Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/93/fd89e9ad49b1805ca94d24ce1088b7d305f05c35ffafcedb9819d03588a0/pydantic_core-2.46.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:413a717a410d0c817ef5b786a059415550b3794e1d0c2abffd9efb93a3d9f7b4", size = 2090926, upload-time = "2026-08-28T10:01:15.19Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/45/8e59dab6acf8d35f02f0a958980074f31038968bdb2c983fcae9d1efee03/pydantic_core-2.46.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e449def1945a462c464331254e5a44fca7c3b4f9aedf59ec2f50f8066dd8e25", size = 2131303, upload-time = "2026-08-28T10:01:17.937Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/a5/e1d4dc5180dd887a9522efc1f8716b8692b7606b1d3273d7862eaf66be44/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:a445486499897b88a7d6c310c88ed64dd37b1b59bfd7ae9107490bbb362f47d6", size = 2145128, upload-time = "2026-08-28T10:01:20.694Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/d7/ad493864a7fb21c0c4df98f965e2db430cb25a9d7369b5778d5016c09fd9/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:2d330aaba8621b1edcec8ae2c4050f63b84ccf6d98723a8f212e9684713abf0e", size = 2294560, upload-time = "2026-08-28T10:01:23.495Z" },
+ { url = "https://files.pythonhosted.org/packages/02/8e/b41c84c913f29973a268e6c2b5bbf13c95adb9956c126d10da11ba3b2bef/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b6acfb46a814762367fb7ba0828b0a17d441b92ce249a0e007474c9072662dda", size = 2317531, upload-time = "2026-08-28T10:01:26.334Z" },
+ { url = "https://files.pythonhosted.org/packages/db/1d/068464f23075f66a8f1b806935e9cd9363ee446636ea70d2c22ee8659dbf/pydantic_core-2.46.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d0a24b40877af2de4950252be9d21eaf7fb07660f3c2cae1f56c6b599ada5266", size = 2140686, upload-time = "2026-08-28T10:01:28.947Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.15.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pydantic" },
+ { name = "python-dotenv" },
+ { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/ca/31c57507b13119d7d3cfa1576dad2911a4861e3be07b579395f4e9d393f9/pydantic_settings-2.15.0.tar.gz", hash = "sha256:694b793e84f766ba76a90ebdefc01d0a9a045dab0382bee70393da93712ad117", size = 261253, upload-time = "2026-08-07T09:24:57.419Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/30/a4/2bffa9f8e804325a09867f0e9d30795c80ea9f8d62560bd1b6ad6220eb2f/pydantic_settings-2.15.0-py3-none-any.whl", hash = "sha256:0ba092c291c94baceb5eff768aa0d56400a457585bc0175925a5a5510303da42", size = 69413, upload-time = "2026-08-07T09:24:55.839Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/c3/8a3b59c25070cc61dc517fbdfa5dc0904670c96f605cc69759dc09166b99/pyjwt-2.14.0.tar.gz", hash = "sha256:77283c83fb56ecf566a886c757a714bc83668e38156de2cce8263302f42e0b86", size = 113177, upload-time = "2026-09-11T13:11:54.638Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9c/97/672cb32ce0dfea44b740cb7b4f97038463b9cf7c0ead1aacf595572851d6/pyjwt-2.14.0-py3-none-any.whl", hash = "sha256:ad0cef71c756a56e74863c2919cf0985f72decbcfcb550ee2f422e7c62b5eedc", size = 32896, upload-time = "2026-09-11T13:11:53.409Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+ { name = "cryptography" },
+]
+
+[[package]]
+name = "pypdfium2"
+version = "5.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/78/a52cb80611339ec95f35c7a10d7bfe7a6f97f3b50a35a9f94283d062512e/pypdfium2-5.13.0.tar.gz", hash = "sha256:7ca2d8e31bd8d0d40c496416b7d8bea423388669ffd494929f50e8c3a82326b8", size = 273639, upload-time = "2026-08-13T10:58:15.837Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7c/9c/a49050af85055054299c7fab658ac63f8fddde575774aecbf8f71c7a9e5f/pypdfium2-5.13.0-py3-none-android_23_arm64_v8a.whl", hash = "sha256:882f4bbd4b17a335b43603169a14cde9341de12b238acd5c39e690cbca7c4293", size = 3417299, upload-time = "2026-08-13T10:57:40.522Z" },
+ { url = "https://files.pythonhosted.org/packages/50/ad/f23027328843ee2bdd05afe16bb101f5906befd0c70de35fa8c53f60a5ff/pypdfium2-5.13.0-py3-none-android_23_armeabi_v7a.whl", hash = "sha256:d96929bde3bd64c771ab3558ca1ffd7704cc4d872ab92cd9f8f8b8a20f7f36b8", size = 2864708, upload-time = "2026-08-13T10:57:42.259Z" },
+ { url = "https://files.pythonhosted.org/packages/08/99/1fe58428b69d2722dcbcfaa08ce71834a332c5b518fd58874bcef936b823/pypdfium2-5.13.0-py3-none-macosx_13_0_arm64.whl", hash = "sha256:da5c7b74eebf40b5c1fbe1de01aa1edc8827a79fb1efd999616bc20dcaf77ba4", size = 3507415, upload-time = "2026-08-13T10:57:43.978Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/41/06e26da88a4f5b4ed289325868717a186020661b7b221aa6df622711d31b/pypdfium2-5.13.0-py3-none-macosx_13_0_x86_64.whl", hash = "sha256:2abedfb5c70992b19c780ed58d7f7b929e8ce8ee52c9140158f44317c90ec6c7", size = 3670979, upload-time = "2026-08-13T10:57:45.607Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/31/f8210d53775f142be934336665b1d60e800c3f176f28c29b4908d945c518/pypdfium2-5.13.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ee8c2bb2e68b396ab4a763215ac100dacb6b96d0da5bebeb239a021aecc3a7e", size = 3676486, upload-time = "2026-08-13T10:57:47.267Z" },
+ { url = "https://files.pythonhosted.org/packages/94/50/d339fa09fbe592564b100bfc76833170a1104a764a458ac2abfffcb632f2/pypdfium2-5.13.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07f58e91b8c45ca144a1ff3008faf3c73ef8a5e9fb32988831788363288228cd", size = 3400883, upload-time = "2026-08-13T10:57:49.189Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/e0/b10cf41b5e9f0212d014c40635659c6ab95bb4fcc6fc47f5d3c571f8d57f/pypdfium2-5.13.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:46b2f5be9e7ae941ee4216e3d20b66f9dc3d81944a3d57756272de5275204709", size = 3803912, upload-time = "2026-08-13T10:57:50.865Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/d8/25ba4ce9a9059ece82f4514df0658fde0aa9bbeafe135e76017c052bf56f/pypdfium2-5.13.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d96beb7f379e6c76d874ca93fcd182ac3168dd499056407070f9927fb1061b8e", size = 4218231, upload-time = "2026-08-13T10:57:52.525Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/7c/74a2fb48e5b0d2402d9ca64b39074c722d67e9a8a2c58449a843a8c2329a/pypdfium2-5.13.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81df25c1ab4c13ff773102d3cbea1967511d079123b067fc077bd0c4d57d91d8", size = 3730077, upload-time = "2026-08-13T10:57:54.021Z" },
+ { url = "https://files.pythonhosted.org/packages/59/12/8c922f00518c26dc47d3676cc09c1d3c95e991c1977e31067d23cc2215cb/pypdfium2-5.13.0-py3-none-manylinux_2_27_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d66a32d89fa5b4a2715810171239eb194df4aba604727483ab760512f3c6a851", size = 4031512, upload-time = "2026-08-13T10:57:55.736Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/48/a171d034c2dac01adcc57d3dad3c97ba11f19d916f421176002c9e02c904/pypdfium2-5.13.0-py3-none-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b90b0a5ac310bb34db8eb848e58fcab4e201e124e3cf3cb1ccb7b85293e034af", size = 3995485, upload-time = "2026-08-13T10:57:57.39Z" },
+ { url = "https://files.pythonhosted.org/packages/36/2e/dcb24776d409bb9e5b7fb26a0c62a87b98ab0e30dfcca645eaf31e35123b/pypdfium2-5.13.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:ada81c36483cd61d07e32bc7814620ee96256b4f421b913f566861bf91800248", size = 5016636, upload-time = "2026-08-13T10:57:59.181Z" },
+ { url = "https://files.pythonhosted.org/packages/93/24/1fab8470fc6de6f4481f009c90757b1a1ee0a61d8e864ed273f72ffca855/pypdfium2-5.13.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:3826e521e895648983cb9ee6b934d4bf51552600043984f84e9c2b3b14b696f3", size = 4555251, upload-time = "2026-08-13T10:58:00.753Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/ef/6e8dbea1eddcb55cf34172753ffccd39566333c803cc94d43c653f369f2f/pypdfium2-5.13.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5c029d7163a91f264eafab51fb442a84a33efd9fd83d5a06c0136a7857a3cc8d", size = 5263483, upload-time = "2026-08-13T10:58:02.48Z" },
+ { url = "https://files.pythonhosted.org/packages/53/fe/2ff673730189a621c01f9193c74b0f6aa70d8740889fdf11949e1c541869/pypdfium2-5.13.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:be2dccbde0ce7efe334ecd8f348df4308db360756ede4f0821d82dfc9a58caa8", size = 5144135, upload-time = "2026-08-13T10:58:04.351Z" },
+ { url = "https://files.pythonhosted.org/packages/19/0b/759b9037c007317fa5c990dd3f6eff2b99d3fbced251d1e2512be92f2e2e/pypdfium2-5.13.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:bcd81394fe101405e026eedb3e40bef84635c1e5d974dd6036420eb6937753c6", size = 4648156, upload-time = "2026-08-13T10:58:06.036Z" },
+ { url = "https://files.pythonhosted.org/packages/db/3b/ffe29679c52efe8eb02d77aa6656e6d6201395423329af018ebd5923a3d0/pypdfium2-5.13.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:2ed32ff685f8e05e637c990bedbf5fca66727bf27718d8bc33eeab21ce0630d1", size = 5089852, upload-time = "2026-08-13T10:58:07.791Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/b6/cebacc1601ddfdcd1e6a1dc321533d215ceccf9b825fa9b91b11c6dc39fb/pypdfium2-5.13.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:9c777edba28d1d5fd15435ed3a78ee2fdb93dd069be37cb53b559bc122793770", size = 5074153, upload-time = "2026-08-13T10:58:09.396Z" },
+ { url = "https://files.pythonhosted.org/packages/54/40/cf14c4f534f817788966857afdedb90002198dca5ce4fe2c6ecb031955ae/pypdfium2-5.13.0-py3-none-win32.whl", hash = "sha256:d33ee7077db67478b75efe4b5ea9610fb96c5416a0bc4949227f0f59c34dfcd9", size = 3753164, upload-time = "2026-08-13T10:58:10.97Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/99/a37b6b902457569468ed5908c94e56cb6c4032541f02cf89f723d42a9148/pypdfium2-5.13.0-py3-none-win_amd64.whl", hash = "sha256:47dcca2a8d507b5fd24f94c3c9d48fb379430f097bc20f01beff6c963ffbcedb", size = 3885553, upload-time = "2026-08-13T10:58:12.709Z" },
+ { url = "https://files.pythonhosted.org/packages/50/7f/d39f6e64375c2ffd50ea100e3c73af79085c880c2791eb7203bc61d8913f/pypdfium2-5.13.0-py3-none-win_arm64.whl", hash = "sha256:554a0b23376460af1410e3c915906895e2dac67a086b9e6ccde0643a795d3b0d", size = 3700026, upload-time = "2026-08-13T10:58:14.206Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+ { name = "iniconfig" },
+ { name = "packaging" },
+ { name = "pluggy" },
+ { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pytest" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.32"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "312"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1f/f5/10a6e845a00fc5e7afd0a988b744f403d4d57162a28d160a093c4d9322f0/pywin32-312-cp311-cp311-win32.whl", hash = "sha256:17948aeadbdb091f0ced6ef0841620794e68327b94ee415571c1203594b7215c", size = 6362659, upload-time = "2026-06-04T07:49:21.349Z" },
+ { url = "https://files.pythonhosted.org/packages/35/c4/dcd2d62b5944b6d5db53413a5899016ccd57ffcb7278f3f81655d25d2027/pywin32-312-cp311-cp311-win_amd64.whl", hash = "sha256:d11417d84412f859b722fad0841b3614459ed0047f7542d8362e77884f6b6e8a", size = 6928825, upload-time = "2026-06-04T07:49:23.934Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/56/3cbb433fe4501cdba2eb9040f56a4e1a8243faa4186b25295564d1a7a79d/pywin32-312-cp311-cp311-win_arm64.whl", hash = "sha256:b2200a054ca6d6625c4842fc56a4976a4b47f96b73dbe5538c3f813a80359f47", size = 6721875, upload-time = "2026-06-04T07:49:26.416Z" },
+ { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" },
+ { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" },
+ { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "attrs" },
+ { name = "rpds-py" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "2026.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/94/1f/a2dca5ffdbf1d475ffc4e80e4d5d720ff3a00f691795910116960ee12511/rpds_py-2026.6.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7b689145a1485c335569bd056464f3243a29af7ed3871c7be31ad624ba239bc7", size = 342174, upload-time = "2026-06-30T07:14:54.821Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/dc/323d08583c0832911768663d1944f0107fcd4088704858d84b5e06d105a0/rpds_py-2026.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:db08f45aecde626498fb3df07bcf6d2ec040af42e859a4f5040d79c200342911", size = 345513, upload-time = "2026-06-30T07:14:56.515Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/2a/e31989834d18d2f26ec1d2774c5b1eb3331df4ea8ada525175294c94b48a/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:acc992ab27b15f852c76755eb2ab7dce86585ddadba6fa5946e58556088845b4", size = 373783, upload-time = "2026-06-30T07:14:57.736Z" },
+ { url = "https://files.pythonhosted.org/packages/87/fe/e80107ee3639585c9941c17d6a42cd65325022f656c023191fce78c324c8/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f88d653e7b3b779d71ae7454e20dcc9b6bae903f33c269db9f2be41bda3f261", size = 378316, upload-time = "2026-06-30T07:14:59.077Z" },
+ { url = "https://files.pythonhosted.org/packages/22/6f/81e3adf81acfb6fa694de2a6e4e7d8863121e3e0799e0a7725e6cf5679c4/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e52655eaf81e32593abedaa4bfe33170c8cfedf3365ed9be6e11e07f148f0278", size = 499423, upload-time = "2026-06-30T07:15:00.488Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/9a/41263969df0ce3d9af2a96d5005a288200af1989aed3354bfceb5fc0b21f/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dfcc8b909769d19db55c7cc9541eb64b9b774b1057ffffb4f1048070475bb9f9", size = 386077, upload-time = "2026-06-30T07:15:01.911Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/19/7e98f468bd50346faff5b10e5297374b443bfdddacc8e9fbc65984539597/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c1255b302953c86a486b81d330d5ee1d5bd937691ce271b6be0ef0e299eaab7", size = 371315, upload-time = "2026-06-30T07:15:03.317Z" },
+ { url = "https://files.pythonhosted.org/packages/99/3c/2b973b4d371906a134b03decfea7f5d9835a2c6d263454392e15b64b5b18/rpds_py-2026.6.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:8d2294a31386bfa251d8c8a39472beee17db67d4f1a6eabea665d35c9a4461c3", size = 383502, upload-time = "2026-06-30T07:15:04.627Z" },
+ { url = "https://files.pythonhosted.org/packages/98/2a/12e2799500af0a307bca76b63361c51f9fe479223561489c29eea1f2ee41/rpds_py-2026.6.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8f23ead891a3b762f35ab3b04623da7056545b48aa60d59957e6789914545da", size = 402673, upload-time = "2026-06-30T07:15:05.856Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/e3/21e5872d165fe08be4f229e3d5ee9d90019c0bf0e5538de60dbd54009450/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:421aba32367055614287a4292b6a17f1939c9452299f7a0209c117e990b646d4", size = 549964, upload-time = "2026-06-30T07:15:07.159Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/d0/5ee0fe36844297de8123bee27bc12078c1a7416ad9f1b8a8ca18d6b0c0ac/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1e5822dfc2f0d4ab7e745eaa6d85945069329beeccef965af3f3bb26058fcab6", size = 615446, upload-time = "2026-06-30T07:15:08.531Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/80/1ea5873cb683f2fbe5f21b23ea1f6d179ead19f3c5b249b7eb5dca568ef2/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:83e35b57523816c8613fd0776b40cd8bb9f596b37ddd2692eb4a6bb5ab2f8c93", size = 576975, upload-time = "2026-06-30T07:15:09.97Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/e1/90ef639217a5ddb15b7f4f61b1c33911fd044ad03c311bafdd2bcab85582/rpds_py-2026.6.3-cp311-cp311-win32.whl", hash = "sha256:de3eceba0b683bcbb1ab93da016d0270df1f9ae7be716b40214c5dafac6ea45a", size = 204453, upload-time = "2026-06-30T07:15:11.324Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/b7/b7a1695d7af36f521fb11e80d6d3adbd744f73b921859bd3c2a2c0dc706f/rpds_py-2026.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:2c54a076ca4d370980ab57bc0e31df57bbe8d41340436a90ef8b1219a3cbb127", size = 223219, upload-time = "2026-06-30T07:15:12.476Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/a2/145afacf796e4506062825941176ad9445c2dcf2b3b6a1f13d3030a15e19/rpds_py-2026.6.3-cp311-cp311-win_arm64.whl", hash = "sha256:168c733a7112e071bb7a66460e667edfcff06c017a3c523f7a8a8e08d0140804", size = 219137, upload-time = "2026-06-30T07:15:13.631Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" },
+ { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" },
+ { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" },
+ { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" },
+ { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" },
+ { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" },
+ { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" },
+ { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" },
+ { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" },
+ { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" },
+ { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/9c/f0d19ac587fd0e4ab6b72cda355e9c5a6166b01ef7e064e437aef8eb9fef/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4cf2d36a2357e4d07bb5a4f98801265327b48256867816cfd2ceb001e9754a8f", size = 349791, upload-time = "2026-06-30T07:17:33.315Z" },
+ { url = "https://files.pythonhosted.org/packages/38/c7/1d49d204c9fd2ee6c537601dc4c1ba921e03363ca576bfab94a00254ac9a/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:30c6dc199b24a5e3e81d50da0f00858c5bbdb2617a750395687f4339c5818171", size = 352842, upload-time = "2026-06-30T07:17:34.897Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/e5/c0b5dc93cd0d4c06ce1f438907649514e2ea077bcd911e3154a51e96c38e/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9891e594296ab9dada6551c8e7b387b2721f27a67eecd528412e8906247a7b90", size = 382094, upload-time = "2026-06-30T07:17:36.514Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/54/ec0e907b4ca8d541112db352409bd15f871c9b243e0c92c9b5a46ae96f01/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5c2dc92304aa48a4a60443b548bb12f12e119d4b72f314015e67b9e1be97fca", size = 388662, upload-time = "2026-06-30T07:17:38.235Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/f4/921c22a4fd0f1c1ac13a3996ffbf0aa67951e2c8ad0d1d9574938a2932e8/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:127e08c0642d880cf32ca47ec2a4a77b901f7e2dd1ad9762adb13955d72ffcc9", size = 504896, upload-time = "2026-06-30T07:17:39.689Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/1b/a114b972cefa1ab1cdb3c7bb177cd3844a12826c507c722d3a73516dbbaf/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8bb68f03f395eb793220b45c097bd4d8c32944393da0fad8b999efac0868fc8c", size = 391545, upload-time = "2026-06-30T07:17:41.336Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/98/af9b3db77d47fcbe6c8c1f36e2c2147ec70292819e99c325f871584a1c11/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3450b693fde92133e9f51060568a4c31fcca76d5e53bbd611e689ca446517e9", size = 380059, upload-time = "2026-06-30T07:17:42.857Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/ba/0efd8668b97c1d26a61566386c636a7a7a09829e474fdf807caa15a2c844/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:5e8d07bddee435a2ff6f1920e18feff28d0bc4533e42f4bf6927fbd073312c41", size = 393235, upload-time = "2026-06-30T07:17:44.637Z" },
+ { url = "https://files.pythonhosted.org/packages/62/90/8c139ee9690f73b0829f32647de6f40d826f8f443af6fa72644f96351aac/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3a83ae6c67b7676b9878378547ca8e93ed77a580037bcbcd1d32f739e1e6089c", size = 413008, upload-time = "2026-06-30T07:17:46.225Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/97/0043896fdd7828ce09a1d9a8b06433714d0960fc4ff3fc4aa72b666b764e/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2bfd04c19ddbd6640de0b51894d764bd2758854d5b75bd102d2ef10cb9c293a9", size = 558118, upload-time = "2026-06-30T07:17:47.759Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/40/02355f0e134f783a8f9814c4680a1bd311d37671577a5964ea838573ff37/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:ca6546b66be9dc4738b1b043d5ebd5488c66c578c5ff0fd0e8065313fe3afb76", size = 623138, upload-time = "2026-06-30T07:17:49.355Z" },
+ { url = "https://files.pythonhosted.org/packages/10/85/48f0abdcef5cce4e034c7a5b0ceeceba0b01bf0d942824f4bb720afe2dec/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8e65860d238379ed982fd9ba690579b5e95af2f4840f99c772816dbe573cb826", size = 586486, upload-time = "2026-06-30T07:17:51.141Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.16.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/78/449cb84790bd5cc3823b2652ee405a4558856e5c4195aee3a16bf7b3eb5d/ruff-0.16.8.tar.gz", hash = "sha256:9247bf92b5f04d825c8639a4fe423ec2e4222acd9222e58412b0dab7e442798b", size = 4938814, upload-time = "2026-09-16T15:54:46.688Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ac/25/6071aabc530e9be7e2c195e8fe3f7aea2735405b6cf447212832d7811831/ruff-0.16.8-py3-none-linux_armv6l.whl", hash = "sha256:6ffbd6d87383c1edf5f6fa890f10200950240d7c1a16052a19a09d3a2307dd38", size = 10048966, upload-time = "2026-09-16T15:53:57.605Z" },
+ { url = "https://files.pythonhosted.org/packages/54/98/07f90ecbc74dd5fb5764f11f2bc774d6a7cffef92d2ff5f5b4e9e23c754e/ruff-0.16.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:42ed6b878ed61e3acca92f2730a17acff39286944ea82398544696366a6f925e", size = 10165498, upload-time = "2026-09-16T15:54:01.14Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/1f/e6a712e3b47cad4a40600134105ed193cb773f618a42eb7ba323cb812cc0/ruff-0.16.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ea781c7f2afba8c6a505ea0fb3f994020249e0c450635f5381286fea6b46170", size = 9830004, upload-time = "2026-09-16T15:54:03.998Z" },
+ { url = "https://files.pythonhosted.org/packages/23/f2/311a08776d75d81c7676e20b6b020ae63cbe881fcdc7a8dd64e6e18bdd93/ruff-0.16.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8efeae3bbe414a5efefda11a792dfb51ef90ac48d50c4830de2f644caf3e8659", size = 9986558, upload-time = "2026-09-16T15:54:06.804Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/ed/37b6cb3d3ba8c73e68ae3eb1d502383beb5aa05a582bb7bb3a922f929f54/ruff-0.16.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a79b795469fef7fc6e908b218eed2eb17332afd85031db6480dc864560e69b2", size = 9877332, upload-time = "2026-09-16T15:54:09.552Z" },
+ { url = "https://files.pythonhosted.org/packages/22/cc/40873a8f36ad084cc540d55fcca7077264d5b13b24659e9180c176fb2b08/ruff-0.16.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3fdc5563cdc50555e6fba39322850860e9267c1b3d12c26a74729d8604c3c812", size = 10507125, upload-time = "2026-09-16T15:54:12.152Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/e4/fc91a642b78ccbab6b9477720f3644ae7a10a9bcce69a934679cd64f62bc/ruff-0.16.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34508983c70665578dab88f5223d8e6228307e1135398ca8bfc8b7e9501e282b", size = 11336694, upload-time = "2026-09-16T15:54:15.489Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/3d/bbd2a9a600a4e73dc3e7548a249c8d1671273464b55822c6fae50f602dff/ruff-0.16.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:644bb578569e0ffc575741232bd385dacdd6fbe123f1a729e7a225f54aa3957f", size = 10774448, upload-time = "2026-09-16T15:54:18.16Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/41/d83af9879a7b6e8bf5fe16b1da0b134049d2f5d3afac12defb0897cb84bd/ruff-0.16.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15e7d226246961db9235098333caa13063906d3851136b84c2900b82f5daa1df", size = 10323796, upload-time = "2026-09-16T15:54:20.743Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/2c/cefd07bfe914b84943ea769ade8d607bd22750b965d3228eefd7cebd15d0/ruff-0.16.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a2bf6bc3e9ebdd4449abc6f06cf64b98051a2c61cf94d2fe9596518c881f1a1e", size = 10514115, upload-time = "2026-09-16T15:54:23.497Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/9d/76a2e26c79a23be6e6e3664c57bec9e9fc8de155cfb9e4b67ea91b64f9d7/ruff-0.16.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:6ca111ba0849539165e9e59d2b442542f3c1e8060ebbdea82494f1ffbccb1e1f", size = 10072582, upload-time = "2026-09-16T15:54:26.185Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/d4/f42edddb39668af1a559ceafa3823aedd65633a48dc9768e775485faa2c1/ruff-0.16.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:359a1e5b495448ee1e91018064382ebc86f90e8aac2fed222c7d0e4e8df85fd2", size = 9879644, upload-time = "2026-09-16T15:54:29.278Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/d4/913e3195d95e0378786c6656945c865f534a3560e29139da4882aff630d1/ruff-0.16.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:59e8f5681349474110b24d62e93cfda6593f5fa3473446ca3705200cac1a08b9", size = 10231569, upload-time = "2026-09-16T15:54:32.036Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/c4/8aa6ea0bdcedbd1bf87397e2fc4ed8406448ea5842f8660bc6e5f163039d/ruff-0.16.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:efa3e7a16d1baaa79957888dfdf8be9ef2e44db81cb032af06d76632ab59e773", size = 10663666, upload-time = "2026-09-16T15:54:34.838Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/02/7f10ef4700bc223c30a3fdd10631a29830c45524b810a3c7ed947af64591/ruff-0.16.8-py3-none-win32.whl", hash = "sha256:55793ba85c69921e89be061426d91a78652d6e50317c962240922747a4eb713f", size = 10093472, upload-time = "2026-09-16T15:54:37.47Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/5d/a509c07d714b6da88f2c518b4637cf6f1d46b074be8f0f1e5fb9ff5126fe/ruff-0.16.8-py3-none-win_amd64.whl", hash = "sha256:a6b85621fd3c81e31fc5f5add09c9c078b430db3595ca632efafdec9e64ebfaa", size = 10586899, upload-time = "2026-09-16T15:54:40.488Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/a0/50787329e4f20bf9dc9f6230015d46ec69c51a97ace5bc202dae4755365d/ruff-0.16.8-py3-none-win_arm64.whl", hash = "sha256:d075e820af612102ce217f07cc93e69f9490b10ec13ea85fa87bd03d996cef8a", size = 10386316, upload-time = "2026-09-16T15:54:43.332Z" },
+]
+
+[[package]]
+name = "safetensors"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", hash = "sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d", size = 325846, upload-time = "2026-06-09T07:52:25.563Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/39/a0/f718cda65b05407d228f97602cf60dca269c979867aa5beb25410de26cd3/safetensors-0.8.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0", size = 473568, upload-time = "2026-06-09T07:52:18.829Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/b1/fa7c600e7dceae12e9606c7578cbc9ff1e1ed55844883ee5c92205e86226/safetensors-0.8.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25", size = 484562, upload-time = "2026-06-09T07:52:17.518Z" },
+ { url = "https://files.pythonhosted.org/packages/09/7d/65a7de0af421317bb36a067241e4235fff194eed60b961ed6d3f59a3fc60/safetensors-0.8.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235", size = 502844, upload-time = "2026-06-09T07:52:07.624Z" },
+ { url = "https://files.pythonhosted.org/packages/91/4f/3175c9d75634e0e0dda0082794193521035edd7c70a6f212bf33ca06ddf4/safetensors-0.8.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0", size = 511823, upload-time = "2026-06-09T07:52:09.565Z" },
+ { url = "https://files.pythonhosted.org/packages/20/87/846c289e7aa2299eff406335717cf43ce8777194ece8aad75772e0411615/safetensors-0.8.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98", size = 633461, upload-time = "2026-06-09T07:52:11.128Z" },
+ { url = "https://files.pythonhosted.org/packages/76/22/8d64d9df2c45d5ded401df889d0ad90882804ca172d79ec4f0df8f727fe0/safetensors-0.8.0-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358", size = 545148, upload-time = "2026-06-09T07:52:13.603Z" },
+ { url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774", size = 516040, upload-time = "2026-06-09T07:52:16.29Z" },
+ { url = "https://files.pythonhosted.org/packages/46/fb/cdaed17ceb2948784fd9c36b6fd3e951b608547cea81a48e8ee6f8cfdfcb/safetensors-0.8.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78", size = 513832, upload-time = "2026-06-09T07:52:12.37Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/49/1e15de264dcc3b77943d2d0c56a95809956883b1c2d6d585c792523f180b/safetensors-0.8.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca", size = 559930, upload-time = "2026-06-09T07:52:14.743Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/43/bf38443278eab4b1be1fce2931e2b012ad9cb7df52ada751d0aab8f7659a/safetensors-0.8.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4", size = 678670, upload-time = "2026-06-09T07:52:20.032Z" },
+ { url = "https://files.pythonhosted.org/packages/72/e3/68cd3fa5b48488e84add63e04cb12f3bc28ae4638c06d4508c6e88823d0e/safetensors-0.8.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc", size = 786679, upload-time = "2026-06-09T07:52:21.322Z" },
+ { url = "https://files.pythonhosted.org/packages/29/4b/1c19c509d56e01f4fbb3d0a2e597450f6cc04d1d56cf52defb0a62dfd715/safetensors-0.8.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d", size = 765683, upload-time = "2026-06-09T07:52:22.594Z" },
+ { url = "https://files.pythonhosted.org/packages/27/43/41c1621732edd934d868a00d1b891584c892a7b62a9aab82ea5a0a5623ee/safetensors-0.8.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846", size = 722361, upload-time = "2026-06-09T07:52:23.924Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/3f/73ccf82579412b4a71c4ca673f10b5f1f888d7cf5af7fe24f27d30307be4/safetensors-0.8.0-cp310-abi3-win32.whl", hash = "sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d", size = 342401, upload-time = "2026-06-09T07:52:28.895Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl", hash = "sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f", size = 355540, upload-time = "2026-06-09T07:52:27.832Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/fc/7eedc3510d97878876e32774eebbeb61c43f148a96e915c84229a3e967aa/safetensors-0.8.0-cp310-abi3-win_arm64.whl", hash = "sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452", size = 340500, upload-time = "2026-06-09T07:52:26.745Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "84.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.4.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2b/54/6767bb789b2f2fed6e0f953df949cd39dc263a384c1b65a95232598621d6/sse_starlette-3.4.11.tar.gz", hash = "sha256:1bae716c02f3e6f294be41ff333220692dae7c3cbab077c900f159676719dade", size = 34972, upload-time = "2026-09-05T12:11:04.607Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/98/6a/2ba3ed4a69babf3afdddf7d8314a48d87562c0a442206bbc2a1b50d5efc0/sse_starlette-3.4.11-py3-none-any.whl", hash = "sha256:c7b2244bdff016fe7f64e10075e89a3e6bbf899649cc89b0fe884b5545042453", size = 17122, upload-time = "2026-09-05T12:11:03.195Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
+ { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" },
+ { name = "filelock" },
+ { name = "fsspec" },
+ { name = "jinja2" },
+ { name = "networkx" },
+ { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" },
+ { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" },
+ { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" },
+ { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" },
+ { name = "setuptools" },
+ { name = "sympy" },
+ { name = "triton", marker = "sys_platform == 'linux'" },
+ { name = "typing-extensions" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e6/2c/0c9757a1ea1fff8ccc4faff1d1c87e98a69542b5d4b606e50f7518f72e58/torch-2.14.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ae530ddd3f3b94248b77f1fd3313c4f3405bd0d17283d505b81574816767133a", size = 127277244, upload-time = "2026-09-02T13:42:57.855Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/30/eb2f6cf77cb8f2d5e7ce4343882a856783521f51b557673d78d1d7bb8661/torch-2.14.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:4dbea8a10d80b10dff2be1ed467d2617b704fe6bf76bbfad4194774c8f6d886b", size = 453993896, upload-time = "2026-09-02T13:43:29.231Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/be/c0c8a845bf00552960d2f1f6a00b6ac9750fd312f55429c3e8c6c0e3aac4/torch-2.14.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8d9e232b6376c62f3090237889fb1cb6887c0ece9f73e6c1052e80fc1481f999", size = 554583496, upload-time = "2026-09-02T13:44:10.199Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/5b/ed9d177f6a133389d5fa89e298f3e2a879b62952aa928ac6ddd04467f225/torch-2.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:6981872df75eb5409c439050d36b67cb57d88b4e11080516e2aa7410f6730705", size = 124096356, upload-time = "2026-09-02T13:43:02.941Z" },
+ { url = "https://files.pythonhosted.org/packages/17/76/bb4770f56cf6d8971671dbcbb7493e5a6a15ad2825f4e359b02c27c38297/torch-2.14.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:c1f844f1c750e87df4b68bc3afbc0e2b0c7ef19d7b8f666e48bdcf6a0c4f0056", size = 127303200, upload-time = "2026-09-02T13:43:20.311Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/7b/ec44bacf2c8886b85ba4ca2285e8b09f2dff5d9c99e6a031326954082cb5/torch-2.14.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:ada340e62591d06a2bcc2d68170f20f45f0b0665d372dc510a8ed7eb3b1d609a", size = 454010251, upload-time = "2026-09-02T13:44:24.927Z" },
+ { url = "https://files.pythonhosted.org/packages/15/71/49399acd41f750a906c686bd23c08a2001ccb8dd25f2971003c2ed89c1dd/torch-2.14.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:fecffb58f51fd643d213acd68da21cc3fc19bea05a3bc64b4ee55128f47a4963", size = 554620488, upload-time = "2026-09-02T13:44:49.442Z" },
+ { url = "https://files.pythonhosted.org/packages/be/16/9489b137112040f9911d7527e452854f21cc4e499ce0da79864e6a7451a7/torch-2.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:cad84f41bbdf3dcf333ce394aeeaf25237c4d94fd6b659ba5eb813c829978823", size = 124114011, upload-time = "2026-09-02T13:43:55.034Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/40/0db773452c2a62b37761d3f418acf933d381f9e87077036fb57c2a386c37/torch-2.14.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9d4b1022a5d9b71282ec67ad0d9e7235870096b8a246dc1c32d6ea1fc83dc998", size = 127311393, upload-time = "2026-09-02T13:43:59.607Z" },
+ { url = "https://files.pythonhosted.org/packages/13/36/537fd9da2adad49e7b2bb20741398625bee548493158274e87369a8eed56/torch-2.14.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:731b9ebdea402b8b1996d4c2ae613b16660e559b19e47bdc45d970568bc91c53", size = 454010525, upload-time = "2026-09-02T13:45:03.719Z" },
+ { url = "https://files.pythonhosted.org/packages/21/f1/39bd13b21f57d1982b7f3ddf663f01c7266e2957714880744eba9e8c8d11/torch-2.14.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:84bf384779a10c02fc3c6bdbab71a9cb66b0dd93c652d1ed5d6dfc0cb37e5962", size = 554619993, upload-time = "2026-09-02T13:45:28.209Z" },
+ { url = "https://files.pythonhosted.org/packages/89/a8/683d9c44737554b67ca76dd2db4f42258a0f014246cb511293e51e0154bd/torch-2.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:0e7cf18cb0d8bd666b6120932e29c7aef3502b61a08b44da4839580c539a7cdb", size = 124113865, upload-time = "2026-09-02T13:44:33.705Z" },
+]
+
+[[package]]
+name = "triton"
+version = "3.8.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a3/cf/d21c9b1a4d1df9ba3aed218069f24f762a4b9565c5a362bef6f110c08e72/triton-3.8.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:372285307d4c44ee74cee32de0b4f04bd157e071427e38c6f4ee3e3beb2194f4", size = 226467015, upload-time = "2026-08-28T16:08:05.871Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/9a/2c3d3823726d5ad5359f7065b02b984925158b74611c1e3987f6a37461fb/triton-3.8.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:68988ac85d5e7086baeda0ddc175af9667db7529b3c5e11a5c0601b8bef2200a", size = 247945226, upload-time = "2026-08-28T15:55:43.795Z" },
+ { url = "https://files.pythonhosted.org/packages/87/07/0f8cd8e8db0472334253efdaaab3d0819fea27aa99bf0e7f1aeea4ceb5ae/triton-3.8.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9c404c69ed4a39e8ec632eaf6b9fe058a060bf98979c177f6ef666f06bb8d50", size = 226474486, upload-time = "2026-08-28T16:08:18.29Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/09/b7012e5bfae67640f268aa584caa80fe1674f6b0da949046b679972c33e3/triton-3.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e91ffa46d095b252248297292dd22bcbacd53a125a0c2eefbbbf74925a320bc3", size = 247972921, upload-time = "2026-08-28T15:55:53.157Z" },
+ { url = "https://files.pythonhosted.org/packages/87/4d/4c564374bcdadb166fccbf3e45aee0d4a473f88d341761bd2fefe3b8e8c1/triton-3.8.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7004666652f500ed854a86988e4b3d69d247188b5d2092b5df1e44f4a954099", size = 226476793, upload-time = "2026-08-28T16:08:30.956Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/b6/3394d5548404c1cabd1dadadd28d0b3f9478db1dff8180da53bb3f0a1e19/triton-3.8.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f0497218e26b7d79773ad9c2a3fa3b539ee69f587a13fac2e552b1d322a8015", size = 247975122, upload-time = "2026-08-28T15:56:04.112Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.53.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "click" },
+ { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5d/ad/04bbb797c84fc1f26cb171f7394716f4865ffb8d8c5e1eef42565c2dfa6b/uvicorn-0.53.0.tar.gz", hash = "sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e", size = 110881, upload-time = "2026-09-14T07:44:23.815Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/76/18/0eea75741ee812e9f598b687619ce2454f6c3a1c5cd21ea990ec6bd26f45/uvicorn-0.53.0-py3-none-any.whl", hash = "sha256:e8dca71ec86dce5f04e333f0d56cdedf942446e6643b9cea1af0d6d3a02cb03e", size = 87081, upload-time = "2026-09-14T07:44:22.179Z" },
+]
diff --git a/libs/cua-s1/training/autoresearch.py b/libs/cua-s1/training/autoresearch.py
new file mode 100644
index 0000000000..9a3c054230
--- /dev/null
+++ b/libs/cua-s1/training/autoresearch.py
@@ -0,0 +1,296 @@
+"""Run a configurable, deterministic Cua-S1 form-specialist experiment ladder."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import time
+from pathlib import Path
+
+from cua_s1.model import load_checkpoint, save_checkpoint, select_device
+
+from train import MetaDataset, evaluate, train
+
+BASE_MODEL_CONFIG = {
+ "encoder": "tinyx",
+ "width": 128,
+ "rank": 128,
+ "layers": 2,
+ "heads": 4,
+ "context_tokens": 224,
+ "option_tokens": 96,
+}
+
+DEFAULT_LADDER = (
+ {
+ "name": "tiny-64",
+ "model": {"encoder": "tiny", "width": 64, "rank": 64},
+ "training": {"epochs": 6},
+ },
+ {
+ "name": "tiny-256",
+ "model": {"encoder": "tiny", "width": 256, "rank": 256},
+ "training": {"epochs": 6},
+ },
+ {"name": "tinyx-128-l2", "model": {}, "training": {"epochs": 6}},
+ {
+ "name": "tinyx-192-l3",
+ "model": {"width": 192, "layers": 3, "heads": 6},
+ "training": {"epochs": 8},
+ },
+ {
+ "name": "tinyx-256-l4",
+ "model": {"width": 256, "rank": 256, "layers": 4, "heads": 8},
+ "training": {"epochs": 8, "learning_rate": 1e-3},
+ },
+ {
+ "name": "tinyx-128-l2-lr1e-3-e12",
+ "model": {},
+ "training": {"epochs": 12, "learning_rate": 1e-3},
+ },
+)
+
+_SAFE_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
+_TRAINING_KEYS = {"epochs", "batch_size", "learning_rate", "warmup"}
+
+
+def _validate_name(name: str) -> str:
+ if not _SAFE_NAME.fullmatch(name) or name in {".", ".."}:
+ raise ValueError(f"unsafe experiment name: {name!r}")
+ return name
+
+
+def _experiment_seed(base_seed: int, name: str) -> int:
+ digest = hashlib.sha256(f"{base_seed}:{name}".encode("utf-8")).digest()
+ return int.from_bytes(digest[:4], "big")
+
+
+def load_ladder(path: str | Path | None) -> list[dict]:
+ """Load an optional JSON ladder, validating the small supported schema."""
+
+ if path is None:
+ ladder = [
+ {
+ "name": experiment["name"],
+ "model": dict(experiment["model"]),
+ "training": dict(experiment["training"]),
+ }
+ for experiment in DEFAULT_LADDER
+ ]
+ else:
+ payload = json.loads(Path(path).read_text(encoding="utf-8"))
+ if not isinstance(payload, list):
+ raise ValueError("ladder JSON must be a list of experiments")
+ ladder = payload
+
+ seen: set[str] = set()
+ validated: list[dict] = []
+ for experiment in ladder:
+ if not isinstance(experiment, dict):
+ raise ValueError("each ladder experiment must be an object")
+ name = _validate_name(str(experiment.get("name", "")))
+ if name in seen:
+ raise ValueError(f"duplicate experiment name: {name}")
+ seen.add(name)
+ model = experiment.get("model", {})
+ training = experiment.get("training", {})
+ if not isinstance(model, dict) or not isinstance(training, dict):
+ raise ValueError(f"experiment {name} model and training values must be objects")
+ unknown_training_keys = set(training) - _TRAINING_KEYS
+ if unknown_training_keys:
+ unknown = ", ".join(sorted(unknown_training_keys))
+ raise ValueError(f"experiment {name} has unsupported training keys: {unknown}")
+ validated.append({"name": name, "model": dict(model), "training": dict(training)})
+ return validated
+
+
+def _write_json(path: Path, payload: dict) -> None:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ temporary = path.with_suffix(path.suffix + ".tmp")
+ temporary.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+ temporary.replace(path)
+
+
+def _metric_summary(metrics: dict) -> dict:
+ return {
+ "top1": metrics["top1"],
+ "nll": metrics["nll"],
+ "ece": metrics["ece"],
+ "examples": metrics["examples"],
+ "per_action": metrics["per_action"],
+ }
+
+
+def run_experiment(
+ name: str,
+ config: dict,
+ training: dict,
+ data: Path,
+ output: Path,
+ device_name: str,
+ seed: int,
+ workers: int,
+ deterministic: bool,
+ record_timing: bool = False,
+) -> dict:
+ """Train and score one form-specialist experiment."""
+
+ name = _validate_name(name)
+ checkpoint = output / "checkpoints" / name
+ started = time.perf_counter()
+ training_options = {
+ "seed": seed,
+ "workers": workers,
+ "deterministic": deterministic,
+ **training,
+ }
+ result = train(
+ config,
+ data / "train.jsonl",
+ data / "validation.jsonl",
+ checkpoint,
+ device_name=device_name,
+ log=lambda message: print(f"[{name}] {message}"),
+ **training_options,
+ )
+ device = select_device(device_name)
+ model, collator, _ = load_checkpoint(checkpoint, device)
+ test_dataset = MetaDataset(data / "test.jsonl")
+ test = evaluate(model, test_dataset, collator, device)
+ shuffled_context = evaluate(model, test_dataset, collator, device, shuffle_context=True)
+ record = {
+ "name": name,
+ "config": config,
+ "training": training_options,
+ "parameters": result["parameters"],
+ "best_validation": result["best_validation"],
+ "test": _metric_summary(test),
+ "shuffled_context": _metric_summary(shuffled_context),
+ "checkpoint": str(Path("checkpoints") / name),
+ }
+ if record_timing:
+ record["timing"] = {
+ "train_seconds": result["train_seconds"],
+ "wall_seconds": round(time.perf_counter() - started, 3),
+ "test_rows_per_second": test["rows_per_second"],
+ }
+ print(
+ json.dumps(
+ {
+ "name": name,
+ "parameters": record["parameters"],
+ "test_top1": record["test"]["top1"],
+ "shuffled_context_top1": record["shuffled_context"]["top1"],
+ },
+ sort_keys=True,
+ )
+ )
+ return record
+
+
+def select_best(records: list[dict]) -> dict:
+ if not records:
+ raise ValueError("cannot select a best experiment from an empty result set")
+ return max(
+ records,
+ key=lambda record: (
+ record["best_validation"]["top1"],
+ -record["best_validation"]["nll"],
+ record["name"],
+ ),
+ )
+
+
+def build_manifest(records: list[dict], base_seed: int, deterministic: bool) -> dict:
+ """Build the final selection record from completed experiment results."""
+
+ best = select_best(records)
+ return {
+ "base_seed": base_seed,
+ "deterministic": deterministic,
+ "best": best["name"],
+ "best_checkpoint": "best",
+ "experiments": records,
+ }
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--data", type=Path, default=Path("data/cua-s1"))
+ parser.add_argument("--output", type=Path, default=Path("runs/cua-s1/autoresearch"))
+ parser.add_argument("--ladder", type=Path, help="JSON experiment list")
+ parser.add_argument("--device", default="auto")
+ parser.add_argument("--only", nargs="*", help="run only these experiment names")
+ parser.add_argument("--seed", type=int, default=7)
+ parser.add_argument("--workers", type=int, default=0)
+ parser.add_argument("--non-deterministic", action="store_true")
+ parser.add_argument("--record-timing", action="store_true")
+ args = parser.parse_args()
+
+ ladder = load_ladder(args.ladder)
+ selected = set(args.only or ())
+ available = {experiment["name"] for experiment in ladder}
+ unknown = selected - available
+ if unknown:
+ raise ValueError(f"unknown experiment names: {', '.join(sorted(unknown))}")
+
+ args.output.mkdir(parents=True, exist_ok=True)
+ records: list[dict] = []
+ for experiment in ladder:
+ name = experiment["name"]
+ if selected and name not in selected:
+ continue
+ config = {**BASE_MODEL_CONFIG, **experiment["model"]}
+ records.append(
+ run_experiment(
+ name,
+ config,
+ experiment["training"],
+ args.data,
+ args.output,
+ args.device,
+ _experiment_seed(args.seed, name),
+ args.workers,
+ not args.non_deterministic,
+ args.record_timing,
+ )
+ )
+ _write_json(args.output / "results.json", {"experiments": records})
+
+ best = select_best(records)
+ best_checkpoint = args.output / best["checkpoint"]
+ device = select_device(args.device)
+ model, _, source_config = load_checkpoint(best_checkpoint, device)
+ best_metadata = {
+ "task": "form-specialist-choice-classification",
+ "selected_experiment": best["name"],
+ "selection_metrics": {
+ "validation": best["best_validation"],
+ },
+ "source_checkpoint": best["checkpoint"],
+ "source_config": source_config,
+ }
+ save_checkpoint(
+ args.output / "best",
+ model,
+ best["config"],
+ metadata=best_metadata,
+ )
+ manifest = build_manifest(records, args.seed, not args.non_deterministic)
+ _write_json(args.output / "results.json", manifest)
+ print(
+ json.dumps(
+ {
+ "best": best["name"],
+ "test_top1": best["test"]["top1"],
+ "checkpoint": "best",
+ },
+ sort_keys=True,
+ )
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/libs/cua-s1/training/train.py b/libs/cua-s1/training/train.py
new file mode 100644
index 0000000000..5098d00d27
--- /dev/null
+++ b/libs/cua-s1/training/train.py
@@ -0,0 +1,376 @@
+"""Train and evaluate the Cua-S1 form-specialist choice scorer."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+import time
+from collections import defaultdict
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Callable
+
+import torch
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, Dataset
+
+from cua_s1.model import (
+ ChoiceExample,
+ load_checkpoint,
+ make_system,
+ parameter_count,
+ save_checkpoint,
+ select_device,
+ trainable_state,
+ validate_example,
+)
+from cua_s1.schema import FIXED_ACTIONS
+
+
+class MetaDataset(Dataset):
+ """Validated JSONL choices with action labels retained for metrics."""
+
+ def __init__(self, path: str | Path) -> None:
+ self.path = Path(path)
+ self.examples: list[ChoiceExample] = []
+ self.actions: list[str] = []
+ with self.path.open(encoding="utf-8") as handle:
+ for line_number, line in enumerate(handle, start=1):
+ if not line.strip():
+ continue
+ try:
+ payload = json.loads(line)
+ example = validate_example(payload)
+ except (AttributeError, json.JSONDecodeError, TypeError, ValueError) as error:
+ raise ValueError(f"invalid example at {self.path}:{line_number}") from error
+ self.examples.append(example)
+ metadata = payload.get("meta")
+ action = metadata.get("action") if isinstance(metadata, Mapping) else None
+ self.actions.append(action or action_name(example))
+
+ def __len__(self) -> int:
+ return len(self.examples)
+
+ def __getitem__(self, index: int) -> ChoiceExample:
+ return self.examples[index]
+
+
+def action_name(example: ChoiceExample) -> str:
+ option = example.options[example.label]
+ return option if option in FIXED_ACTIONS else "fill"
+
+
+def move(batch: dict, device: torch.device) -> dict:
+ return {key: value.to(device) for key, value in batch.items()}
+
+
+def _seed_worker(_worker_id: int) -> None:
+ random.seed(torch.initial_seed() % 2**32)
+
+
+def configure_determinism(seed: int, deterministic: bool) -> torch.Generator:
+ """Seed model and loader randomness and configure deterministic kernels."""
+
+ random.seed(seed)
+ torch.manual_seed(seed)
+ if torch.cuda.is_available():
+ torch.cuda.manual_seed_all(seed)
+ torch.use_deterministic_algorithms(deterministic)
+ if hasattr(torch.backends, "cudnn"):
+ torch.backends.cudnn.benchmark = not deterministic
+ torch.backends.cudnn.deterministic = deterministic
+ generator = torch.Generator()
+ generator.manual_seed(seed)
+ return generator
+
+
+def evaluate(
+ model,
+ dataset: MetaDataset,
+ collator,
+ device: torch.device,
+ batch_size: int = 256,
+ shuffle_context: bool = False,
+) -> dict:
+ """Report aggregate, per-action, calibration, and throughput metrics."""
+
+ if not dataset:
+ raise ValueError(f"evaluation dataset is empty: {dataset.path}")
+ if batch_size <= 0:
+ raise ValueError("batch_size must be positive")
+ model.eval()
+ loader = DataLoader(dataset, batch_size=batch_size, collate_fn=collator)
+ per_action: dict[str, list[int]] = defaultdict(lambda: [0, 0])
+ confidences: list[torch.Tensor] = []
+ corrects: list[torch.Tensor] = []
+ nll_total = 0.0
+ offset = 0
+ start = time.perf_counter()
+ for host_batch in loader:
+ batch = move(host_batch, device)
+ logits = model(batch, shuffle_context=shuffle_context)
+ nll_total += float(F.cross_entropy(logits, batch["labels"], reduction="sum"))
+ probabilities = logits.softmax(-1)
+ confidence, prediction = probabilities.max(-1)
+ correct = prediction.eq(batch["labels"])
+ for row_index in range(correct.shape[0]):
+ action = dataset.actions[offset + row_index]
+ per_action[action][0] += int(correct[row_index])
+ per_action[action][1] += 1
+ offset += correct.shape[0]
+ confidences.append(confidence.cpu())
+ corrects.append(correct.cpu())
+
+ elapsed = max(time.perf_counter() - start, 1e-12)
+ confidence = torch.cat(confidences)
+ correct = torch.cat(corrects).float()
+ expected_calibration_error = 0.0
+ for lower_bound in torch.linspace(0, 0.9, 10):
+ selected = (confidence >= lower_bound) & (confidence < lower_bound + 0.1)
+ if selected.any():
+ expected_calibration_error += float(
+ selected.float().mean()
+ * (correct[selected].mean() - confidence[selected].mean()).abs()
+ )
+ example_count = len(dataset)
+ return {
+ "top1": float(correct.mean()),
+ "nll": nll_total / example_count,
+ "ece": expected_calibration_error,
+ "examples": example_count,
+ "per_action": {
+ action: {"acc": correct_count / total, "n": total}
+ for action, (correct_count, total) in sorted(per_action.items())
+ },
+ "rows_per_second": example_count / elapsed,
+ }
+
+
+def _stable_metrics(metrics: dict) -> dict:
+ return {key: value for key, value in metrics.items() if key != "rows_per_second"}
+
+
+def _clone_trainable_state(model) -> dict[str, torch.Tensor]:
+ return {key: value.detach().cpu().clone() for key, value in trainable_state(model).items()}
+
+
+def train(
+ config: dict,
+ train_path: str | Path,
+ validation_path: str | Path,
+ output: str | Path,
+ *,
+ epochs: int = 10,
+ batch_size: int = 128,
+ learning_rate: float = 2e-3,
+ seed: int = 7,
+ device_name: str = "auto",
+ warmup: float = 0.05,
+ workers: int = 0,
+ deterministic: bool = True,
+ log: Callable[[str], None] = print,
+) -> dict:
+ """Train from scratch and save the best validation checkpoint safely."""
+
+ if epochs <= 0 or batch_size <= 0:
+ raise ValueError("epochs and batch_size must be positive")
+ if learning_rate <= 0:
+ raise ValueError("learning_rate must be positive")
+ if warmup < 0 or warmup > 1:
+ raise ValueError("warmup must be between 0 and 1")
+ if workers < 0:
+ raise ValueError("workers must be non-negative")
+
+ loader_generator = configure_determinism(seed, deterministic)
+ device = select_device(device_name)
+ model, collator = make_system(config, device)
+ train_set = MetaDataset(train_path)
+ validation_set = MetaDataset(validation_path)
+ if not train_set:
+ raise ValueError(f"training dataset is empty: {train_set.path}")
+ if not validation_set:
+ raise ValueError(f"validation dataset is empty: {validation_set.path}")
+
+ loader = DataLoader(
+ train_set,
+ batch_size=batch_size,
+ shuffle=True,
+ collate_fn=collator,
+ drop_last=False,
+ num_workers=workers,
+ persistent_workers=workers > 0,
+ generator=loader_generator,
+ worker_init_fn=_seed_worker if workers else None,
+ )
+ parameters = [parameter for parameter in model.parameters() if parameter.requires_grad]
+ if not parameters:
+ raise ValueError("model has no trainable parameters")
+ optimizer = torch.optim.AdamW(parameters, lr=learning_rate, weight_decay=1e-2)
+ total_steps = epochs * len(loader)
+ warmup_steps = int(total_steps * warmup)
+
+ def learning_rate_multiplier(step: int) -> float:
+ if warmup_steps and step < warmup_steps:
+ return (step + 1) / warmup_steps
+ progress = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+ return 0.5 * (1 + math.cos(math.pi * min(progress, 1.0)))
+
+ scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, learning_rate_multiplier)
+ best_validation: dict = {"nll": float("inf")}
+ best_state: dict[str, torch.Tensor] | None = None
+ history: list[dict] = []
+ started = time.perf_counter()
+
+ for epoch in range(epochs):
+ model.train()
+ total_loss = 0.0
+ example_count = 0
+ for host_batch in loader:
+ batch = move(host_batch, device)
+ loss = F.cross_entropy(model(batch), batch["labels"])
+ optimizer.zero_grad(set_to_none=True)
+ loss.backward()
+ torch.nn.utils.clip_grad_norm_(parameters, 1.0)
+ optimizer.step()
+ scheduler.step()
+ batch_examples = batch["labels"].numel()
+ total_loss += float(loss.detach()) * batch_examples
+ example_count += batch_examples
+
+ validation = evaluate(model, validation_set, collator, device)
+ stable_validation = _stable_metrics(validation)
+ record = {
+ "epoch": epoch + 1,
+ "train_nll": total_loss / example_count,
+ "validation": stable_validation,
+ }
+ history.append(record)
+ log(json.dumps(record, sort_keys=True))
+ if stable_validation["nll"] < best_validation["nll"]:
+ best_validation = stable_validation
+ best_state = _clone_trainable_state(model)
+
+ if best_state is None:
+ raise RuntimeError("training completed without a validation checkpoint")
+ model.load_state_dict(best_state, strict=False)
+ training_metadata = {
+ "task": "form-specialist-choice-classification",
+ "seed": seed,
+ "deterministic": deterministic,
+ "epochs": epochs,
+ "batch_size": batch_size,
+ "learning_rate": learning_rate,
+ "warmup": warmup,
+ "workers": workers,
+ "history": history,
+ "best_validation": best_validation,
+ }
+ output_path = Path(output)
+ save_checkpoint(output_path, model, config, metadata=training_metadata)
+ return {
+ "checkpoint": str(output_path),
+ "best_validation": best_validation,
+ "parameters": parameter_count(model),
+ "history": history,
+ "train_seconds": round(time.perf_counter() - started, 3),
+ }
+
+
+def _model_config(args: argparse.Namespace) -> dict:
+ return {
+ "encoder": args.encoder,
+ "width": args.width,
+ "rank": args.rank,
+ "layers": args.layers,
+ "heads": args.heads,
+ "context_tokens": args.context_tokens,
+ "option_tokens": args.option_tokens,
+ }
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(description=__doc__)
+ commands = parser.add_subparsers(dest="command", required=True)
+ train_parser = commands.add_parser("train")
+ train_parser.add_argument("train")
+ train_parser.add_argument("--validation", required=True)
+ train_parser.add_argument("--output", type=Path, default=Path("runs/cua-s1/model"))
+ train_parser.add_argument("--encoder", choices=("tiny", "tinyx"), default="tinyx")
+ train_parser.add_argument("--width", type=int, default=128)
+ train_parser.add_argument("--rank", type=int, default=128)
+ train_parser.add_argument("--layers", type=int, default=2)
+ train_parser.add_argument("--heads", type=int, default=4)
+ train_parser.add_argument("--context-tokens", type=int, default=224)
+ train_parser.add_argument("--option-tokens", type=int, default=96)
+ train_parser.add_argument("--epochs", type=int, default=10)
+ train_parser.add_argument("--batch-size", type=int, default=128)
+ train_parser.add_argument("--learning-rate", type=float, default=2e-3)
+ train_parser.add_argument("--warmup", type=float, default=0.05)
+ train_parser.add_argument("--workers", type=int, default=0)
+ train_parser.add_argument("--device", default="auto")
+ train_parser.add_argument("--seed", type=int, default=7)
+ train_parser.add_argument("--non-deterministic", action="store_true")
+
+ eval_parser = commands.add_parser("eval")
+ eval_parser.add_argument("checkpoint", type=Path)
+ eval_parser.add_argument("data", type=Path)
+ eval_parser.add_argument("--batch-size", type=int, default=256)
+ eval_parser.add_argument("--device", default="auto")
+ args = parser.parse_args()
+
+ if args.command == "train":
+ result = train(
+ _model_config(args),
+ args.train,
+ args.validation,
+ args.output,
+ epochs=args.epochs,
+ batch_size=args.batch_size,
+ learning_rate=args.learning_rate,
+ seed=args.seed,
+ device_name=args.device,
+ warmup=args.warmup,
+ workers=args.workers,
+ deterministic=not args.non_deterministic,
+ )
+ print(
+ json.dumps(
+ {
+ key: value
+ for key, value in result.items()
+ if key not in {"history", "train_seconds"}
+ },
+ indent=2,
+ sort_keys=True,
+ )
+ )
+ return
+
+ device = select_device(args.device)
+ model, collator, checkpoint_config = load_checkpoint(args.checkpoint, device)
+ dataset = MetaDataset(args.data)
+ print(
+ json.dumps(
+ {
+ "checkpoint_config": checkpoint_config,
+ "model": evaluate(model, dataset, collator, device, batch_size=args.batch_size),
+ "shuffled_context": evaluate(
+ model,
+ dataset,
+ collator,
+ device,
+ batch_size=args.batch_size,
+ shuffle_context=True,
+ ),
+ },
+ indent=2,
+ sort_keys=True,
+ )
+ )
+
+
+if __name__ == "__main__":
+ main()