Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
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.ymlnew file mode 100644index 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+ PYdiff --git a/libs/cua-s1/.gitignore b/libs/cua-s1/.gitignorenew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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__.pynew file mode 100644index 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.pynew file mode 100644index 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/LICENSEnew file mode 100644index 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.tomlnew file mode 100644index 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__.pynew file mode 100644index 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.pynew file mode 100644index 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, metadatadiff --git a/libs/cua-s1/python/src/cua_s1/concepts.py b/libs/cua-s1/python/src/cua_s1/concepts.pynew file mode 100644index 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"],+ placeholder=("[email protected]", "[email protected]"),+ 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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_entitiesdiff --git a/libs/cua-s1/python/src/cua_s1/planner.py b/libs/cua-s1/python/src/cua_s1/planner.pynew file mode 100644index 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.pynew file mode 100644index 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 excdiff --git a/libs/cua-s1/python/src/cua_s1/server.py b/libs/cua-s1/python/src/cua_s1/server.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 Truediff --git a/libs/cua-s1/python/tests/test_schema.py b/libs/cua-s1/python/tests/test_schema.pynew file mode 100644index 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")) < 400diff --git a/libs/cua-s1/python/tests/test_server.py b/libs/cua-s1/python/tests/test_server.pynew file mode 100644index 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.pynew file mode 100644index 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.locknew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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++[email protected]_grad()+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()