From 96d4d08230b2f2c80a31f0308d7e5a918cb70cff Mon Sep 17 00:00:00 2001 From: Alexander Baranov Date: Mon, 24 Aug 2026 14:57:34 +0300 Subject: [PATCH] feat: implement repoctl L1 core (models, schemas, validate, discover, context, init, adopt) Adds the repository-stewardship Python package (src/stewardship) with: - JSON Schemas (Draft 2020-12) for RepositoryContract, KnowledgeBase, CatalogIndex, ContextBundle, BootstrapPlan, AdoptionAssessment/Plan/Report, user config and the repoctl-result envelope. - Safe YAML I/O, path confinement, deterministic clock and canonical-JSON hashing. - validate: schema, ID uniqueness, path safety, KDB references, freshness, secret-shaped fields, shell-string detection, and Markdown frontmatter/fence/link checks. - discover/CatalogIndex with deterministic sorting and duplicate-name detection. - describe (contract-only) and context (intent-scoped ContextBundle with budgeted materialization and --strict truncation). - init: plan-then-apply bootstrap with SHA-256 plan-hash approval, no fake domain artifacts, bundled Claude skills. - adopt: assess/plan/apply/verify overlay workflow per docs/adoption-runbook.md, preserving legacy content roots and KDB, with baseline-hash re-check and rollback. - argparse-based `repoctl` CLI with human/yaml/json output and spec exit codes. - pytest suite (39 tests) covering positive/negative fixtures, discovery, context, bootstrap and adoption (including LXD- and Antivirus-shaped legacy layouts). Managed with uv (.venv), ruff clean, mypy --strict clean. Co-Authored-By: Claude Sonnet 5 --- pyproject.toml | 41 ++ src/stewardship/__init__.py | 3 + src/stewardship/adoption.py | 396 ++++++++++++++ src/stewardship/bootstrap.py | 235 ++++++++ src/stewardship/cli.py | 334 ++++++++++++ src/stewardship/clock.py | 20 + src/stewardship/config.py | 75 +++ src/stewardship/constants.py | 19 + src/stewardship/context.py | 149 +++++ src/stewardship/discovery.py | 151 ++++++ src/stewardship/gitutil.py | 35 ++ src/stewardship/io.py | 86 +++ src/stewardship/markdown.py | 176 ++++++ src/stewardship/paths.py | 51 ++ src/stewardship/render.py | 48 ++ src/stewardship/schema_loader.py | 83 +++ .../schemas/adoption-assessment.schema.json | 84 +++ .../schemas/adoption-plan.schema.json | 44 ++ .../schemas/adoption-report.schema.json | 18 + .../schemas/bootstrap-plan.schema.json | 29 + .../schemas/catalog-index.schema.json | 55 ++ .../schemas/context-bundle.schema.json | 36 ++ .../schemas/knowledge-base.schema.json | 91 ++++ .../schemas/repository-contract.schema.json | 176 ++++++ .../schemas/result-envelope.schema.json | 29 + .../schemas/user-config.schema.json | 12 + src/stewardship/skills_content.py | 82 +++ src/stewardship/types.py | 24 + src/stewardship/validate.py | 416 ++++++++++++++ tests/conftest.py | 48 ++ .../adoption/antivirus-legacy/kdb/kdb.yaml | 2 + .../antivirus-legacy/policies/.gitkeep | 0 tests/fixtures/adoption/lxd-legacy/kdb.yaml | 2 + .../lxd-legacy/profiles-source/default.yaml | 2 + .../adoption/lxd-legacy/profiles/default.yaml | 2 + .../negative/absolute-path/contract.yaml | 15 + .../negative/duplicate-ids/contract.yaml | 20 + .../negative/path-traversal/contract.yaml | 15 + .../negative/secret-field/contract.yaml | 11 + .../negative/shell-string/contract.yaml | 18 + .../negative/unknown-field/contract.yaml | 10 + tests/fixtures/positive/infra-lxd/AGENTS.md | 3 + tests/fixtures/positive/infra-lxd/CLAUDE.md | 3 + .../infra-lxd/kdb/container-deployment.md | 3 + .../fixtures/positive/infra-lxd/kdb/kdb.yaml | 22 + .../positive/infra-lxd/ops/contract.yaml | 46 ++ .../infra-lxd/profiles-source/default.yaml | 2 + .../positive/infra-lxd/profiles/default.yaml | 2 + .../positive/project-example/AGENTS.md | 3 + .../positive/project-example/CLAUDE.md | 3 + .../project-example/decisions/adr-0001.md | 3 + .../deliverables/deliverable-1.md | 3 + .../positive/project-example/kdb/kdb.yaml | 9 + .../project-example/ops/contract.yaml | 30 + .../positive/service-antivirus/AGENTS.md | 3 + .../positive/service-antivirus/CLAUDE.md | 3 + .../service-antivirus/acceptance/.gitkeep | 0 .../positive/service-antivirus/kdb/kdb.yaml | 9 + .../service-antivirus/ops/contract.yaml | 46 ++ .../service-antivirus/policies/.gitkeep | 0 .../positive/software-example/AGENTS.md | 3 + .../positive/software-example/CLAUDE.md | 3 + .../positive/software-example/kdb/kdb.yaml | 9 + .../software-example/ops/contract.yaml | 30 + .../positive/software-example/src/main.py | 1 + .../software-example/tests/test_main.py | 2 + tests/test_adoption.py | 91 ++++ tests/test_bootstrap.py | 51 ++ tests/test_cli.py | 41 ++ tests/test_context.py | 35 ++ tests/test_discovery.py | 64 +++ tests/test_schema.py | 32 ++ tests/test_validate_negative.py | 23 + tests/test_validate_positive.py | 27 + uv.lock | 511 ++++++++++++++++++ 75 files changed, 4259 insertions(+) create mode 100644 pyproject.toml create mode 100644 src/stewardship/__init__.py create mode 100644 src/stewardship/adoption.py create mode 100644 src/stewardship/bootstrap.py create mode 100644 src/stewardship/cli.py create mode 100644 src/stewardship/clock.py create mode 100644 src/stewardship/config.py create mode 100644 src/stewardship/constants.py create mode 100644 src/stewardship/context.py create mode 100644 src/stewardship/discovery.py create mode 100644 src/stewardship/gitutil.py create mode 100644 src/stewardship/io.py create mode 100644 src/stewardship/markdown.py create mode 100644 src/stewardship/paths.py create mode 100644 src/stewardship/render.py create mode 100644 src/stewardship/schema_loader.py create mode 100644 src/stewardship/schemas/adoption-assessment.schema.json create mode 100644 src/stewardship/schemas/adoption-plan.schema.json create mode 100644 src/stewardship/schemas/adoption-report.schema.json create mode 100644 src/stewardship/schemas/bootstrap-plan.schema.json create mode 100644 src/stewardship/schemas/catalog-index.schema.json create mode 100644 src/stewardship/schemas/context-bundle.schema.json create mode 100644 src/stewardship/schemas/knowledge-base.schema.json create mode 100644 src/stewardship/schemas/repository-contract.schema.json create mode 100644 src/stewardship/schemas/result-envelope.schema.json create mode 100644 src/stewardship/schemas/user-config.schema.json create mode 100644 src/stewardship/skills_content.py create mode 100644 src/stewardship/types.py create mode 100644 src/stewardship/validate.py create mode 100644 tests/conftest.py create mode 100644 tests/fixtures/adoption/antivirus-legacy/kdb/kdb.yaml create mode 100644 tests/fixtures/adoption/antivirus-legacy/policies/.gitkeep create mode 100644 tests/fixtures/adoption/lxd-legacy/kdb.yaml create mode 100644 tests/fixtures/adoption/lxd-legacy/profiles-source/default.yaml create mode 100644 tests/fixtures/adoption/lxd-legacy/profiles/default.yaml create mode 100644 tests/fixtures/negative/absolute-path/contract.yaml create mode 100644 tests/fixtures/negative/duplicate-ids/contract.yaml create mode 100644 tests/fixtures/negative/path-traversal/contract.yaml create mode 100644 tests/fixtures/negative/secret-field/contract.yaml create mode 100644 tests/fixtures/negative/shell-string/contract.yaml create mode 100644 tests/fixtures/negative/unknown-field/contract.yaml create mode 100644 tests/fixtures/positive/infra-lxd/AGENTS.md create mode 100644 tests/fixtures/positive/infra-lxd/CLAUDE.md create mode 100644 tests/fixtures/positive/infra-lxd/kdb/container-deployment.md create mode 100644 tests/fixtures/positive/infra-lxd/kdb/kdb.yaml create mode 100644 tests/fixtures/positive/infra-lxd/ops/contract.yaml create mode 100644 tests/fixtures/positive/infra-lxd/profiles-source/default.yaml create mode 100644 tests/fixtures/positive/infra-lxd/profiles/default.yaml create mode 100644 tests/fixtures/positive/project-example/AGENTS.md create mode 100644 tests/fixtures/positive/project-example/CLAUDE.md create mode 100644 tests/fixtures/positive/project-example/decisions/adr-0001.md create mode 100644 tests/fixtures/positive/project-example/deliverables/deliverable-1.md create mode 100644 tests/fixtures/positive/project-example/kdb/kdb.yaml create mode 100644 tests/fixtures/positive/project-example/ops/contract.yaml create mode 100644 tests/fixtures/positive/service-antivirus/AGENTS.md create mode 100644 tests/fixtures/positive/service-antivirus/CLAUDE.md create mode 100644 tests/fixtures/positive/service-antivirus/acceptance/.gitkeep create mode 100644 tests/fixtures/positive/service-antivirus/kdb/kdb.yaml create mode 100644 tests/fixtures/positive/service-antivirus/ops/contract.yaml create mode 100644 tests/fixtures/positive/service-antivirus/policies/.gitkeep create mode 100644 tests/fixtures/positive/software-example/AGENTS.md create mode 100644 tests/fixtures/positive/software-example/CLAUDE.md create mode 100644 tests/fixtures/positive/software-example/kdb/kdb.yaml create mode 100644 tests/fixtures/positive/software-example/ops/contract.yaml create mode 100644 tests/fixtures/positive/software-example/src/main.py create mode 100644 tests/fixtures/positive/software-example/tests/test_main.py create mode 100644 tests/test_adoption.py create mode 100644 tests/test_bootstrap.py create mode 100644 tests/test_cli.py create mode 100644 tests/test_context.py create mode 100644 tests/test_discovery.py create mode 100644 tests/test_schema.py create mode 100644 tests/test_validate_negative.py create mode 100644 tests/test_validate_positive.py create mode 100644 uv.lock diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..c8e404e --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,41 @@ +[project] +name = "repository-stewardship" +version = "0.1.0" +description = "Repository Stewardship contracts, catalog and CLI" +readme = "README.md" +requires-python = ">=3.11" +classifiers = ["Private :: Do Not Upload"] +dependencies = [ + "jsonschema>=4.25,<5", + "ruamel.yaml>=0.19,<0.20", +] + +[project.scripts] +repoctl = "stewardship.cli:main" + +[dependency-groups] +dev = [ + "mypy>=1.18,<2", + "pytest>=8.4,<9", + "ruff>=0.12,<1", + "types-jsonschema>=4.26.0.20260518", +] + +[build-system] +requires = ["uv_build>=0.12.5,<0.13"] +build-backend = "uv_build" + +[tool.uv.build-backend] +module-name = "stewardship" + +[tool.pytest.ini_options] +testpaths = ["tests"] + +[tool.ruff] +line-length = 100 +target-version = "py311" + +[tool.mypy] +python_version = "3.11" +strict = true +warn_unused_ignores = true diff --git a/src/stewardship/__init__.py b/src/stewardship/__init__.py new file mode 100644 index 0000000..03a2e19 --- /dev/null +++ b/src/stewardship/__init__.py @@ -0,0 +1,3 @@ +"""Repository Stewardship protocol implementation.""" + +__version__ = "0.1.0" diff --git a/src/stewardship/adoption.py b/src/stewardship/adoption.py new file mode 100644 index 0000000..88534d6 --- /dev/null +++ b/src/stewardship/adoption.py @@ -0,0 +1,396 @@ +"""`repoctl adopt`: assess -> plan -> apply -> verify for an existing repository. + +Follows docs/adoption-runbook.md. Default strategy is `overlay`: it only adds +stewardship metadata and never moves, deletes or renames existing files. The +`documents-to-content-root` normalization recipe is a separate, explicitly opted-in +path (not implemented as an automatic heuristic) and is intentionally out of scope +for this first cut beyond structural support in the AdoptionPlan schema. +""" + +from __future__ import annotations + +import fnmatch +from pathlib import Path +from typing import Any + +from . import gitutil, io +from .bootstrap import BootstrapAnswers, render_agents_md, render_claude_md +from .constants import API_VERSION +from .validate import validate_repository + +_COLLISION_PATHS = [ + "ops/contract.yaml", + "kdb/kdb.yaml", + "kdb.yaml", + "CLAUDE.md", + "AGENTS.md", + ".claude/skills", + ".agents/skills", + "ops/handlers", + "ops/template-answers.yaml", +] + +_SECRET_SHAPED_GLOBS = [ + "*.pem", "*.key", "id_rsa", "id_ed25519", "id_ecdsa", "id_dsa", + ".env", ".env.*", "*.env", "*password*", "*secret*", "*.pfx", "*.p12", +] +_SECRET_EXCLUDE_SUFFIXES = (".pub", ".schema.json", ".example") + +_TYPE_EVIDENCE: list[tuple[str, list[str]]] = [ + ("infrastructure-config", ["profiles-source", "profiles", "inventory", "stacks", "terraform", "ansible"]), + ("service-config", ["policies", "acceptance", "runbooks", "deployments"]), + ("software", ["src", "pyproject.toml", "package.json", "go.mod", "Cargo.toml"]), + ("project", ["deliverables", "docs", "decisions"]), +] + + +def _finding(severity: str, code: str, path: str | None = None, message: str | None = None) -> dict[str, Any]: + item: dict[str, Any] = {"severity": severity, "code": code} + if path: + item["path"] = path + if message: + item["message"] = message + return item + + +def _detect_secret_shaped_paths(root: Path) -> list[tuple[str, bool]]: + """Return (relative_path, is_tracked) for files matching secret-shaped name patterns.""" + tracked = gitutil.tracked_files(root) + found: list[tuple[str, bool]] = [] + for path in root.rglob("*"): + if not path.is_file(): + continue + if ".git" in path.parts or ".venv" in path.parts or "node_modules" in path.parts: + continue + name = path.name + if name.lower().endswith(_SECRET_EXCLUDE_SUFFIXES): + continue + if any(fnmatch.fnmatch(name.lower(), pattern) for pattern in _SECRET_SHAPED_GLOBS): + rel = path.relative_to(root).as_posix() + found.append((rel, rel in tracked)) + return found + + +def _classify_type(root: Path) -> tuple[str, str, list[str]]: + scores: dict[str, list[str]] = {t: [] for t, _ in _TYPE_EVIDENCE} + for repo_type, markers in _TYPE_EVIDENCE: + for marker in markers: + if (root / marker).exists(): + scores[repo_type].append(marker) + ranked = sorted(scores.items(), key=lambda kv: -len(kv[1])) + best_type, best_evidence = ranked[0] + second_count = len(ranked[1][1]) if len(ranked) > 1 else 0 + if not best_evidence: + return "project", "low", [] + if len(best_evidence) >= 2 and len(best_evidence) > second_count: + confidence = "high" + elif len(best_evidence) > second_count: + confidence = "medium" + else: + confidence = "low" + return best_type, confidence, best_evidence + + +def assess(root: Path) -> dict[str, Any]: + head = gitutil.head_revision(root) + dirty = gitutil.is_dirty(root) + + proposed_type, confidence, evidence = _classify_type(root) + + claude_exists = (root / "CLAUDE.md").exists() + agents_exists = (root / "AGENTS.md").exists() + canonical_direction = "none" + findings: list[dict[str, Any]] = [] + if claude_exists and agents_exists: + claude_text = (root / "CLAUDE.md").read_text(encoding="utf-8", errors="ignore") + if "AGENTS.md" in claude_text: + canonical_direction = "claude-imports-agents" + else: + agents_text = (root / "AGENTS.md").read_text(encoding="utf-8", errors="ignore") + if "CLAUDE.md" in agents_text: + canonical_direction = "legacy-agents-to-claude" + findings.append(_finding("warning", "ADOPT_ENTRYPOINT_DIRECTION_LEGACY", "AGENTS.md")) + else: + canonical_direction = "independent" + elif claude_exists: + canonical_direction = "claude-only" + elif agents_exists: + canonical_direction = "agents-only" + + knowledge: list[dict[str, Any]] = [] + if (root / "kdb" / "kdb.yaml").exists(): + knowledge.append({"path": "kdb/kdb.yaml", "format": "stewardship-yaml", "action": "keep-or-validate"}) + elif (root / "kdb.yaml").exists(): + knowledge.append({"path": "kdb.yaml", "format": "legacy-yaml", "action": "wrap"}) + findings.append(_finding("info", "ADOPT_KDB_LEGACY", "kdb.yaml")) + if (root / "ops" / "knowledge.yaml").exists(): + knowledge.append({"path": "ops/knowledge.yaml", "format": "stewardship-yaml", "action": "keep-or-validate"}) + + proposed_content_roots: list[dict[str, Any]] = [] + for repo_type, markers in _TYPE_EVIDENCE: + if repo_type != proposed_type: + continue + for marker in markers: + candidate = root / marker + if candidate.is_dir(): + proposed_content_roots.append( + {"id": marker.replace("/", "-").lower(), "path": marker, "role": marker, "authority": "source"} + ) + + collisions: list[str] = [] + for rel in _COLLISION_PATHS: + if (root / rel).exists(): + collisions.append(rel) + if (root / "kdb" / "kdb.yaml").exists() and (root / "kdb.yaml").exists(): + findings.append(_finding("warning", "ADOPT_KDB_CANONICAL_PATH_OCCUPIED", "kdb/kdb.yaml")) + + for rel, tracked in _detect_secret_shaped_paths(root): + if tracked: + findings.append(_finding("error", "ADOPT_SECRET_TRACKED", rel, "Tracked path matches a secret-shaped filename pattern")) + else: + findings.append(_finding("info", "ADOPT_SECRET_TRACKED", rel, "Untracked secret-shaped path (path only, content not read)")) + + if dirty: + findings.append(_finding("warning", "ADOPT_WORKTREE_DIRTY")) + + questions: list[str] = [] + confirmation_required = confidence != "high" + if confirmation_required: + questions.append("Confirm repository type and confidence evidence") + questions.append("Confirm owner(s) and lifecycle") + + return { + "schema": "stewardship/adoption-assessment@0.1", + "repository": {"path": str(root), "baselineRevision": head, "dirty": dirty}, + "classification": { + "proposedType": proposed_type, + "confidence": confidence, + "evidence": evidence, + "confirmationRequired": confirmation_required, + }, + "entrypoints": { + "claude": "CLAUDE.md" if claude_exists else None, + "portable": "AGENTS.md" if agents_exists else None, + "canonicalDirection": canonical_direction, + }, + "knowledge": knowledge, + "proposedContentRoots": proposed_content_roots, + "collisions": collisions, + "findings": findings, + "questions": questions, + } + + +def build_plan( + root: Path, + assessment: dict[str, Any], + *, + confirmed_name: str, + confirmed_title: str | None = None, + confirmed_owners: list[str] | None = None, + confirmed_lifecycle: str = "active", + strategy: str = "overlay", +) -> dict[str, Any]: + if strategy != "overlay": + raise ValueError("Only the overlay strategy is implemented; normalize requires an explicit recipe run") + + baseline = assessment["repository"]["baselineRevision"] + changes: list[dict[str, Any]] = [] + forbidden: list[str] = [] + + contract_exists = (root / "ops/contract.yaml").exists() + content_roots = [ + { + "id": cr["id"], + "role": cr["role"], + "path": cr["path"], + "kind": "directory", + "authority": cr.get("authority", "source"), + "writePolicy": "managed", + } + for cr in assessment.get("proposedContentRoots", []) + ] + for cr in content_roots: + forbidden.append(f"{cr['path']}/**") + + if not contract_exists: + contract = { + "apiVersion": API_VERSION, + "kind": "RepositoryContract", + "metadata": { + "name": confirmed_name, + "title": confirmed_title or confirmed_name, + "owners": confirmed_owners or [], + }, + "spec": { + "summary": f"Adopted repository {confirmed_name}", + "repository": { + "type": assessment["classification"]["proposedType"], + "lifecycle": confirmed_lifecycle, + }, + "template": { + "id": "repository." + assessment["classification"]["proposedType"].split("-")[0], + "version": "0.1.0", + "source": "repo:repository-stewardship", + "mode": "adopted-overlay", + "managedPaths": ["ops/contract.yaml"], + }, + "agent": {"primary": "CLAUDE.md", "portable": "AGENTS.md"}, + "knowledge": {"entrypoint": _knowledge_entrypoint(assessment)}, + "contentRoots": content_roots, + }, + } + changes.append({"action": "create", "path": "ops/contract.yaml", "ownership": "stewardship", "content": io.yaml_text(contract)}) + else: + changes.append({"action": "preserve", "path": "ops/contract.yaml", "ownership": "repository"}) + + kdb_entries = assessment.get("knowledge", []) + kdb_paths = {entry["path"] for entry in kdb_entries} + if "kdb/kdb.yaml" not in kdb_paths: + legacy = next((e for e in kdb_entries if e["action"] == "wrap"), None) + kdb: dict[str, Any] = { + "apiVersion": API_VERSION, + "kind": "KnowledgeBase", + "metadata": {"name": f"{confirmed_name}-knowledge-index"}, + "spec": { + "repository": f"repo:{confirmed_name}", + "defaultLanguage": "en", + "topics": [], + "documents": [], + }, + } + target_kdb_path = "kdb/kdb.yaml" + if legacy: + kdb["spec"]["documents"].append( + { + "id": "legacy-knowledge-base", + "title": "Existing knowledge base", + "role": "reference", + "path": legacy["path"], + "mediaType": "application/yaml", + "authority": "local-canonical", + "status": "verified", + } + ) + forbidden.append(legacy["path"]) + changes.append({"action": "create", "path": target_kdb_path, "ownership": "stewardship", "reason": "Compatibility index for legacy knowledge base" if legacy else "Minimal KDB", "content": io.yaml_text(kdb)}) + else: + changes.append({"action": "preserve", "path": "kdb/kdb.yaml", "ownership": "repository"}) + + if not (root / "AGENTS.md").exists(): + answers = BootstrapAnswers( + name=confirmed_name, title=confirmed_title or confirmed_name, owners=confirmed_owners or [], + repository_type=assessment["classification"]["proposedType"], lifecycle=confirmed_lifecycle, + ) + changes.append({"action": "create", "path": "AGENTS.md", "ownership": "shared", "content": render_agents_md(answers)}) + else: + changes.append({"action": "preserve", "path": "AGENTS.md", "ownership": "repository"}) + + if not (root / "CLAUDE.md").exists(): + changes.append({"action": "create", "path": "CLAUDE.md", "ownership": "shared", "content": render_claude_md()}) + else: + changes.append({"action": "preserve", "path": "CLAUDE.md", "ownership": "repository"}) + + preserved_already = {c["path"] for c in changes if c["action"] == "preserve"} + for rel in ("kdb.yaml", "profiles-source", "profiles"): + if (root / rel).exists() and rel not in preserved_already: + changes.append({"action": "preserve", "path": rel, "ownership": "repository"}) + preserved_already.add(rel) + + forbidden.append(".ssh/**") + + plan: dict[str, Any] = { + "schema": "stewardship/adoption-plan@0.1", + "repository": f"repo:{confirmed_name}", + "baselineRevision": baseline, + "strategy": strategy, + "changes": changes, + "forbiddenChanges": sorted(set(forbidden)), + "validations": [ + "stewardship-schema", + "path-confinement", + "knowledge-references", + "agent-entrypoint-cycle", + ], + "approval": {"required": True}, + } + plan_hash = io.sha256({k: v for k, v in plan.items() if k != "planHash"}) + plan["planHash"] = plan_hash + return plan + + +def _knowledge_entrypoint(assessment: dict[str, Any]) -> str: + for entry in assessment.get("knowledge", []): + if entry["path"] == "kdb/kdb.yaml": + return "kdb/kdb.yaml" + return "kdb/kdb.yaml" + + +def apply_plan(root: Path, plan: dict[str, Any], approve_hash: str) -> list[str]: + expected_hash = io.sha256({k: v for k, v in plan.items() if k != "planHash"}) + if expected_hash != plan.get("planHash"): + raise ValueError("Plan hash does not match plan content; re-plan before apply") + if approve_hash != plan["planHash"]: + raise ValueError("Approval hash does not match plan hash") + + current_head = gitutil.head_revision(root) + if current_head != plan["baselineRevision"]: + raise ValueError("ADOPT_BASELINE_CHANGED: baseline revision changed since plan was built; re-plan") + + to_write = [c for c in plan["changes"] if c["action"] in ("create", "patch-managed-block")] + for change in to_write: + target = root / change["path"] + if change["action"] == "create" and target.exists(): + raise FileExistsError(f"ADOPT_PATH_COLLISION: refusing to overwrite existing path: {change['path']}") + + written: list[str] = [] + backups: dict[str, bytes | None] = {} + try: + for change in to_write: + target = root / change["path"] + backups[change["path"]] = target.read_bytes() if target.exists() else None + io.write_text_atomic(target, change["content"]) + written.append(change["path"]) + except Exception: + for rel, original in backups.items(): + target = root / rel + if original is None: + if target.exists() and rel in written: + target.unlink() + else: + target.write_bytes(original) + raise + return written + + +def verify(root: Path, plan: dict[str, Any] | None = None) -> dict[str, Any]: + validation = validate_repository(root) + baseline = gitutil.head_revision(root) + + changed_paths: list[str] = [] + preserved_paths: list[str] = [] + if plan is not None: + for change in plan["changes"]: + if change["action"] in ("create", "patch-managed-block"): + changed_paths.append(change["path"]) + elif change["action"] == "preserve": + preserved_paths.append(change["path"]) + + unresolved = sorted({f.code for f in validation.findings if f.severity in ("warning", "error")}) + if any(f.severity == "error" for f in validation.findings): + outcome = "fail" + elif unresolved: + outcome = "pass-with-warnings" + else: + outcome = "pass" + + return { + "schema": "stewardship/adoption-report@0.1", + "repository": f"repo:{(validation.contract or {}).get('metadata', {}).get('name', 'unknown')}", + "baselineRevision": baseline, + "compatibilityLevel": "L1", + "outcome": outcome, + "changedPaths": sorted(set(changed_paths)), + "preservedPaths": sorted(set(preserved_paths)), + "unresolvedFindings": unresolved, + } diff --git a/src/stewardship/bootstrap.py b/src/stewardship/bootstrap.py new file mode 100644 index 0000000..1781a8a --- /dev/null +++ b/src/stewardship/bootstrap.py @@ -0,0 +1,235 @@ +"""`repoctl init`: plan-then-apply bootstrap of a new repository. + +Content roots are declared in the contract but their directories are not created — +this repository's self-hosting rule forbids placeholder directories and fictional +domain artifacts. `init` never commits, pushes or creates a remote. +""" + +from __future__ import annotations + +import subprocess +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from . import io +from .clock import DEFAULT_CLOCK +from .constants import API_VERSION +from .skills_content import ( + REPO_HANDOFF_SKILL, + REPOSITORY_ADOPTION_SKILL, + REPOSITORY_BOOTSTRAP_SKILL, +) + +TEMPLATE_IDS = { + "infrastructure-config": "repository.infrastructure", + "service-config": "repository.service", + "software": "repository.software", + "project": "repository.project", +} + +TEMPLATE_VERSION = "0.1.0" + +_DEFAULT_CONTENT_ROOTS: dict[str, list[dict[str, str]]] = { + "infrastructure-config": [ + {"id": "desired-state", "role": "desired", "path": "desired", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + {"id": "inventory", "role": "inventory", "path": "inventory", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + ], + "service-config": [ + {"id": "policies", "role": "policies", "path": "policies", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + {"id": "acceptance", "role": "acceptance", "path": "acceptance", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + ], + "software": [ + {"id": "source", "role": "source", "path": "src", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + {"id": "tests", "role": "tests", "path": "tests", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + ], + "project": [ + {"id": "deliverables", "role": "deliverables", "path": "deliverables", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + {"id": "decisions", "role": "decisions", "path": "decisions", "kind": "directory", "authority": "source", "writePolicy": "managed"}, + ], +} + +SSH_RECOMMENDATION = ( + "Consider a repository-scoped SSH deploy key: read-only by default, private key kept " + "outside Git, and scoped to only this repository. repoctl does not generate or store " + "the key; use the gen-ssh-eddsa workflow or your Git host's deploy key feature." +) + + +@dataclass +class BootstrapAnswers: + name: str + title: str + owners: list[str] + repository_type: str + lifecycle: str = "active" + namespace: str | None = None + access: str | None = None + summary: str | None = None + content_roots: list[dict[str, str]] | None = None + git_init: bool = False + + @staticmethod + def from_mapping(data: dict[str, Any]) -> BootstrapAnswers: + return BootstrapAnswers( + name=data["name"], + title=data.get("title", data["name"]), + owners=list(data.get("owners", [])), + repository_type=data["repositoryType"], + lifecycle=data.get("lifecycle", "active"), + namespace=data.get("namespace"), + access=data.get("access"), + summary=data.get("summary"), + content_roots=data.get("contentRoots"), + git_init=bool(data.get("gitInit", False)), + ) + + +def _render_contract(answers: BootstrapAnswers) -> str: + content_roots = answers.content_roots if answers.content_roots is not None else _DEFAULT_CONTENT_ROOTS.get(answers.repository_type, []) + contract: dict[str, Any] = { + "apiVersion": API_VERSION, + "kind": "RepositoryContract", + "metadata": { + "name": answers.name, + "title": answers.title, + "owners": answers.owners, + }, + "spec": { + "summary": answers.summary or f"{answers.title} repository", + "repository": { + "type": answers.repository_type, + "lifecycle": answers.lifecycle, + **({"namespace": answers.namespace} if answers.namespace else {}), + **({"access": answers.access} if answers.access else {}), + }, + "template": { + "id": TEMPLATE_IDS[answers.repository_type], + "version": TEMPLATE_VERSION, + "source": "repo:repository-stewardship", + "answersRef": "ops/template-answers.yaml", + "mode": "generated", + }, + "agent": {"primary": "CLAUDE.md", "portable": "AGENTS.md"}, + "knowledge": {"entrypoint": "kdb/kdb.yaml"}, + "contentRoots": content_roots, + }, + } + return io.yaml_text(contract) + + +def _render_kdb(answers: BootstrapAnswers) -> str: + kdb = { + "apiVersion": API_VERSION, + "kind": "KnowledgeBase", + "metadata": {"name": f"{answers.name}-kdb", "title": f"{answers.title} knowledge base"}, + "spec": { + "repository": f"repo:{answers.name}", + "defaultLanguage": "en", + "topics": [], + "documents": [], + }, + } + return io.yaml_text(kdb) + + +def render_agents_md(answers: BootstrapAnswers) -> str: + return f"""# Repository instructions + +## Purpose + +{answers.summary or answers.title} + +## Start here + +1. Read `ops/contract.yaml` to identify the repository and authoritative content roots. +2. Read the small index in `kdb/kdb.yaml`. +3. Match the task to an exact topic intent. +4. Open only the documents and headings named by that topic's `data.readHints`. + +## Safety + +- Do not run destructive operations without an approved plan. +- Do not place secrets, tokens or private keys in this repository. +- Use `repoctl validate --repo .` before proposing changes to contract or KDB. +""" + + +def render_claude_md() -> str: + return """# CLAUDE.md + +@AGENTS.md + +## Claude-specific guidance + +Use `repoctl context` before loading detailed knowledge or running repository operations. +""" + + +def _render_template_answers(answers: BootstrapAnswers) -> str: + return io.yaml_text( + { + "schema": "stewardship/template-answers@0.1", + "templateId": TEMPLATE_IDS[answers.repository_type], + "templateVersion": TEMPLATE_VERSION, + "name": answers.name, + "title": answers.title, + "owners": answers.owners, + "repositoryType": answers.repository_type, + "lifecycle": answers.lifecycle, + } + ) + + +def _render_gitignore() -> str: + return "ops/runs/\n.venv/\n__pycache__/\n" + + +def build_bootstrap_plan(answers: BootstrapAnswers) -> dict[str, Any]: + contract_text = _render_contract(answers) + files = [ + {"path": "ops/contract.yaml", "content": contract_text}, + {"path": "kdb/kdb.yaml", "content": _render_kdb(answers)}, + {"path": "AGENTS.md", "content": render_agents_md(answers)}, + {"path": "CLAUDE.md", "content": render_claude_md()}, + {"path": "ops/template-answers.yaml", "content": _render_template_answers(answers)}, + {"path": ".gitignore", "content": _render_gitignore()}, + {"path": ".claude/skills/repository-bootstrap/SKILL.md", "content": REPOSITORY_BOOTSTRAP_SKILL}, + {"path": ".claude/skills/repository-adoption/SKILL.md", "content": REPOSITORY_ADOPTION_SKILL}, + {"path": ".claude/skills/repo-handoff/SKILL.md", "content": REPO_HANDOFF_SKILL}, + ] + plan: dict[str, Any] = { + "schema": "stewardship/bootstrap-plan@0.1", + "repository": answers.name, + "repositoryType": answers.repository_type, + "createdAt": DEFAULT_CLOCK.now_iso(), + "gitInit": answers.git_init, + "files": files, + "recommendations": [SSH_RECOMMENDATION], + } + plan_hash = io.sha256({k: v for k, v in plan.items() if k != "planHash"}) + plan["planHash"] = plan_hash + return plan + + +def apply_bootstrap_plan(root: Path, plan: dict[str, Any], approve_hash: str) -> list[str]: + expected_hash = io.sha256({k: v for k, v in plan.items() if k != "planHash"}) + if expected_hash != plan.get("planHash"): + raise ValueError("Plan hash does not match plan content; re-plan before apply") + if approve_hash != plan["planHash"]: + raise ValueError("Approval hash does not match plan hash") + + written: list[str] = [] + for file_entry in plan["files"]: + target = root / file_entry["path"] + if target.exists(): + raise FileExistsError(f"Refusing to overwrite existing file: {file_entry['path']}") + for file_entry in plan["files"]: + target = root / file_entry["path"] + io.write_text_atomic(target, file_entry["content"]) + written.append(file_entry["path"]) + + if plan.get("gitInit") and not (root / ".git").exists(): + subprocess.run(["git", "init"], cwd=root, check=True, capture_output=True) + + return written diff --git a/src/stewardship/cli.py b/src/stewardship/cli.py new file mode 100644 index 0000000..90db008 --- /dev/null +++ b/src/stewardship/cli.py @@ -0,0 +1,334 @@ +"""`repoctl`: thin argparse CLI adapter over the stewardship library. + +Exit codes (specification.md 19.2): 0 success, 1 validation/operation failure, +2 invalid invocation/input, 3 repository not found, 4 stale/incomplete strict +context, 5 approval required or denied. +""" + +from __future__ import annotations + +import argparse +import sys +from pathlib import Path +from typing import Any + +from . import adoption, bootstrap, config, discovery, io +from .constants import CONTRACT_PATH +from .context import build_context +from .paths import find_repository_root +from .render import build_envelope, emit +from .schema_loader import validate_against_kind +from .types import Finding +from .validate import validate_repository + +EXIT_SUCCESS = 0 +EXIT_VALIDATION_FAILURE = 1 +EXIT_INVALID_INPUT = 2 +EXIT_NOT_FOUND = 3 +EXIT_STRICT_INCOMPLETE = 4 +EXIT_APPROVAL = 5 + + +class CliError(Exception): + def __init__(self, message: str, exit_code: int = EXIT_INVALID_INPUT): + super().__init__(message) + self.exit_code = exit_code + + +def _resolve_repo(repo_arg: str | None, roots: list[str] | None) -> Path: + if repo_arg: + candidate = Path(repo_arg).expanduser() + if candidate.exists(): + root = find_repository_root(candidate) + if root is None: + raise CliError(f"No .git ancestor found for {candidate}", EXIT_NOT_FOUND) + return root + found, _ = discovery.discover_repositories(config.resolve_roots(roots)) + for repo in found: + name = (repo.contract.get("metadata") or {}).get("name") + if name == repo_arg: + return repo.path + raise CliError(f"Repository not found: {repo_arg}", EXIT_NOT_FOUND) + root = find_repository_root(Path.cwd()) + if root is None: + raise CliError("No .git ancestor found from current directory", EXIT_NOT_FOUND) + return root + + +def _write(envelope: dict[str, Any], output: str) -> None: + emit(envelope, output) + + +def cmd_config(args: argparse.Namespace) -> int: + if args.config_action == "show": + data = config.load_config() + _write(build_envelope("config show", "success", data, []), args.output) + return EXIT_SUCCESS + if args.config_action == "add-root": + data = config.add_root(args.path) + _write(build_envelope("config add-root", "success", data, []), args.output) + return EXIT_SUCCESS + if args.config_action == "remove-root": + data = config.remove_root(args.path) + _write(build_envelope("config remove-root", "success", data, []), args.output) + return EXIT_SUCCESS + raise CliError("Unknown config action") + + +def cmd_validate(args: argparse.Namespace) -> int: + root = _resolve_repo(args.repo, args.root) + result = validate_repository(root) + outcome = "success" if result.ok else "failure" + data = {"repository": str(root), "valid": result.ok} + _write(build_envelope("validate", outcome, data, result.findings), args.output) + return EXIT_SUCCESS if result.ok else EXIT_VALIDATION_FAILURE + + +def cmd_discover(args: argparse.Namespace) -> int: + roots = config.resolve_roots(args.root) + catalog, findings = discovery.build_catalog_index(roots) + has_error = any(f.severity == "error" for f in findings) + _write(build_envelope("discover", "failure" if has_error else "success", catalog, findings), args.output) + return EXIT_VALIDATION_FAILURE if has_error else EXIT_SUCCESS + + +def cmd_describe(args: argparse.Namespace) -> int: + root = _resolve_repo(args.repo, args.root) + contract_path = root / CONTRACT_PATH + if not contract_path.exists(): + raise CliError(f"{CONTRACT_PATH} not found under {root}", EXIT_NOT_FOUND) + contract = io.load_yaml(contract_path) + errors = validate_against_kind("RepositoryContract", contract) if isinstance(contract, dict) else ["not a mapping"] + findings = [Finding("error", "CONTRACT_SCHEMA_INVALID", e) for e in errors] + outcome = "failure" if findings else "success" + _write(build_envelope("describe", outcome, contract, findings), args.output) + return EXIT_VALIDATION_FAILURE if findings else EXIT_SUCCESS + + +def cmd_context(args: argparse.Namespace) -> int: + root = _resolve_repo(args.repo, args.root) + result = build_context( + root, + args.intent, + include_related=args.include_related, + materialize=args.materialize, + budget_bytes=args.budget_bytes, + strict=args.strict, + ) + data = dict(result.bundle) + if result.materialized: + data["spec"] = dict(data["spec"]) + data["spec"]["materializedContent"] = [ + {"document": m.document_id, "path": m.path, "bytes": m.bytes_used, "content": m.content} + for m in result.materialized + ] + findings = [ + Finding(w.split(":", 2)[0], w.split(":", 2)[1], w.split(":", 2)[2]) + for w in result.bundle["spec"]["warnings"] + ] + outcome = "success" + exit_code = EXIT_SUCCESS + if result.truncated and args.strict: + outcome = "failure" + exit_code = EXIT_STRICT_INCOMPLETE + _write(build_envelope("context", outcome, data, findings), args.output) + return exit_code + + +def cmd_init(args: argparse.Namespace) -> int: + repo_path = Path(args.repo).expanduser() + if args.apply: + if not args.plan or not args.approve: + raise CliError("--apply requires --plan and --approve", EXIT_INVALID_INPUT) + plan = io.load_yaml(Path(args.plan)) + repo_path.mkdir(parents=True, exist_ok=True) + try: + written = bootstrap.apply_bootstrap_plan(repo_path, plan, args.approve) + except ValueError as exc: + _write(build_envelope("init apply", "failure", None, [Finding("error", "APPROVAL_FAILED", str(exc))]), args.output) + return EXIT_APPROVAL + except FileExistsError as exc: + _write(build_envelope("init apply", "failure", None, [Finding("error", "ADOPT_PATH_COLLISION", str(exc))]), args.output) + return EXIT_VALIDATION_FAILURE + _write(build_envelope("init apply", "success", {"written": written}, []), args.output) + return EXIT_SUCCESS + + if args.answers: + answers_data = io.load_yaml(Path(args.answers)) + else: + answers_data = {} + if args.name: + answers_data["name"] = args.name + if args.type: + answers_data["repositoryType"] = args.type + if args.title: + answers_data["title"] = args.title + if args.owner: + answers_data["owners"] = list(args.owner) + if args.lifecycle: + answers_data["lifecycle"] = args.lifecycle + if args.git_init: + answers_data["gitInit"] = True + + missing = [f for f in ("name", "repositoryType") if f not in answers_data] + if missing: + raise CliError(f"Missing required answers: {', '.join(missing)}", EXIT_INVALID_INPUT) + + answers = bootstrap.BootstrapAnswers.from_mapping(answers_data) + plan = bootstrap.build_bootstrap_plan(answers) + _write(build_envelope("init plan", "success", plan, []), args.output) + return EXIT_SUCCESS + + +def cmd_adopt(args: argparse.Namespace) -> int: + repo_path = Path(args.repo).expanduser() + if not repo_path.exists(): + raise CliError(f"Path does not exist: {repo_path}", EXIT_NOT_FOUND) + + if args.mode == "assess": + result = adoption.assess(repo_path) + findings = [ + Finding(f["severity"], f["code"], f.get("message", f["code"]), path=f.get("path")) + for f in result["findings"] + ] + blocker = any(f.severity == "error" for f in findings) + _write(build_envelope("adopt assess", "failure" if blocker else "success", result, findings), args.output) + return EXIT_VALIDATION_FAILURE if blocker else EXIT_SUCCESS + + if args.mode == "plan": + assessment = adoption.assess(repo_path) + if args.answers: + answers = io.load_yaml(Path(args.answers)) + else: + answers = {} + name = answers.get("name") or repo_path.name.lower() + plan = adoption.build_plan( + repo_path, + assessment, + confirmed_name=name, + confirmed_title=answers.get("title"), + confirmed_owners=answers.get("owners"), + confirmed_lifecycle=answers.get("lifecycle", "active"), + strategy=args.strategy, + ) + _write(build_envelope("adopt plan", "success", plan, []), args.output) + return EXIT_SUCCESS + + if args.mode == "apply": + if not args.plan or not args.approve: + raise CliError("--mode apply requires --plan and --approve", EXIT_INVALID_INPUT) + plan = io.load_yaml(Path(args.plan)) + try: + written = adoption.apply_plan(repo_path, plan, args.approve) + except ValueError as exc: + code = "APPROVAL_FAILED" if "Approval" in str(exc) or "hash" in str(exc) else "ADOPT_BASELINE_CHANGED" + _write(build_envelope("adopt apply", "failure", None, [Finding("error", code, str(exc))]), args.output) + return EXIT_APPROVAL + except FileExistsError as exc: + _write(build_envelope("adopt apply", "failure", None, [Finding("error", "ADOPT_PATH_COLLISION", str(exc))]), args.output) + return EXIT_VALIDATION_FAILURE + _write(build_envelope("adopt apply", "success", {"written": written}, []), args.output) + return EXIT_SUCCESS + + if args.mode == "verify": + verify_plan = io.load_yaml(Path(args.plan)) if args.plan else None + report = adoption.verify(repo_path, verify_plan) + outcome = "failure" if report["outcome"] == "fail" else "success" + _write(build_envelope("adopt verify", outcome, report, []), args.output) + return EXIT_VALIDATION_FAILURE if report["outcome"] == "fail" else EXIT_SUCCESS + + raise CliError(f"Unknown adopt mode: {args.mode}", EXIT_INVALID_INPUT) + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(prog="repoctl", description="Repository Stewardship CLI") + sub = parser.add_subparsers(dest="command", required=True) + + def add_common(p: argparse.ArgumentParser) -> None: + p.add_argument("--output", choices=["human", "yaml", "json"], default="human") + + p_config = sub.add_parser("config") + add_common(p_config) + config_sub = p_config.add_subparsers(dest="config_action", required=True) + config_sub.add_parser("show") + p_add_root = config_sub.add_parser("add-root") + p_add_root.add_argument("path") + p_remove_root = config_sub.add_parser("remove-root") + p_remove_root.add_argument("path") + p_config.set_defaults(func=cmd_config) + + p_validate = sub.add_parser("validate") + add_common(p_validate) + p_validate.add_argument("--repo") + p_validate.add_argument("--root", action="append") + p_validate.set_defaults(func=cmd_validate) + + p_discover = sub.add_parser("discover") + add_common(p_discover) + p_discover.add_argument("--root", action="append") + p_discover.set_defaults(func=cmd_discover) + + p_describe = sub.add_parser("describe") + add_common(p_describe) + p_describe.add_argument("--repo") + p_describe.add_argument("--root", action="append") + p_describe.set_defaults(func=cmd_describe) + + p_context = sub.add_parser("context") + add_common(p_context) + p_context.add_argument("--repo") + p_context.add_argument("--root", action="append") + p_context.add_argument("--intent", required=True) + p_context.add_argument("--include-related", action="store_true") + p_context.add_argument("--materialize", action="store_true") + p_context.add_argument("--budget-bytes", type=int, default=None) + p_context.add_argument("--strict", action="store_true") + p_context.set_defaults(func=cmd_context) + + p_init = sub.add_parser("init") + add_common(p_init) + p_init.add_argument("--repo", required=True) + p_init.add_argument("--answers") + p_init.add_argument("--name") + p_init.add_argument("--type", dest="type", choices=["infrastructure-config", "service-config", "software", "project"]) + p_init.add_argument("--title") + p_init.add_argument("--owner", action="append") + p_init.add_argument("--lifecycle") + p_init.add_argument("--git-init", action="store_true") + p_init.add_argument("--no-git-init", dest="git_init", action="store_false") + p_init.set_defaults(git_init=None) + p_init.add_argument("--apply", action="store_true") + p_init.add_argument("--plan") + p_init.add_argument("--approve") + p_init.set_defaults(func=cmd_init) + + p_adopt = sub.add_parser("adopt") + add_common(p_adopt) + p_adopt.add_argument("--repo", required=True) + p_adopt.add_argument("--mode", required=True, choices=["assess", "plan", "apply", "verify"]) + p_adopt.add_argument("--answers") + p_adopt.add_argument("--strategy", default="overlay", choices=["overlay", "normalize"]) + p_adopt.add_argument("--recipe") + p_adopt.add_argument("--plan") + p_adopt.add_argument("--approve") + p_adopt.set_defaults(func=cmd_adopt) + + return parser + + +def main(argv: list[str] | None = None) -> int: + parser = build_parser() + args = parser.parse_args(argv) + try: + result: int = args.func(args) + return result + except CliError as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return exc.exit_code + except Exception as exc: # noqa: BLE001 - top-level CLI safety net + print(f"ERROR: {exc}", file=sys.stderr) + return EXIT_VALIDATION_FAILURE + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/stewardship/clock.py b/src/stewardship/clock.py new file mode 100644 index 0000000..5fa2795 --- /dev/null +++ b/src/stewardship/clock.py @@ -0,0 +1,20 @@ +"""Deterministic time source so machine output is reproducible in tests.""" + +from __future__ import annotations + +import os +from datetime import UTC, datetime + + +class Clock: + def now(self) -> datetime: + override = os.environ.get("REPOCTL_CLOCK_UTC") + if override: + return datetime.fromisoformat(override).replace(tzinfo=UTC) + return datetime.now(UTC) + + def now_iso(self) -> str: + return self.now().replace(microsecond=0).isoformat().replace("+00:00", "Z") + + +DEFAULT_CLOCK = Clock() diff --git a/src/stewardship/config.py b/src/stewardship/config.py new file mode 100644 index 0000000..d20b657 --- /dev/null +++ b/src/stewardship/config.py @@ -0,0 +1,75 @@ +"""User configuration: repository root list used to resolve `--repo NAME`. + +Resolution order (per docs/PLAN.md): explicit --root flags -> REPOCTL_ROOTS env -> +user config -> current repository as a last-resort fallback. Config is only ever +changed by explicit `config add-root` / `config remove-root`; no hidden cache. +""" + +from __future__ import annotations + +import os +import platform +from pathlib import Path +from typing import Any + +from . import io +from .constants import CONFIG_SCHEMA + + +def config_path() -> Path: + override = os.environ.get("REPOCTL_CONFIG_PATH") + if override: + return Path(override) + if platform.system() == "Windows": + base = os.environ.get("APPDATA") + root = Path(base) if base else Path.home() / "AppData" / "Roaming" + return root / "RepositoryStewardship" / "config.yaml" + xdg = os.environ.get("XDG_CONFIG_HOME") + root = Path(xdg) if xdg else Path.home() / ".config" + return root / "repository-stewardship" / "config.yaml" + + +def load_config() -> dict[str, Any]: + path = config_path() + if not path.exists(): + return {"schema": CONFIG_SCHEMA, "roots": []} + data = io.load_yaml(path) + if not isinstance(data, dict): + raise TypeError(f"Config at {path} is not a mapping") + data.setdefault("schema", CONFIG_SCHEMA) + data.setdefault("roots", []) + return data + + +def save_config(data: dict[str, Any]) -> None: + path = config_path() + io.write_text_atomic(path, io.yaml_text(data)) + + +def add_root(root: str) -> dict[str, Any]: + data = load_config() + normalized = str(Path(root).expanduser()) + roots = list(dict.fromkeys([*data.get("roots", []), normalized])) + data["roots"] = roots + save_config(data) + return data + + +def remove_root(root: str) -> dict[str, Any]: + data = load_config() + normalized = str(Path(root).expanduser()) + data["roots"] = [item for item in data.get("roots", []) if item != normalized] + save_config(data) + return data + + +def resolve_roots(cli_roots: list[str] | None) -> list[Path]: + if cli_roots: + return [Path(item).expanduser() for item in cli_roots] + env_roots = os.environ.get("REPOCTL_ROOTS") + if env_roots: + return [Path(item).expanduser() for item in env_roots.split(os.pathsep) if item] + configured = load_config().get("roots", []) + if configured: + return [Path(item).expanduser() for item in configured] + return [Path.cwd()] diff --git a/src/stewardship/constants.py b/src/stewardship/constants.py new file mode 100644 index 0000000..7aa98c9 --- /dev/null +++ b/src/stewardship/constants.py @@ -0,0 +1,19 @@ +from __future__ import annotations + +API_VERSION = "stewardship.corsus.ru/v1alpha1" +CONTRACT_PATH = "ops/contract.yaml" +DEFAULT_KDB_PATH = "kdb/kdb.yaml" +CONFIG_SCHEMA = "stewardship/repoctl-config@0.1" +RESULT_SCHEMA = "stewardship/repoctl-result@0.1" +ID_PATTERN = r"^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" +REPOSITORY_TYPES = {"infrastructure-config", "service-config", "software", "project"} +LIFECYCLES = {"production", "active", "experimental", "stub", "archive", "external"} +ACCESS_VALUES = {"public", "internal", "restricted"} +CONTENT_KINDS = {"directory", "file", "file-set", "manifest"} +AUTHORITIES = {"source", "generated", "observed", "mirror", "evidence"} +WRITE_POLICIES = {"managed", "read-only", "generated"} +DOCUMENT_AUTHORITIES = {"vendor", "local-canonical", "observed", "derived", "manual"} +DOCUMENT_STATUSES = {"verified", "manual", "draft", "stale"} +DOCUMENT_ROLES = {"tutorial", "how-to", "reference", "explanation", "runbook", "vendor-source", "evidence"} +SECRET_KEYS = {"password", "token", "privatekey", "secretvalue"} + diff --git a/src/stewardship/context.py b/src/stewardship/context.py new file mode 100644 index 0000000..c750c16 --- /dev/null +++ b/src/stewardship/context.py @@ -0,0 +1,149 @@ +"""`repoctl context`: deterministic, budgeted, intent-scoped ContextBundle selection.""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +from .clock import DEFAULT_CLOCK +from .io import file_sha256 +from .validate import validate_repository + + +@dataclass +class MaterializedItem: + document_id: str + path: str + bytes_used: int + content: str + + +@dataclass +class ContextResult: + bundle: dict[str, Any] + materialized: list[MaterializedItem] = field(default_factory=list) + truncated: bool = False + + +def build_context( + root: Path, + intent: str, + *, + include_related: bool = False, + materialize: bool = False, + budget_bytes: int | None = None, + strict: bool = False, +) -> ContextResult: + validation = validate_repository(root) + warnings: list[str] = [f"{f.severity}:{f.code}:{f.message}" for f in validation.findings if f.severity != "info"] + + contract = validation.contract or {} + metadata = contract.get("metadata", {}) or {} + spec = contract.get("spec", {}) or {} + repo_name = metadata.get("name", "unknown") + + contract_revision = file_sha256(root / "ops/contract.yaml") if (root / "ops/contract.yaml").exists() else None + + operations = [ + f"operation:{repo_name}/{op.get('id')}" + for op in spec.get("operations") or [] + if isinstance(op, dict) and intent in (op.get("intents") or []) + ] + + content_roots = [ + cr["id"] for cr in spec.get("contentRoots") or [] if isinstance(cr, dict) and cr.get("id") + ] + + topics_selected: list[dict[str, Any]] = [] + document_ids: list[str] = [] + kdb = validation.kdb or {} + kdb_spec = kdb.get("spec", {}) if isinstance(kdb.get("spec"), dict) else {} + all_topics = kdb_spec.get("topics") or [] + all_documents = {d.get("id"): d for d in (kdb_spec.get("documents") or []) if isinstance(d, dict)} + + matched = [t for t in all_topics if isinstance(t, dict) and intent in (t.get("intents") or [])] + matched.sort(key=lambda t: (-(t.get("priority") or 50), t.get("id") or "")) + topics_selected.extend(matched) + + if include_related: + related_ids: set[str] = set() + for topic in matched: + related_ids.update(topic.get("relatedTopics") or []) + for topic in all_topics: + if isinstance(topic, dict) and topic.get("id") in related_ids: + topics_selected.append(topic) + + seen_docs: set[str] = set() + for topic in topics_selected: + for doc_id in topic.get("documents") or []: + if doc_id in seen_docs: + continue + seen_docs.add(doc_id) + document_ids.append(doc_id) + doc = all_documents.get(doc_id) + if doc is None: + warnings.append(f"warning:CONTEXT_DOCUMENT_MISSING:Referenced document not found: {doc_id}") + elif doc.get("status") == "stale": + warnings.append(f"warning:CONTEXT_DOCUMENT_STALE:Document authored status is stale: {doc_id}") + + topics_ref = sorted(f"topic:{repo_name}/{t.get('id')}" for t in topics_selected if t.get("id")) + operations = sorted(set(operations)) + content_roots = sorted(set(content_roots)) + document_ids = sorted(set(document_ids)) + + bundle_name = f"{repo_name}-{intent.replace('.', '-')}" + bundle: dict[str, Any] = { + "apiVersion": "stewardship.corsus.ru/v1alpha1", + "kind": "ContextBundle", + "metadata": {"name": bundle_name}, + "spec": { + "generatedAt": DEFAULT_CLOCK.now_iso(), + "intent": intent, + "repository": f"repo:{repo_name}", + "summary": spec.get("summary", ""), + "contentRoots": content_roots, + "operations": operations, + "topics": topics_ref, + "documents": document_ids, + "warnings": warnings, + }, + } + if contract_revision: + bundle["spec"]["contractRevision"] = contract_revision + + result = ContextResult(bundle=bundle) + + if materialize: + remaining = budget_bytes if budget_bytes is not None else None + materialized_items = [] + truncated = False + for doc_id in document_ids: + doc = all_documents.get(doc_id) + if not doc or not doc.get("path"): + continue + doc_path = root / doc["path"] + if not doc_path.exists(): + continue + content = doc_path.read_text(encoding="utf-8") + content_bytes = content.encode("utf-8") + if remaining is not None: + if len(content_bytes) > remaining: + truncated = True + if remaining <= 0: + continue + content_bytes = content_bytes[:remaining] + content = content_bytes.decode("utf-8", errors="ignore") + remaining -= len(content_bytes) + materialized_items.append( + MaterializedItem(document_id=doc_id, path=doc["path"], bytes_used=len(content_bytes), content=content) + ) + result.materialized = materialized_items + result.truncated = truncated + bundle["spec"]["materialized"] = [ + {"document": item.document_id, "path": item.path, "bytes": item.bytes_used} for item in materialized_items + ] + if truncated: + bundle["spec"]["warnings"].append("warning:CONTEXT_BUDGET_TRUNCATED:Materialized content truncated to fit budget") + + return result diff --git a/src/stewardship/discovery.py b/src/stewardship/discovery.py new file mode 100644 index 0000000..dfcf564 --- /dev/null +++ b/src/stewardship/discovery.py @@ -0,0 +1,151 @@ +"""`repoctl discover`: find `ops/contract.yaml` under roots and build a CatalogIndex.""" + +from __future__ import annotations + +from collections.abc import Iterator +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .clock import DEFAULT_CLOCK +from .constants import CONTRACT_PATH +from .io import file_sha256 +from .types import Finding, sort_findings +from .validate import validate_repository + +_SKIP_DIR_NAMES = { + ".git", + ".venv", + "venv", + "node_modules", + "__pycache__", + ".mypy_cache", + ".pytest_cache", + ".ruff_cache", + ".tox", + "dist", + "build", + ".eggs", + "site-packages", +} + + +@dataclass +class DiscoveredRepository: + path: Path + contract: dict[str, Any] + contract_hash: str + + +def _iter_contract_dirs(root: Path) -> Iterator[Path]: + root = root.resolve() + if not root.exists(): + return + stack = [root] + while stack: + current = stack.pop() + try: + entries = sorted(current.iterdir(), key=lambda p: p.name) + except OSError: + continue + if (current / CONTRACT_PATH.split("/")[0] / CONTRACT_PATH.split("/")[1]).exists(): + yield current + for entry in entries: + if not entry.is_dir(): + continue + if entry.is_symlink(): + continue + if entry.name in _SKIP_DIR_NAMES: + continue + stack.append(entry) + + +def discover_repositories(roots: list[Path]) -> tuple[list[DiscoveredRepository], list[Finding]]: + findings: list[Finding] = [] + found: list[DiscoveredRepository] = [] + seen_paths: set[Path] = set() + for root in roots: + for repo_dir in _iter_contract_dirs(root): + resolved = repo_dir.resolve() + if resolved in seen_paths: + continue + seen_paths.add(resolved) + validation = validate_repository(repo_dir) + if validation.contract is None: + findings.extend(validation.findings) + continue + findings.extend(validation.findings) + contract_hash = file_sha256(repo_dir / CONTRACT_PATH) + found.append(DiscoveredRepository(repo_dir, validation.contract, contract_hash)) + found.sort(key=lambda item: item.path.as_posix()) + return found, findings + + +def build_catalog_index(roots: list[Path]) -> tuple[dict[str, Any], list[Finding]]: + repositories, findings = discover_repositories(roots) + + seen_names: dict[str, Path] = {} + entries = [] + relations: list[dict[str, str]] = [] + by_name: dict[str, dict[str, Any]] = {} + + for repo in repositories: + metadata = repo.contract.get("metadata", {}) or {} + name = metadata.get("name") + spec = repo.contract.get("spec", {}) or {} + repository_info = spec.get("repository", {}) or {} + if not name: + findings.append(Finding("error", "CATALOG_REPOSITORY_NAME_MISSING", "Contract has no metadata.name", path=str(repo.path))) + continue + if name in seen_names: + findings.append( + Finding( + "error", + "CATALOG_DUPLICATE_REPOSITORY_NAME", + f"Repository name {name!r} is used by both {seen_names[name]} and {repo.path}", + resource=f"repo:{name}", + ) + ) + continue + seen_names[name] = repo.path + entry = { + "ref": f"repo:{name}", + "path": repo.path.as_posix(), + "type": repository_info.get("type", "unknown"), + "lifecycle": repository_info.get("lifecycle", "unknown"), + "contractHash": repo.contract_hash, + } + entries.append(entry) + by_name[name] = repo.contract + + for name, contract in by_name.items(): + spec = contract.get("spec", {}) or {} + for cap in spec.get("provides") or []: + relations.append({"from": f"repo:{name}", "type": "provides", "to": f"capability:{name}/{cap.get('id')}"}) + for req in spec.get("requires") or []: + req_ref = f"requirement:{name}/{req.get('id')}" + relations.append({"from": f"repo:{name}", "type": "requires", "to": req_ref}) + for other_name, other_contract in by_name.items(): + for cap in (other_contract.get("spec", {}) or {}).get("provides") or []: + if cap.get("capability") == req.get("capability"): + relations.append({"from": req_ref, "type": "matches", "to": f"capability:{other_name}/{cap.get('id')}"}) + for binding in spec.get("bindings") or []: + binding_ref = f"binding:{name}/{binding.get('id')}" + requirement_ref = binding.get("requirement", "") + relations.append({"from": binding_ref, "type": "fulfills", "to": requirement_ref}) + + entries.sort(key=lambda e: e["ref"]) + relations.sort(key=lambda r: (r["from"], r["type"], r["to"])) + + catalog = { + "apiVersion": "stewardship.corsus.ru/v1alpha1", + "kind": "CatalogIndex", + "metadata": {"name": "local-git-catalog"}, + "spec": { + "generatedAt": DEFAULT_CLOCK.now_iso(), + "roots": [str(r) for r in roots], + "repositories": entries, + "relations": relations, + }, + } + return catalog, sort_findings(findings) diff --git a/src/stewardship/gitutil.py b/src/stewardship/gitutil.py new file mode 100644 index 0000000..1ffbe21 --- /dev/null +++ b/src/stewardship/gitutil.py @@ -0,0 +1,35 @@ +"""Minimal read-only Git helpers used by adoption assess/plan/apply/verify. + +Adoption never commits, pushes, clones or touches remotes; these helpers only ever +call read-only `git` subcommands, plus `git init` for `repoctl init --git-init`. +""" + +from __future__ import annotations + +import subprocess +from pathlib import Path + + +def _run(args: list[str], cwd: Path) -> subprocess.CompletedProcess[str]: + return subprocess.run( + ["git", *args], cwd=cwd, capture_output=True, text=True, check=False + ) + + +def head_revision(root: Path) -> str: + result = _run(["rev-parse", "HEAD"], root) + if result.returncode != 0: + return "unborn" + return result.stdout.strip() + + +def is_dirty(root: Path) -> bool: + result = _run(["status", "--porcelain"], root) + return bool(result.stdout.strip()) + + +def tracked_files(root: Path) -> set[str]: + result = _run(["ls-files"], root) + if result.returncode != 0: + return set() + return {line.strip() for line in result.stdout.splitlines() if line.strip()} diff --git a/src/stewardship/io.py b/src/stewardship/io.py new file mode 100644 index 0000000..bb8e4c4 --- /dev/null +++ b/src/stewardship/io.py @@ -0,0 +1,86 @@ +from __future__ import annotations + +import hashlib +import json +from pathlib import Path +from typing import Any + +from ruamel.yaml import YAML +from ruamel.yaml.error import YAMLError + + +class ResourceError(ValueError): + """Input cannot be safely parsed as an expected resource.""" + + +def _safe_yaml() -> YAML: + yaml = YAML(typ="safe", pure=True) + yaml.allow_duplicate_keys = False + return yaml + + +def _output_yaml() -> YAML: + yaml = YAML() + yaml.default_flow_style = False + yaml.allow_unicode = True + yaml.indent(mapping=2, sequence=4, offset=2) + return yaml + + +def load_yaml(path: Path) -> Any: + try: + with path.open("r", encoding="utf-8") as handle: + return _safe_yaml().load(handle) + except (OSError, YAMLError) as exc: + raise ResourceError(f"Cannot parse YAML: {exc}") from exc + + +def yaml_text(data: Any) -> str: + from io import StringIO + + stream = StringIO() + _output_yaml().dump(data, stream) + return stream.getvalue() + + +def primitive(value: Any) -> Any: + if isinstance(value, dict): + return {str(key): primitive(item) for key, item in value.items()} + if isinstance(value, (list, tuple)): + return [primitive(item) for item in value] + if hasattr(value, "isoformat") and not isinstance(value, str): + return value.isoformat() + return value + + +def canonical_json(value: Any) -> str: + return json.dumps(primitive(value), ensure_ascii=False, sort_keys=True, separators=(",", ":")) + + +def sha256(value: Any) -> str: + return "sha256:" + hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest() + + +def file_sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return "sha256:" + digest.hexdigest() + + +def write_text_atomic(path: Path, content: str) -> None: + """Write ``content`` to ``path`` via a temp file in the same directory, then replace. + + Uses ``\\n`` line endings unconditionally so hashes and diffs are platform independent. + """ + path.parent.mkdir(parents=True, exist_ok=True) + normalized = content.replace("\r\n", "\n") + tmp = path.parent / f".{path.name}.repoctl-tmp" + with tmp.open("w", encoding="utf-8", newline="\n") as handle: + handle.write(normalized) + tmp.replace(path) + + +def dump_json(value: Any) -> str: + return json.dumps(primitive(value), ensure_ascii=False, indent=2, sort_keys=False) + "\n" diff --git a/src/stewardship/markdown.py b/src/stewardship/markdown.py new file mode 100644 index 0000000..0be7451 --- /dev/null +++ b/src/stewardship/markdown.py @@ -0,0 +1,176 @@ +"""Lightweight Markdown structural checks: frontmatter, fenced YAML/Mermaid, local links. + +This module never executes Markdown or fetches remote resources; it is purely static. +""" + +from __future__ import annotations + +import re +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .io import ResourceError +from .types import Finding + +_FENCE_RE = re.compile(r"^(```+|~~~+)(\S*)\s*$") +_LINK_RE = re.compile(r"(? list[Finding]: + findings: list[Finding] = [] + full_path = repo_root / rel_path + try: + text = full_path.read_text(encoding="utf-8") + except OSError as exc: + return [Finding("error", "MARKDOWN_UNREADABLE", str(exc), path=rel_path)] + + findings.extend(_check_frontmatter(text, rel_path)) + findings.extend(_check_fences(text, rel_path)) + findings.extend(_check_local_links(repo_root, rel_path, text)) + return findings + + +def _check_frontmatter(text: str, rel_path: str) -> list[Finding]: + findings: list[Finding] = [] + if text.startswith("---\n"): + end = text.find("\n---", 4) + if end == -1: + return [ + Finding( + "error", + "MARKDOWN_FRONTMATTER_UNTERMINATED", + "Frontmatter block is not closed with '---'", + path=rel_path, + ) + ] + block = text[4:end] + try: + load_yaml_text(block) + except ResourceError as exc: + findings.append( + Finding("error", "MARKDOWN_FRONTMATTER_INVALID_YAML", str(exc), path=rel_path) + ) + return findings + + +def load_yaml_text(text: str) -> Any: + from io import StringIO + + from ruamel.yaml import YAML + from ruamel.yaml.error import YAMLError + + yaml = YAML(typ="safe", pure=True) + try: + return yaml.load(StringIO(text)) + except YAMLError as exc: + raise ResourceError(str(exc)) from exc + + +def _check_fences(text: str, rel_path: str) -> list[Finding]: + findings: list[Finding] = [] + stack: list[tuple[str, int]] = [] + lines = text.splitlines() + fence_blocks: list[tuple[int, int, str]] = [] + for lineno, line in enumerate(lines, start=1): + match = _FENCE_RE.match(line) + if not match: + continue + marker, info = match.groups() + if stack and stack[-1][0][0] == marker[0]: + _open_marker, open_line = stack.pop() + fence_blocks.append((open_line, lineno, info)) + else: + stack.append((marker, lineno)) + for marker, lineno in stack: + findings.append( + Finding( + "error", + "MARKDOWN_FENCE_UNBALANCED", + f"Unclosed code fence opened at line {lineno}", + path=rel_path, + ) + ) + + for start, end, info in fence_blocks: + lang = info.strip().lower() + body = "\n".join(lines[start:end - 1]) + if lang == "yaml": + try: + load_yaml_text(body) + except ResourceError as exc: + findings.append( + Finding( + "error", + "MARKDOWN_YAML_FENCE_INVALID", + f"Fenced YAML block at line {start} is invalid: {exc}", + path=rel_path, + ) + ) + elif lang == "mermaid": + head = body.strip().splitlines()[0].strip() if body.strip() else "" + head_token = head.split()[0] if head else "" + if head_token not in _MERMAID_HEADERS: + findings.append( + Finding( + "warning", + "MARKDOWN_MERMAID_HEADER_UNKNOWN", + f"Mermaid block at line {start} has an unrecognized diagram header: {head_token!r}", + path=rel_path, + ) + ) + return findings + + +def _check_local_links(repo_root: Path, rel_path: str, text: str) -> list[Finding]: + findings: list[Finding] = [] + base_dir = (repo_root / rel_path).parent + for match in _LINK_RE.finditer(text): + target = match.group(1) + if target.startswith(("http://", "https://", "mailto:", "#")): + continue + target_path_part = target.split("#", 1)[0] + if not target_path_part: + continue + candidate = (base_dir / target_path_part).resolve() + try: + candidate.relative_to(repo_root.resolve()) + except ValueError: + findings.append( + Finding( + "warning", + "MARKDOWN_LINK_OUTSIDE_REPOSITORY", + f"Link target resolves outside repository root: {target}", + path=rel_path, + ) + ) + continue + if not candidate.exists(): + findings.append( + Finding( + "error", + "MARKDOWN_LINK_TARGET_MISSING", + f"Local link target does not exist: {target}", + path=rel_path, + ) + ) + return findings diff --git a/src/stewardship/paths.py b/src/stewardship/paths.py new file mode 100644 index 0000000..0f3bbaf --- /dev/null +++ b/src/stewardship/paths.py @@ -0,0 +1,51 @@ +from __future__ import annotations + +import os +from pathlib import Path + + +class PathViolation(ValueError): + """A resource path escapes the repository boundary.""" + + +def normalize_resource_path(value: str) -> str: + if not value or not isinstance(value, str): + raise PathViolation("Path must be a non-empty string") + if "\\" in value or value.startswith(("/", "\\")) or ":" in value.split("/")[0]: + raise PathViolation("Path must be repository-relative and use '/' separators") + parts = value.split("/") + if any(part in {"", ".", ".."} for part in parts): + raise PathViolation("Path contains an unsafe segment") + return "/".join(parts) + + +def confined_path(root: Path, value: str, *, must_exist: bool = False) -> Path: + normalized = normalize_resource_path(value) + root_resolved = root.resolve(strict=True) + candidate = root_resolved.joinpath(*normalized.split("/")) + probe = candidate if candidate.exists() else candidate.parent + try: + probe.resolve(strict=True).relative_to(root_resolved) + except ValueError as exc: + raise PathViolation("Path resolves outside repository root") from exc + if must_exist and not candidate.exists(): + raise PathViolation("Path does not exist") + return candidate + + +def find_repository_root(path: Path) -> Path | None: + current = path.resolve() + if current.is_file(): + current = current.parent + for candidate in (current, *current.parents): + if (candidate / ".git").exists(): + return candidate + return None + + +def display_path(path: Path) -> str: + return path.as_posix() + + +def split_roots(value: str) -> list[Path]: + return [Path(item).expanduser() for item in value.split(os.pathsep) if item] diff --git a/src/stewardship/render.py b/src/stewardship/render.py new file mode 100644 index 0000000..baea1c0 --- /dev/null +++ b/src/stewardship/render.py @@ -0,0 +1,48 @@ +"""Render the `stewardship/repoctl-result@0.1` envelope as human, YAML or JSON output.""" + +from __future__ import annotations + +import sys +from collections.abc import Callable +from typing import Any + +from .constants import RESULT_SCHEMA +from .io import dump_json, yaml_text +from .types import Finding + + +def build_envelope(command: str, outcome: str, data: Any, findings: list[Finding]) -> dict[str, Any]: + return { + "schema": RESULT_SCHEMA, + "command": command, + "outcome": outcome, + "data": data, + "findings": [f.to_dict() for f in findings], + } + + +def print_findings_human(findings: list[Finding]) -> None: + for finding in findings: + location = f" [{finding.resource}]" if finding.resource else "" + path = f" ({finding.path})" if finding.path else "" + print(f"{finding.severity.upper()} {finding.code}{location}{path}: {finding.message}", file=sys.stderr) + + +def emit( + envelope: dict[str, Any], + output: str, + human_renderer: Callable[[dict[str, Any]], None] | None = None, +) -> None: + if output == "json": + sys.stdout.write(dump_json(envelope)) + elif output == "yaml": + sys.stdout.write(yaml_text(envelope)) + else: + for finding in envelope["findings"]: + location = f" [{finding['resource']}]" if finding.get("resource") else "" + path = f" ({finding['path']})" if finding.get("path") else "" + print(f"{finding['severity'].upper()} {finding['code']}{location}{path}: {finding['message']}", file=sys.stderr) + if human_renderer is not None: + human_renderer(envelope) + else: + print(f"{envelope['command']}: {envelope['outcome']}") diff --git a/src/stewardship/schema_loader.py b/src/stewardship/schema_loader.py new file mode 100644 index 0000000..4379feb --- /dev/null +++ b/src/stewardship/schema_loader.py @@ -0,0 +1,83 @@ +"""Load bundled JSON Schemas (Draft 2020-12) as package resources and validate resources. + +Unknown-field rejection follows specification.md 22.2: fields prefixed with ``x-`` are an +open extension point and MUST be preserved by consumers, so they are stripped from a +working copy before schema validation and are never treated as "unknown normative fields". +``metadata.annotations`` is already an open object in the schemas and needs no stripping. +""" + +from __future__ import annotations + +import json +from copy import deepcopy +from functools import cache +from importlib import resources +from typing import Any + +import jsonschema + +_SCHEMA_FILES = { + "RepositoryContract": "repository-contract.schema.json", + "KnowledgeBase": "knowledge-base.schema.json", + "CatalogIndex": "catalog-index.schema.json", + "ContextBundle": "context-bundle.schema.json", + "RepoctlResult": "result-envelope.schema.json", + "RepoctlUserConfig": "user-config.schema.json", + "BootstrapPlan": "bootstrap-plan.schema.json", + "AdoptionAssessment": "adoption-assessment.schema.json", + "AdoptionPlan": "adoption-plan.schema.json", + "AdoptionReport": "adoption-report.schema.json", +} + + +class SchemaValidationError(ValueError): + def __init__(self, errors: list[str]): + super().__init__("; ".join(errors)) + self.errors = errors + + +@cache +def _load_schema(filename: str) -> dict[str, Any]: + package = resources.files("stewardship") + with resources.as_file(package.joinpath("schemas").joinpath(filename)) as path: + loaded: dict[str, Any] = json.loads(path.read_text(encoding="utf-8")) + return loaded + + +def _strip_extensions(value: Any) -> Any: + if isinstance(value, dict): + return { + key: _strip_extensions(item) + for key, item in value.items() + if not (isinstance(key, str) and key.startswith("x-")) + } + if isinstance(value, list): + return [_strip_extensions(item) for item in value] + return value + + +def schema_for_kind(kind: str) -> dict[str, Any]: + filename = _SCHEMA_FILES.get(kind) + if filename is None: + raise KeyError(f"No bundled schema for kind {kind!r}") + return _load_schema(filename) + + +def validate_against_kind(kind: str, data: dict[str, Any]) -> list[str]: + """Return a list of human-readable schema validation error messages (empty if valid).""" + schema = schema_for_kind(kind) + working = _strip_extensions(deepcopy(data)) + validator_cls = jsonschema.validators.validator_for(schema) + validator_cls.check_schema(schema) + validator = validator_cls(schema) + errors = [] + for error in sorted(validator.iter_errors(working), key=lambda e: list(e.absolute_path)): + location = "/".join(str(part) for part in error.absolute_path) or "" + errors.append(f"{location}: {error.message}") + return errors + + +def validate_against_kind_strict(kind: str, data: dict[str, Any]) -> None: + errors = validate_against_kind(kind, data) + if errors: + raise SchemaValidationError(errors) diff --git a/src/stewardship/schemas/adoption-assessment.schema.json b/src/stewardship/schemas/adoption-assessment.schema.json new file mode 100644 index 0000000..1e735eb --- /dev/null +++ b/src/stewardship/schemas/adoption-assessment.schema.json @@ -0,0 +1,84 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/adoption-assessment.schema.json", + "title": "AdoptionAssessment", + "type": "object", + "required": ["schema", "repository", "classification", "entrypoints", "knowledge", "proposedContentRoots", "collisions", "findings", "questions"], + "additionalProperties": false, + "properties": { + "schema": { "const": "stewardship/adoption-assessment@0.1" }, + "repository": { + "type": "object", + "required": ["path", "baselineRevision", "dirty"], + "additionalProperties": false, + "properties": { + "path": { "type": "string" }, + "baselineRevision": { "type": "string" }, + "dirty": { "type": "boolean" } + } + }, + "classification": { + "type": "object", + "required": ["proposedType", "confidence", "evidence", "confirmationRequired"], + "additionalProperties": false, + "properties": { + "proposedType": { "type": "string" }, + "confidence": { "enum": ["low", "medium", "high"] }, + "evidence": { "type": "array", "items": { "type": "string" } }, + "confirmationRequired": { "type": "boolean" } + } + }, + "entrypoints": { + "type": "object", + "additionalProperties": false, + "properties": { + "claude": { "type": ["string", "null"] }, + "portable": { "type": ["string", "null"] }, + "canonicalDirection": { "type": "string" } + } + }, + "knowledge": { + "type": "array", + "items": { + "type": "object", + "required": ["path", "format", "action"], + "additionalProperties": false, + "properties": { + "path": { "type": "string" }, + "format": { "type": "string" }, + "action": { "type": "string" } + } + } + }, + "proposedContentRoots": { + "type": "array", + "items": { + "type": "object", + "required": ["id", "path", "role", "authority"], + "additionalProperties": false, + "properties": { + "id": { "type": "string" }, + "path": { "type": "string" }, + "role": { "type": "string" }, + "authority": { "type": "string" } + } + } + }, + "collisions": { "type": "array", "items": { "type": "string" } }, + "findings": { + "type": "array", + "items": { + "type": "object", + "required": ["severity", "code"], + "additionalProperties": false, + "properties": { + "severity": { "enum": ["info", "warning", "error"] }, + "code": { "type": "string" }, + "path": { "type": "string" }, + "message": { "type": "string" } + } + } + }, + "questions": { "type": "array", "items": { "type": "string" } } + } +} diff --git a/src/stewardship/schemas/adoption-plan.schema.json b/src/stewardship/schemas/adoption-plan.schema.json new file mode 100644 index 0000000..7663491 --- /dev/null +++ b/src/stewardship/schemas/adoption-plan.schema.json @@ -0,0 +1,44 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/adoption-plan.schema.json", + "title": "AdoptionPlan", + "type": "object", + "required": ["schema", "repository", "baselineRevision", "strategy", "changes", "forbiddenChanges", "approval", "planHash"], + "additionalProperties": false, + "properties": { + "schema": { "const": "stewardship/adoption-plan@0.1" }, + "repository": { "type": "string" }, + "baselineRevision": { "type": "string" }, + "strategy": { "enum": ["overlay", "normalize"] }, + "recipe": { "type": "string" }, + "changes": { + "type": "array", + "items": { + "type": "object", + "required": ["action", "path"], + "additionalProperties": false, + "properties": { + "action": { "enum": ["create", "patch-managed-block", "preserve", "move"] }, + "path": { "type": "string" }, + "toPath": { "type": "string" }, + "ownership": { "type": "string" }, + "reason": { "type": "string" }, + "content": { "type": "string" }, + "optional": { "type": "boolean" } + } + } + }, + "forbiddenChanges": { "type": "array", "items": { "type": "string" } }, + "validations": { "type": "array", "items": { "type": "string" } }, + "approval": { + "type": "object", + "required": ["required"], + "additionalProperties": false, + "properties": { + "required": { "type": "boolean" }, + "planHash": { "type": "string" } + } + }, + "planHash": { "type": "string" } + } +} diff --git a/src/stewardship/schemas/adoption-report.schema.json b/src/stewardship/schemas/adoption-report.schema.json new file mode 100644 index 0000000..1cf8ff9 --- /dev/null +++ b/src/stewardship/schemas/adoption-report.schema.json @@ -0,0 +1,18 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/adoption-report.schema.json", + "title": "AdoptionReport", + "type": "object", + "required": ["schema", "repository", "baselineRevision", "compatibilityLevel", "outcome", "changedPaths", "preservedPaths", "unresolvedFindings"], + "additionalProperties": false, + "properties": { + "schema": { "const": "stewardship/adoption-report@0.1" }, + "repository": { "type": "string" }, + "baselineRevision": { "type": "string" }, + "compatibilityLevel": { "type": "string" }, + "outcome": { "enum": ["pass", "pass-with-warnings", "fail"] }, + "changedPaths": { "type": "array", "items": { "type": "string" } }, + "preservedPaths": { "type": "array", "items": { "type": "string" } }, + "unresolvedFindings": { "type": "array", "items": { "type": "string" } } + } +} diff --git a/src/stewardship/schemas/bootstrap-plan.schema.json b/src/stewardship/schemas/bootstrap-plan.schema.json new file mode 100644 index 0000000..05300a6 --- /dev/null +++ b/src/stewardship/schemas/bootstrap-plan.schema.json @@ -0,0 +1,29 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/bootstrap-plan.schema.json", + "title": "BootstrapPlan", + "type": "object", + "required": ["schema", "repository", "files", "planHash"], + "additionalProperties": false, + "properties": { + "schema": { "const": "stewardship/bootstrap-plan@0.1" }, + "repository": { "type": "string" }, + "repositoryType": { "type": "string" }, + "createdAt": { "type": "string" }, + "gitInit": { "type": "boolean" }, + "files": { + "type": "array", + "items": { + "type": "object", + "required": ["path", "content"], + "additionalProperties": false, + "properties": { + "path": { "type": "string" }, + "content": { "type": "string" } + } + } + }, + "recommendations": { "type": "array", "items": { "type": "string" } }, + "planHash": { "type": "string" } + } +} diff --git a/src/stewardship/schemas/catalog-index.schema.json b/src/stewardship/schemas/catalog-index.schema.json new file mode 100644 index 0000000..9047f2f --- /dev/null +++ b/src/stewardship/schemas/catalog-index.schema.json @@ -0,0 +1,55 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/catalog-index.schema.json", + "title": "CatalogIndex", + "type": "object", + "required": ["apiVersion", "kind", "metadata", "spec"], + "additionalProperties": false, + "properties": { + "apiVersion": { "const": "stewardship.corsus.ru/v1alpha1" }, + "kind": { "const": "CatalogIndex" }, + "metadata": { + "type": "object", + "required": ["name"], + "additionalProperties": false, + "properties": { "name": { "type": "string" } } + }, + "spec": { + "type": "object", + "required": ["generatedAt", "roots", "repositories", "relations"], + "additionalProperties": false, + "properties": { + "generatedAt": { "type": "string" }, + "roots": { "type": "array", "items": { "type": "string" } }, + "repositories": { + "type": "array", + "items": { + "type": "object", + "required": ["ref", "path", "type", "lifecycle", "contractHash"], + "additionalProperties": false, + "properties": { + "ref": { "type": "string" }, + "path": { "type": "string" }, + "type": { "type": "string" }, + "lifecycle": { "type": "string" }, + "contractHash": { "type": "string" } + } + } + }, + "relations": { + "type": "array", + "items": { + "type": "object", + "required": ["from", "type", "to"], + "additionalProperties": false, + "properties": { + "from": { "type": "string" }, + "type": { "type": "string" }, + "to": { "type": "string" } + } + } + } + } + } + } +} diff --git a/src/stewardship/schemas/context-bundle.schema.json b/src/stewardship/schemas/context-bundle.schema.json new file mode 100644 index 0000000..f2ca879 --- /dev/null +++ b/src/stewardship/schemas/context-bundle.schema.json @@ -0,0 +1,36 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/context-bundle.schema.json", + "title": "ContextBundle", + "type": "object", + "required": ["apiVersion", "kind", "metadata", "spec"], + "additionalProperties": false, + "properties": { + "apiVersion": { "const": "stewardship.corsus.ru/v1alpha1" }, + "kind": { "const": "ContextBundle" }, + "metadata": { + "type": "object", + "required": ["name"], + "additionalProperties": false, + "properties": { "name": { "type": "string" } } + }, + "spec": { + "type": "object", + "required": ["generatedAt", "intent", "repository", "summary", "warnings"], + "additionalProperties": false, + "properties": { + "generatedAt": { "type": "string" }, + "intent": { "type": "string" }, + "repository": { "type": "string" }, + "contractRevision": { "type": "string" }, + "summary": { "type": "string" }, + "contentRoots": { "type": "array", "items": { "type": "string" } }, + "operations": { "type": "array", "items": { "type": "string" } }, + "topics": { "type": "array", "items": { "type": "string" } }, + "documents": { "type": "array", "items": { "type": "string" } }, + "materialized": { "type": "array", "items": { "type": "object" } }, + "warnings": { "type": "array", "items": { "type": "string" } } + } + } + } +} diff --git a/src/stewardship/schemas/knowledge-base.schema.json b/src/stewardship/schemas/knowledge-base.schema.json new file mode 100644 index 0000000..196398e --- /dev/null +++ b/src/stewardship/schemas/knowledge-base.schema.json @@ -0,0 +1,91 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/knowledge-base.schema.json", + "title": "KnowledgeBase", + "type": "object", + "required": ["apiVersion", "kind", "metadata", "spec"], + "additionalProperties": false, + "properties": { + "apiVersion": { "const": "stewardship.corsus.ru/v1alpha1" }, + "kind": { "const": "KnowledgeBase" }, + "metadata": { + "type": "object", + "required": ["name"], + "additionalProperties": false, + "properties": { + "name": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "title": { "type": "string" }, + "owners": { "type": "array", "items": { "type": "string" } }, + "labels": { "type": "object", "additionalProperties": { "type": "string" } }, + "annotations": { "type": "object" } + } + }, + "spec": { + "type": "object", + "required": ["repository", "topics", "documents"], + "additionalProperties": false, + "properties": { + "repository": { "type": "string" }, + "defaultLanguage": { "type": "string" }, + "topics": { "type": "array", "items": { "$ref": "#/$defs/topic" } }, + "documents": { "type": "array", "items": { "$ref": "#/$defs/document" } } + } + } + }, + "$defs": { + "topic": { + "type": "object", + "required": ["id", "summary", "intents"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "title": { "type": "string" }, + "summary": { "type": "string" }, + "intents": { "type": "array", "items": { "type": "string" }, "minItems": 1 }, + "keywords": { "type": "array", "items": { "type": "string" } }, + "priority": { "type": "integer", "minimum": 0, "maximum": 100 }, + "documents": { "type": "array", "items": { "type": "string" } }, + "relatedTopics": { "type": "array", "items": { "type": "string" } }, + "data": { "type": "object" } + } + }, + "document": { + "type": "object", + "required": ["id", "role", "authority", "status"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "title": { "type": "string" }, + "role": { + "enum": ["tutorial", "how-to", "reference", "explanation", "runbook", "vendor-source", "evidence"] + }, + "path": { "type": "string" }, + "uri": { "type": "string", "format": "uri" }, + "mediaType": { "type": "string" }, + "authority": { "enum": ["vendor", "local-canonical", "observed", "derived", "manual"] }, + "status": { "enum": ["verified", "manual", "draft", "stale"] }, + "provenance": { + "type": "object", + "additionalProperties": false, + "properties": { + "uri": { "type": "string" }, + "vendor": { "type": "string" }, + "version": { "type": "string" }, + "retrievedAt": { "type": "string" }, + "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" }, + "license": { "type": "string" } + } + }, + "freshness": { + "type": "object", + "additionalProperties": false, + "properties": { + "verifiedAt": { "type": "string" }, + "expiresAt": { "type": "string" }, + "verificationOperation": { "type": "string" } + } + } + } + } + } +} diff --git a/src/stewardship/schemas/repository-contract.schema.json b/src/stewardship/schemas/repository-contract.schema.json new file mode 100644 index 0000000..d4e6844 --- /dev/null +++ b/src/stewardship/schemas/repository-contract.schema.json @@ -0,0 +1,176 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/repository-contract.schema.json", + "title": "RepositoryContract", + "type": "object", + "required": ["apiVersion", "kind", "metadata", "spec"], + "additionalProperties": false, + "properties": { + "apiVersion": { "const": "stewardship.corsus.ru/v1alpha1" }, + "kind": { "const": "RepositoryContract" }, + "metadata": { "$ref": "#/$defs/metadata" }, + "spec": { + "type": "object", + "required": ["summary", "repository"], + "additionalProperties": false, + "properties": { + "summary": { "type": "string", "minLength": 1 }, + "repository": { + "type": "object", + "required": ["type", "lifecycle"], + "additionalProperties": false, + "properties": { + "type": { "enum": ["infrastructure-config", "service-config", "software", "project"] }, + "lifecycle": { "enum": ["production", "active", "experimental", "stub", "archive", "external"] }, + "namespace": { "type": "string" }, + "access": { "enum": ["public", "internal", "restricted"] } + } + }, + "template": { + "type": "object", + "required": ["id", "version"], + "additionalProperties": false, + "properties": { + "id": { "type": "string" }, + "version": { "type": "string" }, + "source": { "type": "string" }, + "revision": { "type": "string" }, + "answersRef": { "type": "string" }, + "mode": { "enum": ["generated", "adopted-overlay"] }, + "managedPaths": { "type": "array", "items": { "type": "string" } } + } + }, + "agent": { + "type": "object", + "additionalProperties": false, + "properties": { + "primary": { "type": "string" }, + "portable": { "type": "string" } + } + }, + "knowledge": { + "type": "object", + "additionalProperties": false, + "properties": { + "entrypoint": { "type": "string" } + } + }, + "contentRoots": { + "type": "array", + "items": { "$ref": "#/$defs/contentRoot" } + }, + "provides": { + "type": "array", + "items": { "$ref": "#/$defs/capability" } + }, + "requires": { + "type": "array", + "items": { "$ref": "#/$defs/requirement" } + }, + "bindings": { + "type": "array", + "items": { "$ref": "#/$defs/binding" } + }, + "operations": { + "type": "array", + "items": { "$ref": "#/$defs/operation" } + } + } + } + }, + "$defs": { + "metadata": { + "type": "object", + "required": ["name"], + "additionalProperties": false, + "properties": { + "name": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "title": { "type": "string" }, + "owners": { "type": "array", "items": { "type": "string" } }, + "labels": { "type": "object", "additionalProperties": { "type": "string" } }, + "annotations": { "type": "object" } + } + }, + "contentRoot": { + "type": "object", + "required": ["id", "role", "path", "kind", "authority"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "role": { "type": "string" }, + "path": { "type": "string" }, + "kind": { "enum": ["directory", "file", "file-set", "manifest"] }, + "authority": { "enum": ["source", "generated", "observed", "mirror", "evidence"] }, + "writePolicy": { "enum": ["managed", "read-only", "generated"] }, + "selector": { "type": "string" }, + "format": { "type": "string" }, + "environments": { "type": "array", "items": { "type": "string" } }, + "generatedFrom": { "type": "array", "items": { "type": "string" } } + } + }, + "capability": { + "type": "object", + "required": ["id", "capability"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "capability": { "type": "string" }, + "summary": { "type": "string" }, + "parametersSchema": { "type": "string" } + } + }, + "requirement": { + "type": "object", + "required": ["id", "capability"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "capability": { "type": "string" }, + "summary": { "type": "string" }, + "constraints": { "type": "object" }, + "preferredProviders": { "type": "array", "items": { "type": "string" } }, + "acceptance": { "type": "array", "items": { "type": "string" } } + } + }, + "binding": { + "type": "object", + "required": ["id", "requirement", "target", "status"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "requirement": { "type": "string" }, + "target": { "type": "string" }, + "status": { "enum": ["proposed", "active", "failed", "retired"] }, + "evidenceRef": { "type": "string" } + } + }, + "operation": { + "type": "object", + "required": ["id", "phase", "effect", "risk"], + "additionalProperties": false, + "properties": { + "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" }, + "title": { "type": "string" }, + "intents": { "type": "array", "items": { "type": "string" } }, + "phase": { + "enum": ["describe", "inspect", "snapshot", "validate", "diff", "plan", "apply", "verify", "reconcile", "rollback"] + }, + "effect": { "enum": ["read-only", "local-write", "external-write", "disruptive", "destructive"] }, + "risk": { "enum": ["low", "medium", "high", "critical"] }, + "execution": { + "type": "object", + "required": ["handler"], + "additionalProperties": false, + "properties": { + "handler": { "type": "string" }, + "argv": { "type": "array", "items": { "type": "string" } } + } + }, + "inputSchema": { "type": "string" }, + "outputSchema": { "type": "string" }, + "preconditions": { "type": "array", "items": { "type": "string" } }, + "approval": { "enum": ["never", "on-write", "always"] } + } + } + } +} diff --git a/src/stewardship/schemas/result-envelope.schema.json b/src/stewardship/schemas/result-envelope.schema.json new file mode 100644 index 0000000..ac4d585 --- /dev/null +++ b/src/stewardship/schemas/result-envelope.schema.json @@ -0,0 +1,29 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/repoctl-result.schema.json", + "title": "RepoctlResult", + "type": "object", + "required": ["schema", "command", "outcome", "data", "findings"], + "additionalProperties": false, + "properties": { + "schema": { "const": "stewardship/repoctl-result@0.1" }, + "command": { "type": "string" }, + "outcome": { "enum": ["success", "failure"] }, + "data": {}, + "findings": { + "type": "array", + "items": { + "type": "object", + "required": ["severity", "code", "message"], + "additionalProperties": false, + "properties": { + "severity": { "enum": ["info", "warning", "error"] }, + "code": { "type": "string" }, + "message": { "type": "string" }, + "resource": { "type": "string" }, + "path": { "type": "string" } + } + } + } + } +} diff --git a/src/stewardship/schemas/user-config.schema.json b/src/stewardship/schemas/user-config.schema.json new file mode 100644 index 0000000..4b917da --- /dev/null +++ b/src/stewardship/schemas/user-config.schema.json @@ -0,0 +1,12 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://stewardship.corsus.ru/schemas/v1alpha1/repoctl-config.schema.json", + "title": "RepoctlUserConfig", + "type": "object", + "required": ["schema"], + "additionalProperties": false, + "properties": { + "schema": { "const": "stewardship/repoctl-config@0.1" }, + "roots": { "type": "array", "items": { "type": "string" }, "uniqueItems": true } + } +} diff --git a/src/stewardship/skills_content.py b/src/stewardship/skills_content.py new file mode 100644 index 0000000..db481d6 --- /dev/null +++ b/src/stewardship/skills_content.py @@ -0,0 +1,82 @@ +"""Shared text for the three Claude project skills that ship with every bootstrap. + +Skills are thin wrappers: they call `repoctl` with machine output and explain findings. +They must never duplicate repoctl's classification, generation or validation logic. +""" + +from __future__ import annotations + +REPOSITORY_BOOTSTRAP_SKILL = """--- +name: repository-bootstrap +description: Bootstrap a new repository into Repository Stewardship using repoctl init. Use when creating a new repository or scaffolding ops/contract.yaml, kdb/kdb.yaml and agent entrypoints from scratch. +--- + +# repository-bootstrap + +Thin wrapper around `repoctl init`. Do not reimplement classification, template +rendering or validation here — call the CLI and explain its output. + +## Procedure + +1. Collect the missing decisions from the user: repository type + (`infrastructure-config` | `service-config` | `software` | `project`), `metadata.name`, + `title`, `owners`, `lifecycle`. +2. Run `repoctl init --repo --answers --output json` to obtain a + `BootstrapPlan` (this performs no writes). +3. Show the user the planned files and the `planHash`. +4. Only after explicit approval, run + `repoctl init --repo --apply --plan --approve `. +5. Report the resulting `repoctl validate --repo ` findings. + +Never invent files outside the plan and never skip the approval step. +""" + +REPOSITORY_ADOPTION_SKILL = """--- +name: repository-adoption +description: Assess and adopt an existing repository into Repository Stewardship using repoctl adopt. Use when connecting an existing, non-templated repository without moving its domain content. +--- + +# repository-adoption + +Thin wrapper around `repoctl adopt`. The canonical procedure is +`docs/adoption-runbook.md`; this skill only collects missing decisions, calls the CLI +with machine output, and explains findings. It must not duplicate the runbook logic. + +## Procedure + +1. Run `repoctl adopt --repo --mode assess --output json` (read-only). +2. Present the classification, detected content roots, and any `questions` that need + owner confirmation. +3. Run `repoctl adopt --repo --mode plan --output json` once open questions are + resolved. This is still read-only and returns an `AdoptionPlan` with a `planHash`. +4. Show the full plan (files created, patched managed blocks, preserved paths, + forbidden changes) before asking for approval. +5. Only after explicit approval, run + `repoctl adopt --repo --mode apply --plan --approve `. +6. Run `repoctl adopt --repo --mode verify --output json` and report the + `AdoptionReport`, including any `unresolvedFindings`. + +Default strategy is `overlay`. Only use `--strategy normalize --recipe +documents-to-content-root` when the owner explicitly asks to reorganize root documents. +""" + +REPO_HANDOFF_SKILL = """--- +name: repo-handoff +description: Produce a minimal, intent-scoped context handoff for a repository using repoctl context. Use when another agent, session or teammate needs just enough context to work on one task in a repository. +--- + +# repo-handoff + +Thin wrapper around `repoctl context`. Do not read the full repository or the full KDB +by hand when this skill applies — let `repoctl` perform the selection. + +## Procedure + +1. Turn the user's request into an `intent` id (e.g. `container.deploy`, + `repository.adopt`), not a literal command. +2. Run `repoctl context --repo --intent --output json`. +3. If the bundle looks incomplete, retry with `--include-related` or `--materialize` + and an explicit `--budget-bytes`. +4. Hand the resulting `ContextBundle` (and any `warnings`) to the requester instead of + pasting raw repository files. +""" diff --git a/src/stewardship/types.py b/src/stewardship/types.py new file mode 100644 index 0000000..ac4df04 --- /dev/null +++ b/src/stewardship/types.py @@ -0,0 +1,24 @@ +from __future__ import annotations + +from dataclasses import asdict, dataclass +from typing import Any + + +@dataclass(frozen=True) +class Finding: + severity: str + code: str + message: str + resource: str | None = None + path: str | None = None + + def to_dict(self) -> dict[str, Any]: + return {key: value for key, value in asdict(self).items() if value is not None} + + +def sort_findings(findings: list[Finding]) -> list[Finding]: + rank = {"error": 0, "warning": 1, "info": 2} + return sorted( + findings, + key=lambda item: (rank.get(item.severity, 9), item.resource or "", item.path or "", item.code), + ) diff --git a/src/stewardship/validate.py b/src/stewardship/validate.py new file mode 100644 index 0000000..7a72cf7 --- /dev/null +++ b/src/stewardship/validate.py @@ -0,0 +1,416 @@ +"""`repoctl validate`: schema, path-safety, reference and Markdown checks for one repository.""" + +from __future__ import annotations + +import fnmatch +import re +from dataclasses import dataclass +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from . import markdown +from .clock import DEFAULT_CLOCK +from .constants import CONTRACT_PATH, ID_PATTERN, SECRET_KEYS +from .io import ResourceError, load_yaml +from .paths import PathViolation, confined_path, normalize_resource_path +from .schema_loader import validate_against_kind +from .types import Finding, sort_findings + +_ID_RE = re.compile(ID_PATTERN) +_SHELL_CHARS = set("|&;<>$`\n\r") + + +@dataclass +class RepositoryValidation: + root: Path + contract: dict[str, Any] | None + kdb: dict[str, Any] | None + findings: list[Finding] + + @property + def ok(self) -> bool: + return not any(item.severity == "error" for item in self.findings) + + +def validate_repository(root: Path) -> RepositoryValidation: + findings: list[Finding] = [] + contract_path = root / CONTRACT_PATH + contract: dict[str, Any] | None = None + kdb: dict[str, Any] | None = None + + if not contract_path.exists(): + findings.append( + Finding("error", "CONTRACT_MISSING", f"{CONTRACT_PATH} does not exist") + ) + return RepositoryValidation(root, None, None, sort_findings(findings)) + + try: + contract = load_yaml(contract_path) + except ResourceError as exc: + findings.append(Finding("error", "CONTRACT_PARSE_ERROR", str(exc), path=CONTRACT_PATH)) + return RepositoryValidation(root, None, None, sort_findings(findings)) + + if not isinstance(contract, dict): + findings.append( + Finding("error", "CONTRACT_NOT_MAPPING", "Contract root must be a mapping", path=CONTRACT_PATH) + ) + return RepositoryValidation(root, None, None, sort_findings(findings)) + + resource_name = f"repo:{contract.get('metadata', {}).get('name', '?')}" + + if contract.get("apiVersion") != "stewardship.corsus.ru/v1alpha1": + findings.append( + Finding( + "error", + "CONTRACT_API_VERSION_UNKNOWN", + f"Unknown or missing apiVersion: {contract.get('apiVersion')!r}", + resource=resource_name, + path="apiVersion", + ) + ) + if contract.get("kind") != "RepositoryContract": + findings.append( + Finding( + "error", + "CONTRACT_KIND_UNEXPECTED", + f"Expected kind RepositoryContract, found {contract.get('kind')!r}", + resource=resource_name, + path="kind", + ) + ) + + for message in validate_against_kind("RepositoryContract", contract): + findings.append( + Finding("error", "CONTRACT_SCHEMA_INVALID", message, resource=resource_name, path=message.split(":", 1)[0]) + ) + + spec = contract.get("spec", {}) if isinstance(contract.get("spec"), dict) else {} + + findings.extend(_check_ids(spec, resource_name)) + findings.extend(_check_content_root_paths(root, spec, resource_name)) + findings.extend(_check_operations(root, spec, resource_name)) + findings.extend(_check_secrets(contract, resource_name, "contract")) + + kdb_rel = None + knowledge = spec.get("knowledge") if isinstance(spec.get("knowledge"), dict) else None + if knowledge and knowledge.get("entrypoint"): + kdb_rel = knowledge["entrypoint"] + lifecycle = (spec.get("repository") or {}).get("lifecycle") + try: + kdb_path = confined_path(root, kdb_rel) + except PathViolation as exc: + findings.append( + Finding("error", "CONTRACT_PATH_OUTSIDE_REPOSITORY", str(exc), resource=resource_name, path="spec.knowledge.entrypoint") + ) + kdb_path = None + if kdb_path is not None: + if not kdb_path.exists(): + if lifecycle != "stub": + findings.append( + Finding( + "error", + "KNOWLEDGE_ENTRYPOINT_MISSING", + f"KDB entrypoint does not exist: {kdb_rel}", + resource=resource_name, + path="spec.knowledge.entrypoint", + ) + ) + else: + kdb, kdb_findings = _validate_kdb(root, kdb_path, kdb_rel, resource_name) + findings.extend(kdb_findings) + + for entry_field, entry_path in (("primary", "agent.primary"), ("portable", "agent.portable")): + agent_raw = spec.get("agent") + agent: dict[str, Any] = agent_raw if isinstance(agent_raw, dict) else {} + rel = agent.get(entry_field) + if rel: + full = root / rel + if not full.exists(): + findings.append( + Finding("warning", "AGENT_ENTRYPOINT_MISSING", f"{rel} does not exist", resource=resource_name, path=f"spec.{entry_path}") + ) + elif full.suffix.lower() == ".md": + findings.extend(markdown.check_markdown_file(root, rel)) + + for extra in ("README.md",): + if (root / extra).exists(): + findings.extend(markdown.check_markdown_file(root, extra)) + + return RepositoryValidation(root, contract, kdb, sort_findings(findings)) + + +def _check_ids(spec: dict[str, Any], resource_name: str) -> list[Finding]: + findings: list[Finding] = [] + for collection_name in ("contentRoots", "provides", "requires", "bindings", "operations"): + items = spec.get(collection_name) + if not isinstance(items, list): + continue + seen: set[str] = set() + for item in items: + if not isinstance(item, dict): + continue + item_id = item.get("id") + if not isinstance(item_id, str) or not _ID_RE.match(item_id): + findings.append( + Finding( + "error", + "ID_FORMAT_INVALID", + f"Invalid id in {collection_name}: {item_id!r}", + resource=resource_name, + path=f"spec.{collection_name}", + ) + ) + continue + if item_id in seen: + findings.append( + Finding( + "error", + "ID_DUPLICATE", + f"Duplicate id {item_id!r} in {collection_name}", + resource=resource_name, + path=f"spec.{collection_name}", + ) + ) + seen.add(item_id) + return findings + + +def _check_content_root_paths(root: Path, spec: dict[str, Any], resource_name: str) -> list[Finding]: + findings: list[Finding] = [] + lifecycle = (spec.get("repository") or {}).get("lifecycle") + for index, item in enumerate(spec.get("contentRoots") or []): + if not isinstance(item, dict): + continue + raw_path = item.get("path") + try: + confined = confined_path(root, raw_path) if isinstance(raw_path, str) else None + except PathViolation as exc: + findings.append( + Finding( + "error", + "CONTRACT_PATH_OUTSIDE_REPOSITORY", + str(exc), + resource=resource_name, + path=f"spec.contentRoots[{index}].path", + ) + ) + continue + if confined is not None and not confined.exists() and lifecycle != "stub": + findings.append( + Finding( + "warning", + "CONTENT_ROOT_PATH_MISSING", + f"contentRoots[{index}] path does not exist: {raw_path}", + resource=resource_name, + path=f"spec.contentRoots[{index}].path", + ) + ) + return findings + + +def _check_operations(root: Path, spec: dict[str, Any], resource_name: str) -> list[Finding]: + findings: list[Finding] = [] + for index, op in enumerate(spec.get("operations") or []): + if not isinstance(op, dict): + continue + execution = op.get("execution") + if not isinstance(execution, dict): + continue + handler = execution.get("handler") + if isinstance(handler, str): + try: + normalize_resource_path(handler) + except PathViolation as exc: + findings.append( + Finding( + "error", + "OPERATION_HANDLER_PATH_UNSAFE", + str(exc), + resource=resource_name, + path=f"spec.operations[{index}].execution.handler", + ) + ) + if any(ch in _SHELL_CHARS for ch in handler): + findings.append( + Finding( + "error", + "OPERATION_HANDLER_SHELL_STRING", + "Handler path must not contain shell metacharacters", + resource=resource_name, + path=f"spec.operations[{index}].execution.handler", + ) + ) + for token in execution.get("argv") or []: + if isinstance(token, str) and any(ch in _SHELL_CHARS for ch in token): + findings.append( + Finding( + "error", + "OPERATION_ARGV_SHELL_STRING", + f"argv token looks like a shell string: {token!r}", + resource=resource_name, + path=f"spec.operations[{index}].execution.argv", + ) + ) + return findings + + +def _check_secrets(data: Any, resource_name: str, top_path: str) -> list[Finding]: + findings: list[Finding] = [] + + def walk(value: Any, path: str) -> None: + if isinstance(value, dict): + for key, item in value.items(): + key_norm = str(key).lower().replace("_", "").replace("-", "") + if key_norm in SECRET_KEYS and isinstance(item, str) and item.strip(): + findings.append( + Finding( + "error", + "SECRET_SHAPED_FIELD", + f"Field looks like a secret value: {key}", + resource=resource_name, + path=f"{path}.{key}" if path else str(key), + ) + ) + continue + walk(item, f"{path}.{key}" if path else str(key)) + elif isinstance(value, list): + for i, item in enumerate(value): + walk(item, f"{path}[{i}]") + + walk(data, top_path) + return findings + + +def _validate_kdb( + root: Path, kdb_path: Path, kdb_rel: str, contract_resource: str +) -> tuple[dict[str, Any] | None, list[Finding]]: + findings: list[Finding] = [] + try: + kdb = load_yaml(kdb_path) + except ResourceError as exc: + return None, [Finding("error", "KNOWLEDGE_PARSE_ERROR", str(exc), path=kdb_rel)] + if not isinstance(kdb, dict): + return None, [Finding("error", "KNOWLEDGE_NOT_MAPPING", "KDB root must be a mapping", path=kdb_rel)] + + kdb_resource = f"repo:{kdb.get('spec', {}).get('repository', '?')}" + + if kdb.get("kind") != "KnowledgeBase": + findings.append(Finding("error", "KNOWLEDGE_KIND_UNEXPECTED", f"Expected kind KnowledgeBase, found {kdb.get('kind')!r}", resource=kdb_resource, path=kdb_rel)) + + for message in validate_against_kind("KnowledgeBase", kdb): + findings.append(Finding("error", "KNOWLEDGE_SCHEMA_INVALID", message, resource=kdb_resource, path=kdb_rel)) + + kdb_spec = kdb.get("spec", {}) if isinstance(kdb.get("spec"), dict) else {} + topics = kdb_spec.get("topics") or [] + documents = kdb_spec.get("documents") or [] + + topic_ids: set[Any] = {t.get("id") for t in topics if isinstance(t, dict)} + doc_ids: dict[Any, dict[str, Any]] = {d.get("id"): d for d in documents if isinstance(d, dict)} + + seen_topic_ids: set[Any] = set() + for topic in topics: + if not isinstance(topic, dict): + continue + tid = topic.get("id") + if tid in seen_topic_ids: + findings.append(Finding("error", "ID_DUPLICATE", f"Duplicate topic id {tid!r}", resource=kdb_resource, path=kdb_rel)) + seen_topic_ids.add(tid) + for doc_id in topic.get("documents") or []: + if doc_id not in doc_ids: + findings.append( + Finding( + "error", + "KNOWLEDGE_TOPIC_DOCUMENT_MISSING", + f"Topic {tid!r} references unknown document {doc_id!r}", + resource=kdb_resource, + path=kdb_rel, + ) + ) + for related in topic.get("relatedTopics") or []: + if related not in topic_ids: + findings.append( + Finding( + "warning", + "KNOWLEDGE_RELATED_TOPIC_MISSING", + f"Topic {tid!r} references unknown relatedTopic {related!r}", + resource=kdb_resource, + path=kdb_rel, + ) + ) + + seen_doc_ids: set[Any] = set() + for doc in documents: + if not isinstance(doc, dict): + continue + did = doc.get("id") + if did in seen_doc_ids: + findings.append(Finding("error", "ID_DUPLICATE", f"Duplicate document id {did!r}", resource=kdb_resource, path=kdb_rel)) + seen_doc_ids.add(did) + has_path = bool(doc.get("path")) + has_uri = bool(doc.get("uri")) + if has_path == has_uri: + findings.append( + Finding( + "error", + "KNOWLEDGE_DOCUMENT_PATH_XOR_URI", + f"Document {did!r} must set exactly one of path/uri", + resource=kdb_resource, + path=kdb_rel, + ) + ) + if has_path: + doc_path = doc["path"] + try: + confined = confined_path(root, doc_path) + except PathViolation as exc: + findings.append(Finding("error", "CONTRACT_PATH_OUTSIDE_REPOSITORY", str(exc), resource=kdb_resource, path=kdb_rel)) + confined = None + if confined is not None: + if not confined.exists(): + findings.append( + Finding("error", "KNOWLEDGE_DOCUMENT_PATH_MISSING", f"Document {did!r} path does not exist: {doc_path}", resource=kdb_resource, path=kdb_rel) + ) + elif confined.suffix.lower() == ".md": + findings.extend(markdown.check_markdown_file(root, doc_path)) + + freshness = doc.get("freshness") if isinstance(doc.get("freshness"), dict) else None + if freshness and freshness.get("expiresAt"): + try: + expires = _parse_dt(freshness["expiresAt"]) + if expires <= DEFAULT_CLOCK.now(): + findings.append( + Finding( + "warning", + "KNOWLEDGE_DOCUMENT_STALE", + f"Document {did!r} freshness expired at {freshness['expiresAt']}", + resource=kdb_resource, + path=kdb_rel, + ) + ) + except ValueError: + findings.append( + Finding("warning", "KNOWLEDGE_FRESHNESS_UNPARSEABLE", f"Cannot parse expiresAt for document {did!r}", resource=kdb_resource, path=kdb_rel) + ) + provenance = doc.get("provenance") if isinstance(doc.get("provenance"), dict) else None + if provenance and provenance.get("sha256") and not re.fullmatch(r"[0-9a-f]{64}", provenance["sha256"]): + findings.append( + Finding("error", "KNOWLEDGE_PROVENANCE_HASH_INVALID", f"Document {did!r} sha256 must be 64 lowercase hex chars", resource=kdb_resource, path=kdb_rel) + ) + + findings.extend(_check_secrets(kdb, kdb_resource, kdb_rel)) + return kdb, findings + + +def _parse_dt(value: str) -> datetime: + text = value.replace("Z", "+00:00") + dt = datetime.fromisoformat(text) + if dt.tzinfo is None: + dt = dt.replace(tzinfo=UTC) + return dt + + +def content_root_files(root: Path, selector_root: Path, selector: str | None) -> list[Path]: + if selector is None: + return [selector_root] if selector_root.is_file() else list(selector_root.rglob("*")) + return [p for p in selector_root.rglob("*") if p.is_file() and fnmatch.fnmatch(p.relative_to(selector_root).as_posix(), selector)] diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..b30182d --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,48 @@ +from __future__ import annotations + +import shutil +import subprocess +from pathlib import Path + +import pytest + +FIXTURES = Path(__file__).parent / "fixtures" + + +def _git_init(repo: Path) -> None: + subprocess.run(["git", "init", "-q"], cwd=repo, check=True) + subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=repo, check=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=repo, check=True) + subprocess.run(["git", "add", "-A"], cwd=repo, check=True) + subprocess.run(["git", "commit", "-q", "-m", "fixture baseline"], cwd=repo, check=True) + + +def materialize_fixture(tmp_path: Path, relative: str, *, git: bool = True) -> Path: + src = FIXTURES / relative + dest = tmp_path / Path(relative).name + shutil.copytree(src, dest) + if git: + _git_init(dest) + return dest + + +@pytest.fixture +def make_repo(tmp_path): + def _make(relative: str, *, git: bool = True) -> Path: + return materialize_fixture(tmp_path, relative, git=git) + + return _make + + +@pytest.fixture +def negative_repo(tmp_path): + """Materialize a negative//contract.yaml fixture as ops/contract.yaml under a fresh repo.""" + + def _make(name: str) -> Path: + dest = tmp_path / name + (dest / "ops").mkdir(parents=True) + shutil.copy(FIXTURES / "negative" / name / "contract.yaml", dest / "ops" / "contract.yaml") + _git_init(dest) + return dest + + return _make diff --git a/tests/fixtures/adoption/antivirus-legacy/kdb/kdb.yaml b/tests/fixtures/adoption/antivirus-legacy/kdb/kdb.yaml new file mode 100644 index 0000000..6fc12d2 --- /dev/null +++ b/tests/fixtures/adoption/antivirus-legacy/kdb/kdb.yaml @@ -0,0 +1,2 @@ +custom_format: true +notes: Pre-existing custom knowledge base that already occupies kdb/kdb.yaml diff --git a/tests/fixtures/adoption/antivirus-legacy/policies/.gitkeep b/tests/fixtures/adoption/antivirus-legacy/policies/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/adoption/lxd-legacy/kdb.yaml b/tests/fixtures/adoption/lxd-legacy/kdb.yaml new file mode 100644 index 0000000..589e607 --- /dev/null +++ b/tests/fixtures/adoption/lxd-legacy/kdb.yaml @@ -0,0 +1,2 @@ +windows_agent_rollout: + summary: Legacy root-level knowledge base, predates Repository Stewardship diff --git a/tests/fixtures/adoption/lxd-legacy/profiles-source/default.yaml b/tests/fixtures/adoption/lxd-legacy/profiles-source/default.yaml new file mode 100644 index 0000000..7936746 --- /dev/null +++ b/tests/fixtures/adoption/lxd-legacy/profiles-source/default.yaml @@ -0,0 +1,2 @@ +name: default +config: {} diff --git a/tests/fixtures/adoption/lxd-legacy/profiles/default.yaml b/tests/fixtures/adoption/lxd-legacy/profiles/default.yaml new file mode 100644 index 0000000..7936746 --- /dev/null +++ b/tests/fixtures/adoption/lxd-legacy/profiles/default.yaml @@ -0,0 +1,2 @@ +name: default +config: {} diff --git a/tests/fixtures/negative/absolute-path/contract.yaml b/tests/fixtures/negative/absolute-path/contract.yaml new file mode 100644 index 0000000..93201ba --- /dev/null +++ b/tests/fixtures/negative/absolute-path/contract.yaml @@ -0,0 +1,15 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: bad-absolute-path +spec: + summary: Content root uses an absolute/UNC-shaped path + repository: + type: project + lifecycle: stub + contentRoots: + - id: absolute + role: documentation + path: "/etc/passwd" + kind: file + authority: source diff --git a/tests/fixtures/negative/duplicate-ids/contract.yaml b/tests/fixtures/negative/duplicate-ids/contract.yaml new file mode 100644 index 0000000..e5bf667 --- /dev/null +++ b/tests/fixtures/negative/duplicate-ids/contract.yaml @@ -0,0 +1,20 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: bad-duplicate-ids +spec: + summary: Has duplicate content root ids + repository: + type: project + lifecycle: stub + contentRoots: + - id: docs + role: documentation + path: docs + kind: directory + authority: source + - id: docs + role: documentation + path: docs2 + kind: directory + authority: source diff --git a/tests/fixtures/negative/path-traversal/contract.yaml b/tests/fixtures/negative/path-traversal/contract.yaml new file mode 100644 index 0000000..336f09c --- /dev/null +++ b/tests/fixtures/negative/path-traversal/contract.yaml @@ -0,0 +1,15 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: bad-path-traversal +spec: + summary: Content root escapes the repository root + repository: + type: project + lifecycle: stub + contentRoots: + - id: escape + role: documentation + path: "../outside" + kind: directory + authority: source diff --git a/tests/fixtures/negative/secret-field/contract.yaml b/tests/fixtures/negative/secret-field/contract.yaml new file mode 100644 index 0000000..6bdc678 --- /dev/null +++ b/tests/fixtures/negative/secret-field/contract.yaml @@ -0,0 +1,11 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: bad-secret-field + annotations: + token: "super-secret-value-should-be-blocked" +spec: + summary: Contains a secret-shaped field + repository: + type: project + lifecycle: stub diff --git a/tests/fixtures/negative/shell-string/contract.yaml b/tests/fixtures/negative/shell-string/contract.yaml new file mode 100644 index 0000000..7023408 --- /dev/null +++ b/tests/fixtures/negative/shell-string/contract.yaml @@ -0,0 +1,18 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: bad-shell-string +spec: + summary: Operation argv contains a shell metacharacter + repository: + type: infrastructure-config + lifecycle: stub + operations: + - id: container.inspect + phase: inspect + effect: read-only + risk: low + execution: + handler: ops/handlers/lxd.py + argv: + - "inspect && rm -rf /" diff --git a/tests/fixtures/negative/unknown-field/contract.yaml b/tests/fixtures/negative/unknown-field/contract.yaml new file mode 100644 index 0000000..536d035 --- /dev/null +++ b/tests/fixtures/negative/unknown-field/contract.yaml @@ -0,0 +1,10 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: bad-unknown-field +spec: + summary: Has an unknown normative field + repository: + type: project + lifecycle: active + unexpectedField: surprise diff --git a/tests/fixtures/positive/infra-lxd/AGENTS.md b/tests/fixtures/positive/infra-lxd/AGENTS.md new file mode 100644 index 0000000..87c592c --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/AGENTS.md @@ -0,0 +1,3 @@ +# infra-lxd agent instructions + +Read `ops/contract.yaml`, then use `repoctl context` for the task at hand. diff --git a/tests/fixtures/positive/infra-lxd/CLAUDE.md b/tests/fixtures/positive/infra-lxd/CLAUDE.md new file mode 100644 index 0000000..f6aa6c0 --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/CLAUDE.md @@ -0,0 +1,3 @@ +# CLAUDE.md + +@AGENTS.md diff --git a/tests/fixtures/positive/infra-lxd/kdb/container-deployment.md b/tests/fixtures/positive/infra-lxd/kdb/container-deployment.md new file mode 100644 index 0000000..ef87f90 --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/kdb/container-deployment.md @@ -0,0 +1,3 @@ +# Container deployment + +Create containers from `profiles-source/`. diff --git a/tests/fixtures/positive/infra-lxd/kdb/kdb.yaml b/tests/fixtures/positive/infra-lxd/kdb/kdb.yaml new file mode 100644 index 0000000..d2094f6 --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/kdb/kdb.yaml @@ -0,0 +1,22 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: KnowledgeBase +metadata: + name: infra-lxd-kdb +spec: + repository: repo:infra-lxd + defaultLanguage: en + topics: + - id: container-deployment + summary: Canonical local process for creating an LXD container + intents: + - container.deploy + documents: + - container-deployment-howto + documents: + - id: container-deployment-howto + title: Container deployment how-to + role: how-to + path: kdb/container-deployment.md + mediaType: text/markdown + authority: local-canonical + status: verified diff --git a/tests/fixtures/positive/infra-lxd/ops/contract.yaml b/tests/fixtures/positive/infra-lxd/ops/contract.yaml new file mode 100644 index 0000000..87dbf85 --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/ops/contract.yaml @@ -0,0 +1,46 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: infra-lxd + title: LXD infrastructure + owners: + - infrastructure +spec: + summary: Desired state and operations for managed LXD containers + repository: + type: infrastructure-config + lifecycle: production + namespace: Infra + agent: + primary: CLAUDE.md + portable: AGENTS.md + knowledge: + entrypoint: kdb/kdb.yaml + contentRoots: + - id: profiles-source + role: profiles + path: profiles-source + kind: directory + authority: source + writePolicy: managed + selector: "**/*.yaml" + - id: profiles-observed + role: observed + path: profiles + kind: directory + authority: mirror + writePolicy: generated + selector: "**/*.yaml" + provides: + - id: container + capability: compute.lxd-container + summary: Managed LXD system container + operations: + - id: container.inspect + title: Inspect containers + intents: + - container.inspect + - container.deploy + phase: inspect + effect: read-only + risk: low diff --git a/tests/fixtures/positive/infra-lxd/profiles-source/default.yaml b/tests/fixtures/positive/infra-lxd/profiles-source/default.yaml new file mode 100644 index 0000000..7936746 --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/profiles-source/default.yaml @@ -0,0 +1,2 @@ +name: default +config: {} diff --git a/tests/fixtures/positive/infra-lxd/profiles/default.yaml b/tests/fixtures/positive/infra-lxd/profiles/default.yaml new file mode 100644 index 0000000..7936746 --- /dev/null +++ b/tests/fixtures/positive/infra-lxd/profiles/default.yaml @@ -0,0 +1,2 @@ +name: default +config: {} diff --git a/tests/fixtures/positive/project-example/AGENTS.md b/tests/fixtures/positive/project-example/AGENTS.md new file mode 100644 index 0000000..34b7c29 --- /dev/null +++ b/tests/fixtures/positive/project-example/AGENTS.md @@ -0,0 +1,3 @@ +# example-project agent instructions + +Read `ops/contract.yaml`, then use `repoctl context`. diff --git a/tests/fixtures/positive/project-example/CLAUDE.md b/tests/fixtures/positive/project-example/CLAUDE.md new file mode 100644 index 0000000..f6aa6c0 --- /dev/null +++ b/tests/fixtures/positive/project-example/CLAUDE.md @@ -0,0 +1,3 @@ +# CLAUDE.md + +@AGENTS.md diff --git a/tests/fixtures/positive/project-example/decisions/adr-0001.md b/tests/fixtures/positive/project-example/decisions/adr-0001.md new file mode 100644 index 0000000..fa14102 --- /dev/null +++ b/tests/fixtures/positive/project-example/decisions/adr-0001.md @@ -0,0 +1,3 @@ +# ADR 0001 + +Placeholder decision record. diff --git a/tests/fixtures/positive/project-example/deliverables/deliverable-1.md b/tests/fixtures/positive/project-example/deliverables/deliverable-1.md new file mode 100644 index 0000000..53f0e0c --- /dev/null +++ b/tests/fixtures/positive/project-example/deliverables/deliverable-1.md @@ -0,0 +1,3 @@ +# Deliverable one + +Placeholder deliverable content for a fixture repository. diff --git a/tests/fixtures/positive/project-example/kdb/kdb.yaml b/tests/fixtures/positive/project-example/kdb/kdb.yaml new file mode 100644 index 0000000..b6b9bdb --- /dev/null +++ b/tests/fixtures/positive/project-example/kdb/kdb.yaml @@ -0,0 +1,9 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: KnowledgeBase +metadata: + name: example-project-kdb +spec: + repository: repo:example-project + defaultLanguage: en + topics: [] + documents: [] diff --git a/tests/fixtures/positive/project-example/ops/contract.yaml b/tests/fixtures/positive/project-example/ops/contract.yaml new file mode 100644 index 0000000..7a2d5b5 --- /dev/null +++ b/tests/fixtures/positive/project-example/ops/contract.yaml @@ -0,0 +1,30 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: example-project + title: Example project + owners: + - example-team +spec: + summary: Example non-code project + repository: + type: project + lifecycle: active + agent: + primary: CLAUDE.md + portable: AGENTS.md + knowledge: + entrypoint: kdb/kdb.yaml + contentRoots: + - id: deliverables + role: deliverables + path: deliverables + kind: directory + authority: source + writePolicy: managed + - id: decisions + role: decisions + path: decisions + kind: directory + authority: source + writePolicy: managed diff --git a/tests/fixtures/positive/service-antivirus/AGENTS.md b/tests/fixtures/positive/service-antivirus/AGENTS.md new file mode 100644 index 0000000..c017cf4 --- /dev/null +++ b/tests/fixtures/positive/service-antivirus/AGENTS.md @@ -0,0 +1,3 @@ +# services-antivirus agent instructions + +Read `ops/contract.yaml`, then use `repoctl context`. diff --git a/tests/fixtures/positive/service-antivirus/CLAUDE.md b/tests/fixtures/positive/service-antivirus/CLAUDE.md new file mode 100644 index 0000000..f6aa6c0 --- /dev/null +++ b/tests/fixtures/positive/service-antivirus/CLAUDE.md @@ -0,0 +1,3 @@ +# CLAUDE.md + +@AGENTS.md diff --git a/tests/fixtures/positive/service-antivirus/acceptance/.gitkeep b/tests/fixtures/positive/service-antivirus/acceptance/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/positive/service-antivirus/kdb/kdb.yaml b/tests/fixtures/positive/service-antivirus/kdb/kdb.yaml new file mode 100644 index 0000000..b951fa6 --- /dev/null +++ b/tests/fixtures/positive/service-antivirus/kdb/kdb.yaml @@ -0,0 +1,9 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: KnowledgeBase +metadata: + name: services-antivirus-kdb +spec: + repository: repo:services-antivirus + defaultLanguage: en + topics: [] + documents: [] diff --git a/tests/fixtures/positive/service-antivirus/ops/contract.yaml b/tests/fixtures/positive/service-antivirus/ops/contract.yaml new file mode 100644 index 0000000..7b2291e --- /dev/null +++ b/tests/fixtures/positive/service-antivirus/ops/contract.yaml @@ -0,0 +1,46 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: services-antivirus + title: Antivirus service + owners: + - security +spec: + summary: Product configuration, knowledge and acceptance for antivirus services + repository: + type: service-config + lifecycle: production + namespace: Services + agent: + primary: CLAUDE.md + portable: AGENTS.md + knowledge: + entrypoint: kdb/kdb.yaml + contentRoots: + - id: product-policies + role: policies + path: policies + kind: directory + authority: source + writePolicy: managed + - id: service-acceptance + role: acceptance + path: acceptance + kind: directory + authority: source + writePolicy: managed + requires: + - id: control-plane-container + capability: compute.lxd-container + summary: Container for antivirus control plane + acceptance: + - operation:services-antivirus/control-plane.verify + operations: + - id: control-plane.verify + title: Verify antivirus control plane + intents: + - container.deploy + - service.verify + phase: verify + effect: read-only + risk: low diff --git a/tests/fixtures/positive/service-antivirus/policies/.gitkeep b/tests/fixtures/positive/service-antivirus/policies/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/positive/software-example/AGENTS.md b/tests/fixtures/positive/software-example/AGENTS.md new file mode 100644 index 0000000..3b02548 --- /dev/null +++ b/tests/fixtures/positive/software-example/AGENTS.md @@ -0,0 +1,3 @@ +# example-software agent instructions + +Read `ops/contract.yaml`, then use `repoctl context`. diff --git a/tests/fixtures/positive/software-example/CLAUDE.md b/tests/fixtures/positive/software-example/CLAUDE.md new file mode 100644 index 0000000..f6aa6c0 --- /dev/null +++ b/tests/fixtures/positive/software-example/CLAUDE.md @@ -0,0 +1,3 @@ +# CLAUDE.md + +@AGENTS.md diff --git a/tests/fixtures/positive/software-example/kdb/kdb.yaml b/tests/fixtures/positive/software-example/kdb/kdb.yaml new file mode 100644 index 0000000..6c72424 --- /dev/null +++ b/tests/fixtures/positive/software-example/kdb/kdb.yaml @@ -0,0 +1,9 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: KnowledgeBase +metadata: + name: example-software-kdb +spec: + repository: repo:example-software + defaultLanguage: en + topics: [] + documents: [] diff --git a/tests/fixtures/positive/software-example/ops/contract.yaml b/tests/fixtures/positive/software-example/ops/contract.yaml new file mode 100644 index 0000000..3acd29a --- /dev/null +++ b/tests/fixtures/positive/software-example/ops/contract.yaml @@ -0,0 +1,30 @@ +apiVersion: stewardship.corsus.ru/v1alpha1 +kind: RepositoryContract +metadata: + name: example-software + title: Example software + owners: + - example-team +spec: + summary: Example software repository + repository: + type: software + lifecycle: active + agent: + primary: CLAUDE.md + portable: AGENTS.md + knowledge: + entrypoint: kdb/kdb.yaml + contentRoots: + - id: source + role: source + path: src + kind: directory + authority: source + writePolicy: managed + - id: tests + role: tests + path: tests + kind: directory + authority: source + writePolicy: managed diff --git a/tests/fixtures/positive/software-example/src/main.py b/tests/fixtures/positive/software-example/src/main.py new file mode 100644 index 0000000..6af92a4 --- /dev/null +++ b/tests/fixtures/positive/software-example/src/main.py @@ -0,0 +1 @@ +print("example") diff --git a/tests/fixtures/positive/software-example/tests/test_main.py b/tests/fixtures/positive/software-example/tests/test_main.py new file mode 100644 index 0000000..3ada1ee --- /dev/null +++ b/tests/fixtures/positive/software-example/tests/test_main.py @@ -0,0 +1,2 @@ +def test_placeholder(): + assert True diff --git a/tests/test_adoption.py b/tests/test_adoption.py new file mode 100644 index 0000000..75f3467 --- /dev/null +++ b/tests/test_adoption.py @@ -0,0 +1,91 @@ +from __future__ import annotations + +import pytest + +from stewardship import adoption + + +def test_assess_lxd_legacy_preserves_layout(make_repo): + repo = make_repo("adoption/lxd-legacy") + result = adoption.assess(repo) + assert result["repository"]["dirty"] is False + assert result["classification"]["proposedType"] == "infrastructure-config" + kdb_actions = {(entry["path"], entry["action"]) for entry in result["knowledge"]} + assert ("kdb.yaml", "wrap") in kdb_actions + root_paths = {cr["path"] for cr in result["proposedContentRoots"]} + assert "profiles-source" in root_paths + + +def test_plan_lxd_legacy_creates_contract_and_kdb_adapter_without_moving_profiles(make_repo): + repo = make_repo("adoption/lxd-legacy") + assessment = adoption.assess(repo) + plan = adoption.build_plan( + repo, assessment, confirmed_name="infra-lxd", confirmed_owners=["infrastructure"], confirmed_lifecycle="production" + ) + changes_by_path = {c["path"]: c for c in plan["changes"]} + assert changes_by_path["ops/contract.yaml"]["action"] == "create" + assert changes_by_path["kdb/kdb.yaml"]["action"] == "create" + assert changes_by_path["kdb.yaml"]["action"] == "preserve" + assert "profiles-source/**" in plan["forbiddenChanges"] + assert "profiles/**" in plan["forbiddenChanges"] + assert plan["planHash"].startswith("sha256:") + + +def test_apply_does_not_touch_working_tree_before_approval(make_repo): + repo = make_repo("adoption/lxd-legacy") + before = sorted(p.relative_to(repo).as_posix() for p in repo.rglob("*") if p.is_file()) + assessment = adoption.assess(repo) + adoption.build_plan(repo, assessment, confirmed_name="infra-lxd") + after = sorted(p.relative_to(repo).as_posix() for p in repo.rglob("*") if p.is_file()) + assert before == after + + +def test_apply_rejects_stale_baseline(make_repo): + repo = make_repo("adoption/lxd-legacy") + assessment = adoption.assess(repo) + plan = adoption.build_plan(repo, assessment, confirmed_name="infra-lxd") + plan["baselineRevision"] = "0" * 40 + with pytest.raises(ValueError): + adoption.apply_plan(repo, plan, plan["planHash"]) + assert not (repo / "ops" / "contract.yaml").exists() + + +def test_apply_and_verify_lxd_legacy(make_repo): + repo = make_repo("adoption/lxd-legacy") + assessment = adoption.assess(repo) + plan = adoption.build_plan( + repo, assessment, confirmed_name="infra-lxd", confirmed_owners=["infrastructure"], confirmed_lifecycle="production" + ) + written = adoption.apply_plan(repo, plan, plan["planHash"]) + assert "ops/contract.yaml" in written + assert (repo / "profiles-source" / "default.yaml").exists() + assert (repo / "profiles" / "default.yaml").exists() + assert (repo / "kdb.yaml").exists() + + report = adoption.verify(repo, plan) + assert "profiles-source" in report["preservedPaths"] or "kdb.yaml" in report["preservedPaths"] + assert report["outcome"] in {"pass", "pass-with-warnings"} + + +def test_assess_antivirus_legacy_detects_occupied_kdb_path(make_repo): + repo = make_repo("adoption/antivirus-legacy") + result = adoption.assess(repo) + kdb_paths = {entry["path"] for entry in result["knowledge"]} + assert "kdb/kdb.yaml" in kdb_paths + + +def test_plan_antivirus_legacy_does_not_overwrite_existing_kdb(make_repo): + repo = make_repo("adoption/antivirus-legacy") + assessment = adoption.assess(repo) + plan = adoption.build_plan(repo, assessment, confirmed_name="services-antivirus") + changes_by_path = {c["path"]: c for c in plan["changes"]} + assert changes_by_path["kdb/kdb.yaml"]["action"] == "preserve" + + +def test_apply_preserves_existing_antivirus_kdb_bytes(make_repo): + repo = make_repo("adoption/antivirus-legacy") + original = (repo / "kdb" / "kdb.yaml").read_bytes() + assessment = adoption.assess(repo) + plan = adoption.build_plan(repo, assessment, confirmed_name="services-antivirus") + adoption.apply_plan(repo, plan, plan["planHash"]) + assert (repo / "kdb" / "kdb.yaml").read_bytes() == original diff --git a/tests/test_bootstrap.py b/tests/test_bootstrap.py new file mode 100644 index 0000000..e01c6ae --- /dev/null +++ b/tests/test_bootstrap.py @@ -0,0 +1,51 @@ +from __future__ import annotations + +import pytest + +from stewardship.bootstrap import BootstrapAnswers, apply_bootstrap_plan, build_bootstrap_plan +from stewardship.validate import validate_repository + + +def test_bootstrap_plan_writes_nothing(tmp_path): + answers = BootstrapAnswers(name="new-proj", title="New project", owners=["team"], repository_type="project") + plan = build_bootstrap_plan(answers) + assert list(tmp_path.iterdir()) == [] + assert plan["planHash"].startswith("sha256:") + + +def test_bootstrap_apply_requires_matching_approval_hash(tmp_path): + answers = BootstrapAnswers(name="new-proj", title="New project", owners=["team"], repository_type="project") + plan = build_bootstrap_plan(answers) + with pytest.raises(ValueError): + apply_bootstrap_plan(tmp_path, plan, "sha256:not-the-real-hash") + assert list(tmp_path.iterdir()) == [] + + +def test_bootstrap_apply_writes_and_validates(tmp_path): + import subprocess + + subprocess.run(["git", "init", "-q"], cwd=tmp_path, check=True) + answers = BootstrapAnswers( + name="new-proj", title="New project", owners=["team"], repository_type="project", lifecycle="active" + ) + plan = build_bootstrap_plan(answers) + written = apply_bootstrap_plan(tmp_path, plan, plan["planHash"]) + assert "ops/contract.yaml" in written + assert (tmp_path / "AGENTS.md").exists() + assert (tmp_path / ".claude/skills/repository-bootstrap/SKILL.md").exists() + + result = validate_repository(tmp_path) + errors = [f for f in result.findings if f.severity == "error"] + assert errors == [] + + +def test_bootstrap_apply_refuses_to_overwrite(tmp_path): + import subprocess + + subprocess.run(["git", "init", "-q"], cwd=tmp_path, check=True) + (tmp_path / "AGENTS.md").write_text("existing", encoding="utf-8") + answers = BootstrapAnswers(name="new-proj", title="New project", owners=["team"], repository_type="project") + plan = build_bootstrap_plan(answers) + with pytest.raises(FileExistsError): + apply_bootstrap_plan(tmp_path, plan, plan["planHash"]) + assert (tmp_path / "AGENTS.md").read_text(encoding="utf-8") == "existing" diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 0000000..ed36a3c --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,41 @@ +from __future__ import annotations + +from stewardship.cli import main + + +def test_validate_exit_codes(make_repo, negative_repo): + good = make_repo("positive/infra-lxd") + assert main(["validate", "--repo", str(good), "--output", "json"]) == 0 + + bad = negative_repo("secret-field") + assert main(["validate", "--repo", str(bad), "--output", "json"]) == 1 + + +def test_missing_repository_returns_exit_3(tmp_path): + missing = tmp_path / "does-not-exist" + assert main(["validate", "--repo", str(missing), "--output", "json"]) == 3 + + +def test_context_strict_truncation_returns_exit_4(make_repo): + repo = make_repo("positive/infra-lxd") + code = main( + [ + "context", + "--repo", + str(repo), + "--intent", + "container.deploy", + "--materialize", + "--budget-bytes", + "1", + "--strict", + "--output", + "json", + ] + ) + assert code == 4 + + +def test_init_apply_without_hash_returns_exit_2(tmp_path): + code = main(["init", "--repo", str(tmp_path), "--apply", "--output", "json"]) + assert code == 2 diff --git a/tests/test_context.py b/tests/test_context.py new file mode 100644 index 0000000..e3edfbd --- /dev/null +++ b/tests/test_context.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +from stewardship.context import build_context + + +def test_context_selects_only_matching_topic(make_repo): + repo = make_repo("positive/infra-lxd") + result = build_context(repo, "container.deploy") + bundle = result.bundle + assert bundle["spec"]["intent"] == "container.deploy" + assert bundle["spec"]["topics"] == ["topic:infra-lxd/container-deployment"] + assert bundle["spec"]["documents"] == ["container-deployment-howto"] + assert "operation:infra-lxd/container.inspect" in bundle["spec"]["operations"] + + +def test_context_unrelated_intent_returns_empty_topics(make_repo): + repo = make_repo("positive/infra-lxd") + result = build_context(repo, "backup.restore") + bundle = result.bundle + assert bundle["spec"]["topics"] == [] + assert bundle["spec"]["documents"] == [] + + +def test_context_materialize_respects_budget_and_warns(make_repo): + repo = make_repo("positive/infra-lxd") + result = build_context(repo, "container.deploy", materialize=True, budget_bytes=5) + assert result.truncated is True + assert any("CONTEXT_BUDGET_TRUNCATED" in w for w in result.bundle["spec"]["warnings"]) + assert result.materialized[0].bytes_used <= 5 + + +def test_context_strict_mode_signaled_via_truncation_flag(make_repo): + repo = make_repo("positive/infra-lxd") + result = build_context(repo, "container.deploy", materialize=True, budget_bytes=0, strict=True) + assert result.truncated is True diff --git a/tests/test_discovery.py b/tests/test_discovery.py new file mode 100644 index 0000000..2d370bb --- /dev/null +++ b/tests/test_discovery.py @@ -0,0 +1,64 @@ +from __future__ import annotations + +from stewardship.discovery import build_catalog_index + + +def test_catalog_finds_all_positive_fixtures_and_is_deterministic(tmp_path, make_repo): + make_repo("positive/infra-lxd") + make_repo("positive/service-antivirus") + make_repo("positive/software-example") + make_repo("positive/project-example") + + catalog1, findings1 = build_catalog_index([tmp_path]) + catalog2, _findings2 = build_catalog_index([tmp_path]) + + names = {r["ref"] for r in catalog1["spec"]["repositories"]} + assert names == { + "repo:infra-lxd", + "repo:services-antivirus", + "repo:example-software", + "repo:example-project", + } + assert not any(f.severity == "error" for f in findings1) + + # Deterministic rebuild ignoring the volatile generatedAt timestamp. + repos1 = catalog1["spec"]["repositories"] + repos2 = catalog2["spec"]["repositories"] + assert repos1 == repos2 + assert catalog1["spec"]["relations"] == catalog2["spec"]["relations"] + + +def test_catalog_matches_requirement_to_capability(tmp_path, make_repo): + make_repo("positive/infra-lxd") + make_repo("positive/service-antivirus") + + catalog, _ = build_catalog_index([tmp_path]) + relations = catalog["spec"]["relations"] + matches = [r for r in relations if r["type"] == "matches"] + assert any( + r["from"] == "requirement:services-antivirus/control-plane-container" + and r["to"] == "capability:infra-lxd/container" + for r in matches + ) + + +def test_catalog_detects_duplicate_repository_name(tmp_path, make_repo): + first = make_repo("positive/infra-lxd", git=False) + import shutil + + second_parent = tmp_path / "duplicate-holder" + second_parent.mkdir() + second = second_parent / "infra-lxd-copy" + shutil.copytree(first, second) + + import subprocess + + for repo in (first, second): + subprocess.run(["git", "init", "-q"], cwd=repo, check=True) + subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=repo, check=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=repo, check=True) + subprocess.run(["git", "add", "-A"], cwd=repo, check=True) + subprocess.run(["git", "commit", "-q", "-m", "baseline"], cwd=repo, check=True) + + _, findings = build_catalog_index([tmp_path]) + assert any(f.code == "CATALOG_DUPLICATE_REPOSITORY_NAME" for f in findings) diff --git a/tests/test_schema.py b/tests/test_schema.py new file mode 100644 index 0000000..3c75e4f --- /dev/null +++ b/tests/test_schema.py @@ -0,0 +1,32 @@ +from __future__ import annotations + +import json +from io import StringIO + +import pytest +from ruamel.yaml import YAML + +from stewardship.cli import main + + +@pytest.mark.parametrize( + "fixture", + [ + "positive/infra-lxd", + "positive/service-antivirus", + "positive/software-example", + "positive/project-example", + ], +) +def test_validate_yaml_and_json_output_have_same_findings(make_repo, fixture, capsys): + repo = make_repo(fixture) + + assert main(["validate", "--repo", str(repo), "--output", "json"]) == 0 + json_out = json.loads(capsys.readouterr().out) + + assert main(["validate", "--repo", str(repo), "--output", "yaml"]) == 0 + yaml_text = capsys.readouterr().out + parsed_yaml = YAML(typ="safe").load(StringIO(yaml_text)) + + assert json_out["findings"] == parsed_yaml["findings"] + assert json_out["outcome"] == parsed_yaml["outcome"] diff --git a/tests/test_validate_negative.py b/tests/test_validate_negative.py new file mode 100644 index 0000000..39dfe11 --- /dev/null +++ b/tests/test_validate_negative.py @@ -0,0 +1,23 @@ +from __future__ import annotations + +import pytest + +from stewardship.validate import validate_repository + +CASES = { + "unknown-field": "CONTRACT_SCHEMA_INVALID", + "duplicate-ids": "ID_DUPLICATE", + "path-traversal": "CONTRACT_PATH_OUTSIDE_REPOSITORY", + "absolute-path": "CONTRACT_PATH_OUTSIDE_REPOSITORY", + "secret-field": "SECRET_SHAPED_FIELD", + "shell-string": "OPERATION_ARGV_SHELL_STRING", +} + + +@pytest.mark.parametrize("name,expected_code", CASES.items()) +def test_negative_fixture_is_rejected(negative_repo, name, expected_code): + repo = negative_repo(name) + result = validate_repository(repo) + codes = {f.code for f in result.findings} + assert expected_code in codes, (name, codes) + assert not result.ok diff --git a/tests/test_validate_positive.py b/tests/test_validate_positive.py new file mode 100644 index 0000000..81428a5 --- /dev/null +++ b/tests/test_validate_positive.py @@ -0,0 +1,27 @@ +from __future__ import annotations + +import pytest + +from stewardship.validate import validate_repository + +POSITIVE_FIXTURES = [ + "positive/infra-lxd", + "positive/service-antivirus", + "positive/software-example", + "positive/project-example", +] + + +@pytest.mark.parametrize("fixture", POSITIVE_FIXTURES) +def test_positive_fixture_validates_clean(make_repo, fixture): + repo = make_repo(fixture) + result = validate_repository(repo) + errors = [f for f in result.findings if f.severity == "error"] + assert errors == [], errors + assert result.ok + + +def test_infra_lxd_content_roots_not_moved(make_repo): + repo = make_repo("positive/infra-lxd") + assert (repo / "profiles-source" / "default.yaml").exists() + assert (repo / "profiles" / "default.yaml").exists() diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..ed353a2 --- /dev/null +++ b/uv.lock @@ -0,0 +1,511 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] + +[[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 = "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 = "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 = "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 = "librt" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/9b/356320fbae2ac8467e21c5e73e1389c80468e4998c62cc7d3536cc51b614/librt-0.15.0.tar.gz", hash = "sha256:4e66cbe84437497d951b799d3e1551291b6fb3d643820a7014b3655d57a59162", size = 214338, upload-time = "2026-08-07T10:49:42.663Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/52/06790ced2ac7117f890c21bda43c39c958ec82aa665c0718e821d33ff939/librt-0.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:823b92cf3c18ecd08afc70c42473888b41b6e8ef5046f3b82c05c154a2fa3d22", size = 148039, upload-time = "2026-08-07T10:46:41.165Z" }, + { url = "https://files.pythonhosted.org/packages/e7/1d/8e150b7fc449a1f33c8a760965cc1f43b14fc1577d9d0b50ab2701420e74/librt-0.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c70bc1b602cf59917e8f0c7a2cbc8bcc6fbc14d5486136b00707a79619121d63", size = 153067, upload-time = "2026-08-07T10:46:42.418Z" }, + { url = "https://files.pythonhosted.org/packages/51/87/a162bc5a66a35599dc619ecb215145f4de7d68e886b479b6d12593139f7c/librt-0.15.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:814ff83a25b5fce8b9c80c4dd803153fb5c5599fc74db9e022466938368957ef", size = 493087, upload-time = "2026-08-07T10:46:43.657Z" }, + { url = "https://files.pythonhosted.org/packages/e5/3a/aeea1fc620cf48060d3065b37614edbf97043c099d0f50782bc8ca61d897/librt-0.15.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:57f5eeb6ad4c180de583b1038e61fe5fbd9796bb69a8a1c1a0c7ddbec4c8c60f", size = 485608, upload-time = "2026-08-07T10:46:45.038Z" }, + { url = "https://files.pythonhosted.org/packages/52/ff/fe571ad416f0856fd0d5578ffc2e6dc531891e586e36b647bcf50569cab8/librt-0.15.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82909c8f7eb9952656b65d3147afde4cf8e6d5a991eebc86418b5e65843b0ab8", size = 498723, upload-time = "2026-08-07T10:46:46.35Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e1/7a65eb5dedb1f00aebd948cdd8e17add48bf066cab3514e9daf84ab45a6c/librt-0.15.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f779070399f991400fc451719e0ea388eb7de313388bada2c127a35de05f798a", size = 516002, upload-time = "2026-08-07T10:46:47.599Z" }, + { url = "https://files.pythonhosted.org/packages/5f/45/59832b0ebfbd08c2742e6ece372ceb53f18bf1faef5d33c8daf3abebf749/librt-0.15.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bac89069bc496ebdf4f79ebb57bbd10d0b214c8454225deb672d91002bd17e18", size = 508607, upload-time = "2026-08-07T10:46:48.873Z" }, + { url = "https://files.pythonhosted.org/packages/ea/0d/37fa73f3b43ebd8259f91ae9102a15e5a54e65d581e48dea72df3e81d7a4/librt-0.15.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e0d00c708fb2f5822b152429b1ac80a58dbbbc3f6c232c4d13a3f7fcf2ea5b4c", size = 530422, upload-time = "2026-08-07T10:46:50.45Z" }, + { url = "https://files.pythonhosted.org/packages/26/02/e046c6fe7a5881ac34623242192f484426ba8a75595fd18f22c53a3f530f/librt-0.15.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6c6624fe268625869485553dd7cc1daf30d22558215bb2a4ff16f67a9801a31a", size = 534303, upload-time = "2026-08-07T10:46:51.693Z" }, + { url = "https://files.pythonhosted.org/packages/95/32/d5e6d861ab0366f3edf74f887ab0c9eb9f535aaf01d32b80b4f734daa179/librt-0.15.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f56b397858a23dacf35ede366ed2212fdc03a6a57a1ad36468ad6e9dc5fac091", size = 536084, upload-time = "2026-08-07T10:46:52.951Z" }, + { url = "https://files.pythonhosted.org/packages/2a/de/d69d725513fe53fc90c6d7a1f86e4428939bad2fb905b17fe4c18d413dde/librt-0.15.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4388184646efe2054911c5b00a1077d6d1ee86a95b7e8ba96dc7850a809f3f40", size = 514307, upload-time = "2026-08-07T10:46:54.194Z" }, + { url = "https://files.pythonhosted.org/packages/36/93/f8aded0d6682b4f25820fa86e0690f87f01df9fd7bd09ddb04d9167ad021/librt-0.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:97335f59082f9fe2ce6c2a9cc6433a0114bbb6cd4d5c09dd76c95c68b9f9a8b0", size = 557686, upload-time = "2026-08-07T10:46:55.443Z" }, + { url = "https://files.pythonhosted.org/packages/74/09/ffeb6bdeb6cd862b4272fddc8ad05f938dd25d020ed517e631813917d80a/librt-0.15.0-cp311-cp311-win32.whl", hash = "sha256:83380ffde38062a2e9bb55d83e74474f6614665528b98a6928720fc006dfffbb", size = 104917, upload-time = "2026-08-07T10:46:56.605Z" }, + { url = "https://files.pythonhosted.org/packages/96/28/7e2313a3ffbf0b4de7ba3da58a09e488507b4bd1ea2b5e69378354a23415/librt-0.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:f75720477ee05d509a310e856cacc8d909adc182f7b91193c207bcc26d7ee6db", size = 125886, upload-time = "2026-08-07T10:46:57.729Z" }, + { url = "https://files.pythonhosted.org/packages/39/9e/04b8c3cde014ef255ee785730425268354543acc38902093a40afa0dc164/librt-0.15.0-cp311-cp311-win_arm64.whl", hash = "sha256:256237037a3ab001ae8d9803b2d43562a4c3aa38739843694349e4d5ebb0fd56", size = 111885, upload-time = "2026-08-07T10:46:58.787Z" }, + { url = "https://files.pythonhosted.org/packages/ba/39/99c25030e782bdfb7a21be8c05254806a2e4bbb05c8d50c2a2130acbfa05/librt-0.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e87bc679f86a99aa3b26e3c78eeb821a247c9a28eae48eaafcc32c3bf4c3bb9e", size = 151021, upload-time = "2026-08-07T10:47:00.057Z" }, + { url = "https://files.pythonhosted.org/packages/14/43/f4b1bd1b2888798a1409808889a25ea1ba49eaabce7d681ed27734c2df9d/librt-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71599e011ac880e8e45d46047d714871894c7d4ab6f25626f8d4f89da21f368d", size = 155267, upload-time = "2026-08-07T10:47:01.311Z" }, + { url = "https://files.pythonhosted.org/packages/0c/db/3ad9c965c72f1e1d6beeec44ec10a54e17be8ae042fbb4baade16cbadced/librt-0.15.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c802434092b769b1d613ed2e13fac15fbfce1934a74bd10283b03c0fae231cd1", size = 503136, upload-time = "2026-08-07T10:47:02.45Z" }, + { url = "https://files.pythonhosted.org/packages/4b/07/5888a6d76acd62ebce66c61b74d94e9370b9c32929f111e487bb6546f8ed/librt-0.15.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5500eeae393a184d14e1f35645962c27129d20c81afa4069e6ef826ebc2b3aaa", size = 496670, upload-time = "2026-08-07T10:47:03.675Z" }, + { url = "https://files.pythonhosted.org/packages/29/39/ab57cc2f5b276156da02bb7f5a8921bada1cb1993ffec99acf811c602c23/librt-0.15.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6ecfc32dfb46fb7b565bcd6abf9412acf978775a998273d22888a6d7953730dd", size = 513688, upload-time = "2026-08-07T10:47:04.981Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b9/bdbb0b648b5c2befb031f4c6f3b1dd857415e8fb492a25a3c764a6681e6c/librt-0.15.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cc46cfd15022e35084355478c9ac809d90b1152222706ac9a7655ec21df6fa", size = 531904, upload-time = "2026-08-07T10:47:06.211Z" }, + { url = "https://files.pythonhosted.org/packages/93/26/473c2e4b6c104e9e58e27ce95fc8005c8bd4fc36cae4f254371125a92db8/librt-0.15.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5f51401d102c885b9ca509e62c79b1dbff286e1b9b047fde6f763780789356d", size = 524427, upload-time = "2026-08-07T10:47:07.592Z" }, + { url = "https://files.pythonhosted.org/packages/26/60/03b3abb82b41714671b907bf6989b228e31e6a8af52dec82b5b0728dc250/librt-0.15.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cc30523e3f1a23fb7511cc659834a0d01a1042bb9de359bc1c131cc4ec6c9656", size = 543155, upload-time = "2026-08-07T10:47:08.866Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0e/9bb1f0a4affbd0a1888f4f79dc03ed2a299d9a2c26c59ab2a97dcbf11903/librt-0.15.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:59fe030d8ae4a57e3fb7756bf35a858de74e04066fc8555c53d0af979132af81", size = 546890, upload-time = "2026-08-07T10:47:10.327Z" }, + { url = "https://files.pythonhosted.org/packages/dc/84/6937a280d461f7de6e031ffb02edc2b7c3c90d49d630565ce8ff27cbc5f2/librt-0.15.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5a6526a2a956bbb1e4ae3568c82e650fc99119c66bb011ea60715744955a2b4d", size = 555163, upload-time = "2026-08-07T10:47:11.798Z" }, + { url = "https://files.pythonhosted.org/packages/bc/95/2a2853c1ee014bf102116e7f897a04beeaeb2461b45b79af98bdfb95f1ef/librt-0.15.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:85ea21ec6730194d67156b0e0b5430ccb1d61f8b8b907e39b37f9812b74a13f0", size = 535812, upload-time = "2026-08-07T10:47:13.279Z" }, + { url = "https://files.pythonhosted.org/packages/c9/4c/cf9601c1b4c5f09280acd5d83abdb2e68527a2be8257136eb42304218622/librt-0.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1e47b8ba865d7ede071a91a7163073bbaeb72541f1ef8a07d512c45c7b5007f2", size = 573688, upload-time = "2026-08-07T10:47:14.727Z" }, + { url = "https://files.pythonhosted.org/packages/47/6d/9ac7cbec46189a7625af4b5acbd25f10d827f4141b2002181848c8418923/librt-0.15.0-cp312-cp312-win32.whl", hash = "sha256:a5207ec414d1c4a2a7231b2086970dc036f94293cdf338190984958a013a42f1", size = 106138, upload-time = "2026-08-07T10:47:15.973Z" }, + { url = "https://files.pythonhosted.org/packages/38/d0/2ae99c83be86ce23f925ac1aeeedc777e97f427c4a8d190c70d0a16e9a87/librt-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:73b30cfa976659b3917c8f6153bdb0591c6a9ec6583599fd24a689b690622022", size = 126974, upload-time = "2026-08-07T10:47:17.049Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ef/dd24f9635c730b86b87587967dda7516b1845e8b17684603d31607fed598/librt-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:a54cf9e0ef47b96af580849db5471142200568ce1e02cbf416addab551369570", size = 112292, upload-time = "2026-08-07T10:47:18.222Z" }, + { url = "https://files.pythonhosted.org/packages/e7/42/467b53a601b406ccd7b97c1fd54b59cb34f9185ad5ce7e9d5c3c4e8961c8/librt-0.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:db13ca398005abcbe538deda87b686d9bd08b7001cf40c4c06b444960ae10a26", size = 151029, upload-time = "2026-08-07T10:47:19.312Z" }, + { url = "https://files.pythonhosted.org/packages/3e/e6/36c2299b7a94b84fdd01220d8a777a71be5be0925bb0dbdf71c0a06a34d9/librt-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa1f1995789dca3698bc550aaceb09a51bd5df0a057ff84ff15296cd1975b801", size = 155194, upload-time = "2026-08-07T10:47:20.398Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b6/ed5071f9325845e670bd36012757419767fbf56af77ed483077b9e4db541/librt-0.15.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55456ea87d8df21808446d03817be2f65e20391c1c615d9187440dff28cd08dc", size = 502568, upload-time = "2026-08-07T10:47:21.652Z" }, + { url = "https://files.pythonhosted.org/packages/7f/81/6450c67c3615d87704bcbc21323fafc69c799b06a044c447529f725d4b01/librt-0.15.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5a86a5a08c2235316bdb359d5dbb6ce0abfca7fac06363103e2c5af571d92f95", size = 496153, upload-time = "2026-08-07T10:47:22.925Z" }, + { url = "https://files.pythonhosted.org/packages/e1/d6/5f52b722bc75076954b3bfd49be15ea362df4d580c6fb315d0f617100d30/librt-0.15.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e56b6a368529bed262da40ce13f8fef590db0479819cca84f16a1f01ac356d0b", size = 513336, upload-time = "2026-08-07T10:47:24.213Z" }, + { url = "https://files.pythonhosted.org/packages/8d/e2/c08fd1d36ce63ea5a12b85c5d37f4550b5f86a692167e41e5a74222607ae/librt-0.15.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:234d8d394721fa0d786af15ebf1f3fb7f3ed82fd1cd0cde45c2f247b5d4281d2", size = 531661, upload-time = "2026-08-07T10:47:25.507Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d8/d9482fcbeb177b9eb87bb3899eeb3b42be690313c652f9e146b1d0681fb2/librt-0.15.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d8363d7accb0286ac3a0e633f396e93800dafb8150494505daf9515bbda591f3", size = 524487, upload-time = "2026-08-07T10:47:26.79Z" }, + { url = "https://files.pythonhosted.org/packages/10/cc/075171517b41f861753034fbb151b42cfc83bcc853849f24f5e66fd60ccf/librt-0.15.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0f0ee3644d951f31055ad07d77d92520e84505dd7a432cc4cd501dd70ee06785", size = 543201, upload-time = "2026-08-07T10:47:27.999Z" }, + { url = "https://files.pythonhosted.org/packages/b0/03/42c2330f37eeb475b6affeedd06518f60035f323af3a839335e3fc9fef2d/librt-0.15.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2cfd1a81a648806e6a7717be4cc4d1bb392fa229752bf8444ba365e381e984d6", size = 546467, upload-time = "2026-08-07T10:47:29.396Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/1ad4c5638f7e64d8560328bd25c54b409a661bdb6ff254b38ff90744288d/librt-0.15.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a6cd22c9da0d866558e46a041f1cc0c2bbb26b61b137b2347fa834c332e1d101", size = 555139, upload-time = "2026-08-07T10:47:30.815Z" }, + { url = "https://files.pythonhosted.org/packages/49/41/39fa7d15db1204cd1cbe6514680fbdc243adf754a0885061308f43afc013/librt-0.15.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6d5225ef8801e4ea5e482fa9b5dfb891dd9ef6f6d870f1f25d449ca2c70ac218", size = 536050, upload-time = "2026-08-07T10:47:32.222Z" }, + { url = "https://files.pythonhosted.org/packages/1e/88/c6dcf0dd8e26dc0c9a499a2abab8646c86dcaf9ecea9524cb46d3686331a/librt-0.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d28a05796b99f749bf8794f17ba9ba1612d0076b802e9cfc62c554634e9ce3b", size = 573700, upload-time = "2026-08-07T10:47:33.527Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9b/ab54c71a7918a7c34fa5327fb61390a77446a07a146fbfb1165250a61035/librt-0.15.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:2067ff438048cead9d223ca5675bae2a25e520a7c3e6c1498bf9c6892d22caab", size = 82194, upload-time = "2026-08-07T10:47:34.835Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b2/4f9a243bb892395f3becb80789ade13771701091f9f07ab8230247953ba8/librt-0.15.0-cp313-cp313-win32.whl", hash = "sha256:1cd3b721f24c206398b9e26da3c3a9c011e6e89d06f318ba8ebefc30f1003890", size = 106231, upload-time = "2026-08-07T10:47:36.251Z" }, + { url = "https://files.pythonhosted.org/packages/bf/af/64aff4885a40b93132382f2c314647d722574605416504379184ef3045ea/librt-0.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:f395a4a9a03ac062dbe9a9f82e0c720502e590a38feee6a757bc82e9c63afbd8", size = 126996, upload-time = "2026-08-07T10:47:37.453Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/335bccf6c7cb9028cb0b54aead27d9ece3f01f83bc6baa2abace5da655c1/librt-0.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:0a15cb554761247d84a3ec0cbdf4078d70725384f0e4662c0fa3b26266eb60ad", size = 112188, upload-time = "2026-08-07T10:47:38.729Z" }, + { url = "https://files.pythonhosted.org/packages/a8/93/949053fb462eecc4a9a5ee770a81f4b40be7b79538b245545d4aebc6b58b/librt-0.15.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f5de7feedc56337a088eb15cd9fafa9938367362221d8cc62c642b7f94821993", size = 149833, upload-time = "2026-08-07T10:47:39.86Z" }, + { url = "https://files.pythonhosted.org/packages/61/ca/8281aa6cd560a3420e4497729f6b704b53be3eeaaef82d5aeadddaf7441f/librt-0.15.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c0eb900c0e91f4aebe680845242e614f1864edfd44106380d0752ac29522bf8", size = 154088, upload-time = "2026-08-07T10:47:41.065Z" }, + { url = "https://files.pythonhosted.org/packages/dd/02/1a1662dceaba6a086360891448d5ce9a7d3555976cae59a31a39d744b9c7/librt-0.15.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8c9a650a188e38bac005048cbe6342e81407782944d01934540ab75e417df21", size = 494215, upload-time = "2026-08-07T10:47:42.388Z" }, + { url = "https://files.pythonhosted.org/packages/69/84/99211619dc656370a3740c33d2b0b6d5a3fb1e73689314f6ed477a397dc4/librt-0.15.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:92bfed8deec93df30286b9fe9e3b1dd17329cc076a192b4ee5ec223841d54953", size = 491173, upload-time = "2026-08-07T10:47:43.683Z" }, + { url = "https://files.pythonhosted.org/packages/d4/aa/5448d0b05f4579b635d3899176817ebf561af0e57bacd425b5b1887264c1/librt-0.15.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec4b19788f835711a2072f9dbe6b03b3bf32ed1f0fb30cf399bdd59d9f0c33fa", size = 505512, upload-time = "2026-08-07T10:47:45.314Z" }, + { url = "https://files.pythonhosted.org/packages/95/82/01940e40b83c43a546c4a3c896cf34ca272a9690899d55914e4827b3dcce/librt-0.15.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4c7bacb70930f3d0a56f4ecf1be474a1f0d941b01dd73b756f3c256d42cb879", size = 523073, upload-time = "2026-08-07T10:47:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/88/fa/759c0030f3ee371439eb26de34fc745807caf0abb878af7af4b8b7c3dd3d/librt-0.15.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3e79f05e4a08b4d880342673312bbc895b56df7765605796f15902eb5367d3ae", size = 515080, upload-time = "2026-08-07T10:47:48.319Z" }, + { url = "https://files.pythonhosted.org/packages/0b/27/894e072228fcb159703c655da69f8cd10dbed489c36e3df7dd032a2483be/librt-0.15.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a417149c0cba4d50b61e992e5a15e69eaf96746609b461cc4ed168aeef6b79dd", size = 534164, upload-time = "2026-08-07T10:47:49.875Z" }, + { url = "https://files.pythonhosted.org/packages/98/a3/0078e91c1f36f8815db17827de15650b9a3fe56c55fbf998c854b34e40d3/librt-0.15.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:da7a94d6a3411f579d72aa3e3bc5fbca7ed4549f3dbd7e5de3aa567333374285", size = 540616, upload-time = "2026-08-07T10:47:51.408Z" }, + { url = "https://files.pythonhosted.org/packages/86/33/81a29b796dd52a45e9ef7974c7732926e8f10f15b8d2be505665979f896d/librt-0.15.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:856f743ae607f2c1380eccb566c0038a9fb3eabf0fc2be2704d76d9f73557239", size = 545890, upload-time = "2026-08-07T10:47:52.818Z" }, + { url = "https://files.pythonhosted.org/packages/05/82/8be1baa1350e5d30cfd70ae79d0a6f4dc5862ef47f7bb2808aabc9bb86e5/librt-0.15.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:779a6e7c894737e5983e7790a9c78c4000c30e23c9aada08081bdbea53b0fa60", size = 523287, upload-time = "2026-08-07T10:47:54.165Z" }, + { url = "https://files.pythonhosted.org/packages/c6/4f/d1be6a01a35c20ef734e0e44113f87d4af756a9354a89dcfbe3b4f8af5e1/librt-0.15.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:96bb17dbe8bab3c0954fbebfc69ed395599de75b6bbc35e3270a878e15d4dd65", size = 565868, upload-time = "2026-08-07T10:47:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/67/88/649cfa33f5825927b160610f670bdab012a64d627eddb94fa795ea4292fd/librt-0.15.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:7220697efaa6e5348fc3d18ee7f8563d4bfecd9872b37ffb915bfc1d08840622", size = 81619, upload-time = "2026-08-07T10:47:56.886Z" }, + { url = "https://files.pythonhosted.org/packages/22/31/8e88a8d5e48fc8d1a817787fb6811dfff6499acd6c8683dd83934aa6ede0/librt-0.15.0-cp314-cp314-win32.whl", hash = "sha256:f54598964d357b1c5ab77cf5d92f21e598fe0e23cdbe9618480807f81b4eba15", size = 100138, upload-time = "2026-08-07T10:47:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/80/92/20fd6c4b6a1b1a564b076d55cd3d427d8428217d7638dc25a654cc4791d4/librt-0.15.0-cp314-cp314-win_amd64.whl", hash = "sha256:3ff5893a2c23d886aa9ce786de5ac6ddc74aeeaf90743682b74d920e117d2e28", size = 121258, upload-time = "2026-08-07T10:47:59.564Z" }, + { url = "https://files.pythonhosted.org/packages/fc/28/6af430b44d9ebb897b865a3c363b6dcace51357be2347cc0f8f869656a86/librt-0.15.0-cp314-cp314-win_arm64.whl", hash = "sha256:3722a099730704c9a3d70c879fc0f51daec25fe5f1555672d97bc595abeafb95", size = 106467, upload-time = "2026-08-07T10:48:01.097Z" }, + { url = "https://files.pythonhosted.org/packages/7e/aa/b42bb798942ced219f6d63b27e07f91237887a8d0bd0921666db79a13790/librt-0.15.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:38c0c7d4b6fc06c3324b3f9162c8391bfc4fd9dde53afe1033ce7edb48d5a714", size = 159523, upload-time = "2026-08-07T10:48:02.442Z" }, + { url = "https://files.pythonhosted.org/packages/75/03/1b53cd4ef904e73b1d828a5f90143bf94a2967d7cfff0b9ccf93e12aa9b4/librt-0.15.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8b2fdd7ead3c995c37940a790690660d0ca006c302db26cc51933f6766866fc3", size = 161638, upload-time = "2026-08-07T10:48:03.725Z" }, + { url = "https://files.pythonhosted.org/packages/ac/c4/9f9c9fba097d49e9e694c2b4dc331df31884645ecbc58a93b4b5fc69d2c5/librt-0.15.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2fde98cf1fc4bac144ce23c2c4c017b924ba714509ea9334977b0b27050c837d", size = 701795, upload-time = "2026-08-07T10:48:05.135Z" }, + { url = "https://files.pythonhosted.org/packages/4c/05/0966840bda0380c8ae167b9043c6230202941cc90ea29c48e096964c765e/librt-0.15.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:e3b461183c5fa7681b48560f91515f53a953122fb30c71e07abc67d7ddf58c38", size = 682147, upload-time = "2026-08-07T10:48:06.555Z" }, + { url = "https://files.pythonhosted.org/packages/18/af/1c47ca573c30ea47d195aec26133af522fea1104afaace028d7b32247ea8/librt-0.15.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4bbcc257e3babea20a91715c361b24554ec4e8f51aa578568afc230799fe1a19", size = 696397, upload-time = "2026-08-07T10:48:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/2e/0f/1aed6223d4f9f9d1171a8596ff100ea4c3f7699fea7a4ba657c3e60daa6c/librt-0.15.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b845b8d48088fad0cadc84be4b8fda63203be7e9237b71015b3925443c1f35ab", size = 722542, upload-time = "2026-08-07T10:48:09.569Z" }, + { url = "https://files.pythonhosted.org/packages/c6/22/9e3a929aea456c97d69e6ef3884efea56d4807f97399471cc946baebd8af/librt-0.15.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b30e600e8f337b9bd7f39b86d9fdfedc73cc46e3d0f745931a23a234220bb7e2", size = 729709, upload-time = "2026-08-07T10:48:11.129Z" }, + { url = "https://files.pythonhosted.org/packages/e9/1b/c327ef6018e3a9ca0b8e7c5eddeeb331ba8f9b76c24e126d37d0f6d62faf/librt-0.15.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:64b0c8c35aa4c4ed79896359f3e0b285cbe4e610042106500da4811c322cc108", size = 752891, upload-time = "2026-08-07T10:48:12.558Z" }, + { url = "https://files.pythonhosted.org/packages/d7/d1/d5f1ea02c56930087009e39db9b70660a663e76c730b27b925d786718457/librt-0.15.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0da0d94cb802f32a0524653e7201f2cef72d5f700a5407678f5290483d4fcd08", size = 745301, upload-time = "2026-08-07T10:48:14.55Z" }, + { url = "https://files.pythonhosted.org/packages/d9/3c/5f7c585d15ebb2250c73e7c0ee4e9e47be72c65d520c07ddbcdc62037674/librt-0.15.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4a6369168d371207339b1e50d4532b06a7121586141f82599505a3f315751d47", size = 747921, upload-time = "2026-08-07T10:48:16.453Z" }, + { url = "https://files.pythonhosted.org/packages/7f/52/1443a446486eba966bcbca1696b472e4f210320ec42f490a47f48fbf0fdc/librt-0.15.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c434e072557ade9cbc642d052c89d031efe47d5c9614523619d0d74a02378e81", size = 727561, upload-time = "2026-08-07T10:48:18.089Z" }, + { url = "https://files.pythonhosted.org/packages/79/91/2270a9380f11725cf83ce1925a5e32dd1dde2be9bba597f25c10a38644e7/librt-0.15.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7eec6a42018bc1d45763b1c162d3d2bf7c3b9a1b0ed30d3e91dcba390efefcc", size = 774417, upload-time = "2026-08-07T10:48:19.611Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/f4b1548d4f5b99186737fe27aec238e9823e8d5d23bf4df007c030689dc5/librt-0.15.0-cp314-cp314t-win32.whl", hash = "sha256:6912fa5e635d74529ac7cdb1bdf6ca3af4453da8d1edbe0110ee1cb4ad407ebf", size = 104381, upload-time = "2026-08-07T10:48:21.048Z" }, + { url = "https://files.pythonhosted.org/packages/80/b6/134afad262def1de04c0843c376d02135f1168af43f22e09a52bd8394727/librt-0.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8e11699ed745931c395acd3621b07062e0f840efa6935aad87a64ed0995f0915", size = 127034, upload-time = "2026-08-07T10:48:22.561Z" }, + { url = "https://files.pythonhosted.org/packages/99/5f/1b6846b20572bd699c9e9ec321a5f781845bee477df2aa2a43b28bc40119/librt-0.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5d2a91724463bfed4f573cd7a9fdc856d2e230d0c0e5a61416a93481dccd8605", size = 110827, upload-time = "2026-08-07T10:48:23.804Z" }, + { url = "https://files.pythonhosted.org/packages/c6/44/4de9f4ddadb009a55c7758eb5736d62534a7daaf27bd71bc50e64b606b06/librt-0.15.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:8443e38dcfcfdbcf5add5118c623efd788d65ac2e25756d6251a54a06a4d0aca", size = 149843, upload-time = "2026-08-07T10:48:25.148Z" }, + { url = "https://files.pythonhosted.org/packages/1f/eb/5d9ab71e30119c44094e0275f38b47dd327aea0f843a080396677029d508/librt-0.15.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6d15a29033c57490cfe2069097c6fc4049e4e65ffbb749be7dc453b7c4c68965", size = 154510, upload-time = "2026-08-07T10:48:26.485Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9c/8505d1b8f5e8c19587bd03f7429993b3e9ce5c06819d856bfb11d919374c/librt-0.15.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2c05c729b589e734c09578bf5964be48a911765484840d017bbc84f49d4c4ad", size = 497543, upload-time = "2026-08-07T10:48:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/1d/9a/3a8390775cb095765aded027ac9c63e7c8ea74e731498607544c6505de0e/librt-0.15.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:fa60887537e1d0cd2d9982269d33a709bf54b195cd2b9364fc0a758022af5bd9", size = 480452, upload-time = "2026-08-07T10:48:29.531Z" }, + { url = "https://files.pythonhosted.org/packages/e7/40/258a4a7117ee915d66de5cd9b8ade65a440993161107ce3a686f1859955c/librt-0.15.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d8bc24219b24c0af375718942ab75e3544b2763085f40f965be4326734ae8328", size = 507768, upload-time = "2026-08-07T10:48:31.007Z" }, + { url = "https://files.pythonhosted.org/packages/6b/c6/2f4dd296c97a0b85b98894519b279408ec9dd602d4f692b1ea0e25dee670/librt-0.15.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86a21a7bd3fe3a419512ef424cc1c020f6771d0b29cfddff36d1635a855e63f0", size = 525122, upload-time = "2026-08-07T10:48:32.7Z" }, + { url = "https://files.pythonhosted.org/packages/49/dd/29eab42be13b2bf0ea8cb227135a45d44693e30a7e8b92871981ff56b82b/librt-0.15.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dbab647e88d90b3167b91efe7091e248653688ed4337e4f90907a722c7361bb9", size = 520371, upload-time = "2026-08-07T10:48:34.294Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/4bad71adeca8fe208b775c2a35417fa5a2584c8f4791daaf89a89450fea1/librt-0.15.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:d8edcf6f550e918dca779c069b9e156385c60b406f99fc7641f32c52f7193659", size = 537258, upload-time = "2026-08-07T10:48:35.88Z" }, + { url = "https://files.pythonhosted.org/packages/4c/63/59dba6143fdcc7240c54458b629f3250000a61b8945890fc9efd451b19c5/librt-0.15.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:8b62076030baa2d8b1501a46bf0e19c27a489aa90671c55665bff7887f7660b0", size = 527432, upload-time = "2026-08-07T10:48:37.466Z" }, + { url = "https://files.pythonhosted.org/packages/ec/21/21a24c6a2327d8362580efebe77286bf47b0f4062ec5ea41766e609d3c7d/librt-0.15.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:d00d20d1818e82a07a0ee0aa89a98b17ed7916b92441090b683719cb20a59b6d", size = 548108, upload-time = "2026-08-07T10:48:39.384Z" }, + { url = "https://files.pythonhosted.org/packages/5a/6d/fc68c89a7971418b41f9a873623ff935cb864097544c6a2f8ce491c8ef5d/librt-0.15.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4e6ee93fc3cf848dcbf0cce2eca73d8e7dcd0cc2b6df3a529d57750b30a4c55c", size = 529681, upload-time = "2026-08-07T10:48:41.392Z" }, + { url = "https://files.pythonhosted.org/packages/65/7e/c2d98766124400d722063a630b0fde38a9fc768705d37eecca15c47dc192/librt-0.15.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:32896a0af72508ea979e0acb4e4c04cbeeae04938167950d535c83c45597167d", size = 567736, upload-time = "2026-08-07T10:48:43.124Z" }, + { url = "https://files.pythonhosted.org/packages/55/6c/f8c34a95e3a515c6e1c192b89511e7253c89a7760c6b500d57ffdb8d2dc8/librt-0.15.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:ec3ba415afaf951f6951b1dd16d3c8e4f540065fc382d7e70b823a79567ca374", size = 81673, upload-time = "2026-08-07T10:48:44.645Z" }, + { url = "https://files.pythonhosted.org/packages/c9/9e/e23fa8e78679ec45728188650b39e8ff476c83b691c96f749217df3b1b7c/librt-0.15.0-cp315-cp315-win32.whl", hash = "sha256:d2813ba2503764f0450680c533d13df7cff9b49df1411062eded5f67db4195b9", size = 100081, upload-time = "2026-08-07T10:48:46.171Z" }, + { url = "https://files.pythonhosted.org/packages/e1/dc/3eb4c5e297343f0620a55532cd7c8d764d3001fa2159212dadf480464827/librt-0.15.0-cp315-cp315-win_amd64.whl", hash = "sha256:b87d67e33afaf265262f2a66db578284b88ee2e6fcd224579cb5c15518677ad8", size = 121228, upload-time = "2026-08-07T10:48:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/97/70/43abce19f04e49762f8ec834c8fafee13cc40fd6b94a72a24e534febfcd0/librt-0.15.0-cp315-cp315-win_arm64.whl", hash = "sha256:713bd7df21170b982e729e46870f31d6b437bd1a9b4648cffb529bd3c2ec5c4b", size = 106487, upload-time = "2026-08-07T10:48:49.095Z" }, + { url = "https://files.pythonhosted.org/packages/de/15/83f2deddb9368b8951ec8c9477269b5b9b8bd9bbf15e57402d0f38817dca/librt-0.15.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3de789c82752730f94782a5ee518baf9c05edf85733aeaf73bb6e518755cdf54", size = 159448, upload-time = "2026-08-07T10:48:50.649Z" }, + { url = "https://files.pythonhosted.org/packages/06/bf/043097353f9b3c73b583d07f6b8e552795463f4bfc8caf85e42eee50c26a/librt-0.15.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:e0b5deec9a8664eb722c797241970fd4aa1894d25fda36a1ddac0f7407606bd6", size = 161686, upload-time = "2026-08-07T10:48:52.174Z" }, + { url = "https://files.pythonhosted.org/packages/f4/2a/8ae77f9719d42ce71cd708560a3557b38ac3c17a0383e57f87084de45bbe/librt-0.15.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5563302a8359bc2295bb7084d1a8ed1519df96afb30eb2aa4e0bff7b54228988", size = 710668, upload-time = "2026-08-07T10:48:53.782Z" }, + { url = "https://files.pythonhosted.org/packages/61/34/c0436ea134deb9a0d6da80a396a2739a81cb31e0418f7227239e23140898/librt-0.15.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:22d6263b9d39d7bbb286fa791945646e3218f1be2d693e36fb630f1d0e59cd13", size = 679396, upload-time = "2026-08-07T10:48:55.645Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/001e0d99aa9250d5cd5715a9081291a20656083459f9019cda15255329e1/librt-0.15.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39ffd14646190c454f0d86e0d256b33f00a87a26ab410e619773b841d0e41416", size = 704313, upload-time = "2026-08-07T10:48:57.46Z" }, + { url = "https://files.pythonhosted.org/packages/2d/53/b34fa9d0ff00f136f4d58ebb4c411ff634baed1eb412bb602a2bc8dcafcb/librt-0.15.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47318cd3a61401452de11282242937e3e057c4fd3dbaf601e269d0928a06c0a", size = 729847, upload-time = "2026-08-07T10:48:59.231Z" }, + { url = "https://files.pythonhosted.org/packages/86/ac/fa4d7a424665040e95baf480a6d523446057684b6758624c85338e8a23b2/librt-0.15.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a56a1d4f859a82ca5b99fc4b82c9b027b15e3c455c5cd99e7d0719f27bb20b6c", size = 742736, upload-time = "2026-08-07T10:49:01.151Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f1/e17a9bb5de6fb8c3186ed1a7d68d21618b027ac2d3633e03d3b6109c67ae/librt-0.15.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:077471b3182db4e17c36ae91555f36a4d2c00080b267f749bcad34a478a9a302", size = 763454, upload-time = "2026-08-07T10:49:03.039Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ec/ecd02cd30935b931b9cdbfed6ab5a099c51b280b4e7baa274da80978ed27/librt-0.15.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:411ca4d1b905b860ceba7570dd6717a71dedaddcc4b0f77ece710aa41ee11f8d", size = 743296, upload-time = "2026-08-07T10:49:04.941Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b5/b3c2b8353ce820a4854f78d19321344242f89fa71c975b71132ba9bf242a/librt-0.15.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1256589e0b0adb31751d685a68bce29d73407ddf4ef05d4188f49d5dcf9566d9", size = 756217, upload-time = "2026-08-07T10:49:06.825Z" }, + { url = "https://files.pythonhosted.org/packages/3c/52/6cc22542ba59146b05cca2a656f9ff8bb67e38e63d12c3b0cc183d837bf1/librt-0.15.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:f42b74a53e5f26a0ba0007411a7455b66c67ce4022a39cc1f56fc4efd65bcbab", size = 741934, upload-time = "2026-08-07T10:49:08.839Z" }, + { url = "https://files.pythonhosted.org/packages/40/32/a04b72b1aa86e3be23b2ecff8c1aad2dcc955bd3956d6d26e7e34267e57a/librt-0.15.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:291bf73caf78b9e88d6fae9bfd693207ff7d832e2fdbe2cf8e746bc13f5f892b", size = 783763, upload-time = "2026-08-07T10:49:10.661Z" }, + { url = "https://files.pythonhosted.org/packages/6c/f0/89eb11dffbe9279ff37144dec786927314502ae0b114f1449dc78c458aab/librt-0.15.0-cp315-cp315t-win32.whl", hash = "sha256:c16d15ee371643ab48dc8248a3e680ebbeca573a13af2c3dd0c985b142d77162", size = 104313, upload-time = "2026-08-07T10:49:12.305Z" }, + { url = "https://files.pythonhosted.org/packages/6d/4a/1f1978c200f563beda63c36adff2d65bbecb81e365e8e69e572f5f70fbc6/librt-0.15.0-cp315-cp315t-win_amd64.whl", hash = "sha256:dbd605739f228912dc49027cb764456b9757750bdc2b6b7773164db7096c6fd1", size = 126889, upload-time = "2026-08-07T10:49:13.881Z" }, + { url = "https://files.pythonhosted.org/packages/38/a6/800800bfed7b1fb10fc3f3d557785c3854e80d3f7a9800d784b176a1fc2d/librt-0.15.0-cp315-cp315t-win_arm64.whl", hash = "sha256:84d244b00604d17df3fc7736c327892d6bba66181254aa4087be807b6c342bdc", size = 110700, upload-time = "2026-08-07T10:49:15.499Z" }, +] + +[[package]] +name = "mypy" +version = "1.20.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/af/e3d4b3e9ec91a0ff9aabfdb38692952acf49bbb899c2e4c29acb3a6da3ae/mypy-1.20.2.tar.gz", hash = "sha256:e8222c26daaafd9e8626dec58ae36029f82585890589576f769a650dd20fd665", size = 3817349, upload-time = "2026-04-21T17:12:28.473Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/4d/9ebeae211caccbdaddde7ed5e31dfcf57faac66be9b11deb1dc6526c8078/mypy-1.20.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4077797a273e56e8843d001e9dfe4ba10e33323d6ade647ff260e5cd97d9758c", size = 14371307, upload-time = "2026-04-21T17:08:56.442Z" }, + { url = "https://files.pythonhosted.org/packages/95/d7/93473d34b61f04fac1aecc01368485c89c5c4af7a4b9a0cab5d77d04b63f/mypy-1.20.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cdecf62abcc4292500d7858aeae87a1f8f1150f4c4dd08fb0b336ee79b2a6df3", size = 13258917, upload-time = "2026-04-21T17:05:50.978Z" }, + { url = "https://files.pythonhosted.org/packages/e2/30/3dd903e8bafb7b5f7bf87fcd58f8382086dea2aa19f0a7b357f21f63071b/mypy-1.20.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c566c3a88b6ece59b3d70f65bedef17304f48eb52ff040a6a18214e1917b3254", size = 13700516, upload-time = "2026-04-21T17:11:33.161Z" }, + { url = "https://files.pythonhosted.org/packages/07/05/c61a140aba4c729ac7bc99ae26fc627c78a6e08f5b9dd319244ea71a3d7e/mypy-1.20.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0deb80d062b2479f2c87ae568f89845afc71d11bc41b04179e58165fd9f31e98", size = 14562889, upload-time = "2026-04-21T17:05:27.674Z" }, + { url = "https://files.pythonhosted.org/packages/fd/87/da78243742ffa8a36d98c3010f0d829f93d5da4e6786f1a1a6f2ad616502/mypy-1.20.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bba9ad231e92a3e424b3e56b65aa17704993425bba97e302c832f9466bb85bac", size = 14803844, upload-time = "2026-04-21T17:10:06.2Z" }, + { url = "https://files.pythonhosted.org/packages/37/52/10a1ddf91b40f843943a3c6db51e2df59c9e237f29d355e95eaab427461f/mypy-1.20.2-cp311-cp311-win_amd64.whl", hash = "sha256:baf593f2765fa3a6b1ef95807dbaa3d25b594f6a52adcc506a6b9cb115e1be67", size = 10846300, upload-time = "2026-04-21T17:12:23.886Z" }, + { url = "https://files.pythonhosted.org/packages/20/02/f9a4415b664c53bd34d6709be59da303abcae986dc4ac847b402edb6fa1e/mypy-1.20.2-cp311-cp311-win_arm64.whl", hash = "sha256:20175a1c0f49863946ec20b7f63255768058ac4f07d2b9ded6a6b46cfb5a9100", size = 9779498, upload-time = "2026-04-21T17:09:23.695Z" }, + { url = "https://files.pythonhosted.org/packages/71/4e/7560e4528db9e9b147e4c0f22660466bf30a0a1fe3d63d1b9d3b0fd354ee/mypy-1.20.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4dbfcf869f6b0517f70cf0030ba6ea1d6645e132337a7d5204a18d8d5636c02b", size = 14539393, upload-time = "2026-04-21T17:07:12.52Z" }, + { url = "https://files.pythonhosted.org/packages/32/d9/34a5efed8124f5a9234f55ac6a4ced4201e2c5b81e1109c49ad23190ec8c/mypy-1.20.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b6481b228d072315b053210b01ac320e1be243dc17f9e5887ef167f23f5fae4", size = 13361642, upload-time = "2026-04-21T17:06:53.742Z" }, + { url = "https://files.pythonhosted.org/packages/d1/14/eb377acf78c03c92d566a1510cda8137348215b5335085ef662ab82ecd3a/mypy-1.20.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34397cdced6b90b836e38182076049fdb41424322e0b0728c946b0939ebdf9f6", size = 13740347, upload-time = "2026-04-21T17:12:04.73Z" }, + { url = "https://files.pythonhosted.org/packages/b9/94/7e4634a32b641aa1c112422eed1bbece61ee16205f674190e8b536f884de/mypy-1.20.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5da6976f20cae27059ea8d0c86e7cef3de720e04c4bb9ee18e3690fdb792066", size = 14734042, upload-time = "2026-04-21T17:07:43.16Z" }, + { url = "https://files.pythonhosted.org/packages/7a/f3/f7e62395cb7f434541b4491a01149a4439e28ace4c0c632bbf5431e92d1f/mypy-1.20.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:56908d7e08318d39f85b1f0c6cfd47b0cac1a130da677630dac0de3e0623e102", size = 14964958, upload-time = "2026-04-21T17:11:00.665Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0d/47e3c3a0ec2a876e35aeac365df3cac7776c36bbd4ed18cc521e1b9d255b/mypy-1.20.2-cp312-cp312-win_amd64.whl", hash = "sha256:d52ad8d78522da1d308789df651ee5379088e77c76cb1994858d40a426b343b9", size = 10911340, upload-time = "2026-04-21T17:10:49.179Z" }, + { url = "https://files.pythonhosted.org/packages/d6/b2/6c852d72e0ea8b01f49da817fb52539993cde327e7d010e0103dc12d0dac/mypy-1.20.2-cp312-cp312-win_arm64.whl", hash = "sha256:785b08db19c9f214dc37d65f7c165d19a30fcecb48abfa30f31b01b5acaabb58", size = 9833947, upload-time = "2026-04-21T17:09:05.267Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c4/b93812d3a192c9bcf5df405bd2f30277cd0e48106a14d1023c7f6ed6e39b/mypy-1.20.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:edfbfca868cdd6bd8d974a60f8a3682f5565d3f5c99b327640cedd24c4264026", size = 14524670, upload-time = "2026-04-21T17:10:30.737Z" }, + { url = "https://files.pythonhosted.org/packages/f3/47/42c122501bff18eaf1e8f457f5c017933452d8acdc52918a9f59f6812955/mypy-1.20.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e2877a02380adfcdbc69071a0f74d6e9dbbf593c0dc9d174e1f223ffd5281943", size = 13336218, upload-time = "2026-04-21T17:08:44.069Z" }, + { url = "https://files.pythonhosted.org/packages/92/8f/75bbc92f41725fbd585fb17b440b1119b576105df1013622983e18640a93/mypy-1.20.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7488448de6007cd5177c6cea0517ac33b4c0f5ee9b5e9f2be51ce75511a85517", size = 13724906, upload-time = "2026-04-21T17:08:01.02Z" }, + { url = "https://files.pythonhosted.org/packages/a1/32/4c49da27a606167391ff0c39aa955707a00edc500572e562f7c36c08a71f/mypy-1.20.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bb9c2fa06887e21d6a3a868762acb82aec34e2c6fd0174064f27c93ede68ad15", size = 14726046, upload-time = "2026-04-21T17:11:22.354Z" }, + { url = "https://files.pythonhosted.org/packages/7f/fc/4e354a1bd70216359deb0c9c54847ee6b32ef78dfb09f5131ff99b494078/mypy-1.20.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d56a78b646f2e3daa865bc70cd5ec5a46c50045801ca8ff17a0c43abc97e3ee", size = 14955587, upload-time = "2026-04-21T17:12:16.033Z" }, + { url = "https://files.pythonhosted.org/packages/62/b2/c0f2056e9eb8f08c62cafd9715e4584b89132bdc832fcf85d27d07b5f3e5/mypy-1.20.2-cp313-cp313-win_amd64.whl", hash = "sha256:2a4102b03bb7481d9a91a6da8d174740c9c8c4401024684b9ca3b7cc5e49852f", size = 10922681, upload-time = "2026-04-21T17:06:35.842Z" }, + { url = "https://files.pythonhosted.org/packages/e5/14/065e333721f05de8ef683d0aa804c23026bcc287446b61cac657b902ccac/mypy-1.20.2-cp313-cp313-win_arm64.whl", hash = "sha256:a95a9248b0c6fd933a442c03c3b113c3b61320086b88e2c444676d3fd1ca3330", size = 9830560, upload-time = "2026-04-21T17:07:51.023Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d1/b4ec96b0ecc620a4443570c6e95c867903428cfcde4206518eafdd5880c3/mypy-1.20.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:419413398fe250aae057fd2fe50166b61077083c9b82754c341cf4fd73038f30", size = 14524561, upload-time = "2026-04-21T17:06:27.325Z" }, + { url = "https://files.pythonhosted.org/packages/3a/63/d2c2ff4fa66bc49477d32dfa26e8a167ba803ea6a69c5efb416036909d30/mypy-1.20.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e73c07f23009962885c197ccb9b41356a30cc0e5a1d0c2ea8fd8fb1362d7f924", size = 13363883, upload-time = "2026-04-21T17:11:11.239Z" }, + { url = "https://files.pythonhosted.org/packages/2a/56/983916806bf4eddeaaa2c9230903c3669c6718552a921154e1c5182c701f/mypy-1.20.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c64e5973df366b747646fc98da921f9d6eba9716d57d1db94a83c026a08e0fb", size = 13742945, upload-time = "2026-04-21T17:08:34.181Z" }, + { url = "https://files.pythonhosted.org/packages/19/65/0cd9285ab010ee8214c83d67c6b49417c40d86ce46f1aa109457b5a9b8d7/mypy-1.20.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a65aa591af023864fd08a97da9974e919452cfe19cb146c8a5dc692626445dc", size = 14706163, upload-time = "2026-04-21T17:05:15.51Z" }, + { url = "https://files.pythonhosted.org/packages/94/97/48ff3b297cafcc94d185243a9190836fb1b01c1b0918fff64e941e973cc9/mypy-1.20.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4fef51b01e638974a6e69885687e9bd40c8d1e09a6cd291cca0619625cf1f558", size = 14938677, upload-time = "2026-04-21T17:05:39.562Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a1/1b4233d255bdd0b38a1f284feeb1c143ca508c19184964e22f8d837ec851/mypy-1.20.2-cp314-cp314-win_amd64.whl", hash = "sha256:913485a03f1bcf5d279409a9d2b9ed565c151f61c09f29991e5faa14033da4c8", size = 11089322, upload-time = "2026-04-21T17:06:44.29Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/ce7ee2ba36aeb954ba50f18fa25d9c1188578654b97d02a66a15b6f09531/mypy-1.20.2-cp314-cp314-win_arm64.whl", hash = "sha256:c3bae4f855d965b5453784300c12ffc63a548304ac7f99e55d4dc7c898673aa3", size = 10017775, upload-time = "2026-04-21T17:07:20.732Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a1/9d93a7d0b5859af0ead82b4888b46df6c8797e1bc5e1e262a08518c6d48e/mypy-1.20.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2de3dcea53babc1c3237a19002bc3d228ce1833278f093b8d619e06e7cc79609", size = 15549002, upload-time = "2026-04-21T17:08:23.107Z" }, + { url = "https://files.pythonhosted.org/packages/00/d2/09a6a10ee1bf0008f6c144d9676f2ca6a12512151b4e0ad0ff6c4fac5337/mypy-1.20.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:52b176444e2e5054dfcbcb8c75b0b719865c96247b37407184bbfca5c353f2c2", size = 14401942, upload-time = "2026-04-21T17:07:31.837Z" }, + { url = "https://files.pythonhosted.org/packages/57/da/9594b75c3c019e805250bed3583bdf4443ff9e6ef08f97e39ae308cb06f2/mypy-1.20.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:688c3312e5dadb573a2c69c82af3a298d43ecf9e6d264e0f95df960b5f6ac19c", size = 15041649, upload-time = "2026-04-21T17:09:34.653Z" }, + { url = "https://files.pythonhosted.org/packages/97/77/f75a65c278e6e8eba2071f7f5a90481891053ecc39878cc444634d892abe/mypy-1.20.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29752dbbf8cc53f89f6ac096d363314333045c257c9c75cbd189ca2de0455744", size = 15864588, upload-time = "2026-04-21T17:11:44.936Z" }, + { url = "https://files.pythonhosted.org/packages/d7/46/1a4e1c66e96c1a3246ddf5403d122ac9b0a8d2b7e65730b9d6533ba7a6d3/mypy-1.20.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:803203d2b6ea644982c644895c2f78b28d0e208bba7b27d9b921e0ec5eb207c6", size = 16093956, upload-time = "2026-04-21T17:10:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/5a/2c/78a8851264dec38cd736ca5b8bc9380674df0dd0be7792f538916157716c/mypy-1.20.2-cp314-cp314t-win_amd64.whl", hash = "sha256:9bcb8aa397ff0093c824182fd76a935a9ba7ad097fcbef80ae89bf6c1731d8ec", size = 12568661, upload-time = "2026-04-21T17:11:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/83/01/cd7318aa03493322ce275a0e14f4f52b8896335e4e79d4fb8153a7ad2b77/mypy-1.20.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e061b58443f1736f8a37c48978d7ab581636d6ab03e3d4f99e3fa90463bb9382", size = 10389240, upload-time = "2026-04-21T17:09:42.719Z" }, + { url = "https://files.pythonhosted.org/packages/28/9a/f23c163e25b11074188251b0b5a0342625fc1cdb6af604757174fa9acc9b/mypy-1.20.2-py3-none-any.whl", hash = "sha256:a94c5a76ab46c5e6257c7972b6c8cff0574201ca7dc05647e33e795d78680563", size = 2637314, upload-time = "2026-04-21T17:05:54.5Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[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 = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[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 = "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 = "pytest" +version = "8.4.2" +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/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" }, +] + +[[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 = "repository-stewardship" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "jsonschema" }, + { name = "ruamel-yaml" }, +] + +[package.dev-dependencies] +dev = [ + { name = "mypy" }, + { name = "pytest" }, + { name = "ruff" }, + { name = "types-jsonschema" }, +] + +[package.metadata] +requires-dist = [ + { name = "jsonschema", specifier = ">=4.25,<5" }, + { name = "ruamel-yaml", specifier = ">=0.19,<0.20" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "mypy", specifier = ">=1.18,<2" }, + { name = "pytest", specifier = ">=8.4,<9" }, + { name = "ruff", specifier = ">=0.12,<1" }, + { name = "types-jsonschema", specifier = ">=4.26.0.20260518" }, +] + +[[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/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" }, + { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" }, + { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" }, + { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" }, + { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" }, + { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" }, + { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" }, + { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" }, + { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" }, + { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" }, + { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" }, + { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" }, + { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" }, + { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" }, + { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" }, + { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" }, + { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" }, + { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" }, + { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" }, + { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" }, + { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" }, + { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" }, + { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" }, + { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" }, + { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" }, + { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" }, + { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" }, + { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" }, + { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" }, + { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" }, + { 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 = "ruamel-yaml" +version = "0.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/3b/ebda527b56beb90cb7652cb1c7e4f91f48649fbcd8d2eb2fb6e77cd3329b/ruamel_yaml-0.19.1.tar.gz", hash = "sha256:53eb66cd27849eff968ebf8f0bf61f46cdac2da1d1f3576dd4ccee9b25c31993", size = 142709, upload-time = "2026-01-02T16:50:31.84Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/0c/51f6841f1d84f404f92463fc2b1ba0da357ca1e3db6b7fbda26956c3b82a/ruamel_yaml-0.19.1-py3-none-any.whl", hash = "sha256:27592957fedf6e0b62f281e96effd28043345e0e66001f97683aa9a40c667c93", size = 118102, upload-time = "2026-01-02T16:50:29.201Z" }, +] + +[[package]] +name = "ruff" +version = "0.16.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/8f/d8074b1f25e003164087a8bfe79a0f1a3945135764dbb6aaab04103dcaf9/ruff-0.16.4.tar.gz", hash = "sha256:13171aa9d9af2240ee3504e639de73122c67e74036de5ba2e1d01422cd17e3dc", size = 4899731, upload-time = "2026-08-20T17:43:59.196Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/80/779895ef584e089d22f2c6df0d0e99a65ec2df0805f1fffd439415b8c1f0/ruff-0.16.4-py3-none-linux_armv6l.whl", hash = "sha256:df4075f71ddac40b9934af60c3ec8a53047dd5a5fdc43224e6e4e8e9a27cb6f7", size = 10006909, upload-time = "2026-08-20T17:43:16.888Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e6/f553199b5e8927a05cb5c422d921fd0656b29ab976e91c44802107c6b0da/ruff-0.16.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0c95538517af68004306b0fb3214ff2f2af67a65092aee77cd9eb86db6656604", size = 10240201, upload-time = "2026-08-20T17:43:19.337Z" }, + { url = "https://files.pythonhosted.org/packages/1c/70/4a6dc4bb34da4dee35e30f09bbd1bfbdd26f33b62fb9b8df31f08a199cd2/ruff-0.16.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:963f83df8e69e575b64d67dd447ebbc917db41a14bf38d4593a4183e7aaa8255", size = 9835122, upload-time = "2026-08-20T17:43:21.708Z" }, + { url = "https://files.pythonhosted.org/packages/24/12/c6e22d686372c15bcb7af99831f1a1be96df696491babf4f24e4f942c527/ruff-0.16.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32a5057c7ff3f6e6480a48fccfb3a412a690f48a3d03ac5cf08177d6c2da3ade", size = 9977162, upload-time = "2026-08-20T17:43:24.236Z" }, + { url = "https://files.pythonhosted.org/packages/46/49/72b10ec912f5ab5854992eaf7aa7cd36729b6937d9dc4e0fb41b3bf428ec/ruff-0.16.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b3dce8d9b0c57c265b91885a66a567d8ea1372e8eb4e250fa8e5e3f579e99cff", size = 9829789, upload-time = "2026-08-20T17:43:26.966Z" }, + { url = "https://files.pythonhosted.org/packages/fa/80/0f30e32e7f6ee26edc39075502db9d368d788a44a79b55f763eb4ab03796/ruff-0.16.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7dc651db49283c69f8e72c834eec4fe5573e4c646856aebece0ce385dceb2a80", size = 10527949, upload-time = "2026-08-20T17:43:29.384Z" }, + { url = "https://files.pythonhosted.org/packages/52/3d/86e8ad3542169e56cac3859a343afdb9df2ad54d35a59ce1e67baee83421/ruff-0.16.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3817b87dbcabc92f13b05019257c5b89b5b4d51b5fb20f56fb5235ceb723cd07", size = 11333695, upload-time = "2026-08-20T17:43:31.872Z" }, + { url = "https://files.pythonhosted.org/packages/d0/16/481c29b380c20a0054a8261066665e1b3488e23636c49d0a43e75975b9bb/ruff-0.16.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9fce1499134b2c8c68e5166f95705a5812062bb93aacc5f9873bb1a27084bc7", size = 10727741, upload-time = "2026-08-20T17:43:34.596Z" }, + { url = "https://files.pythonhosted.org/packages/5e/b6/56bc0b8cf45b54b28b3a5e6381c8945d51b5b18adf659454c32295209a31/ruff-0.16.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2d812e482f5a7e02eee26cd73d2a37ebbdf47d795ea63ba1b89110ae93e9fb3", size = 10286522, upload-time = "2026-08-20T17:43:37.288Z" }, + { url = "https://files.pythonhosted.org/packages/e8/8b/b345b4fb110f2fbe2bd31eabd271e5e8b3b7e4ee6c0e02f2dc6be78db000/ruff-0.16.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:6baaf984aa7976edf93d3b627fe2d1d22ee94bbca05fa6f90fc76d73924e3454", size = 10584182, upload-time = "2026-08-20T17:43:39.984Z" }, + { url = "https://files.pythonhosted.org/packages/29/e5/827b34041c35f58774a9681a4213994c164fc987800f4dddabcf451da0bf/ruff-0.16.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:bdfcf0b28662eb890372d50f92c283bb94e67e7635ed93c7fd533970acff7b2b", size = 10134195, upload-time = "2026-08-20T17:43:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/0f/10/d0bffcdd6729b87afc82ba0ef377173356a7dc8e972f5179968cf2fdf98c/ruff-0.16.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b66b02cb9b04f537643cadf5768e5f98dc461890d530cb67113d71c8c76e605d", size = 9825821, upload-time = "2026-08-20T17:43:44.532Z" }, + { url = "https://files.pythonhosted.org/packages/f5/32/0db2a863b796ca62d83e92a07a3ccf00921b14db02059347576a2fda3d4b/ruff-0.16.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:8528bf9a4b291a60bf02ea453511e8ce6215bd2b982ee80405b66b008b6c30a0", size = 10267658, upload-time = "2026-08-20T17:43:46.989Z" }, + { url = "https://files.pythonhosted.org/packages/b2/a0/fbdeb59e48c6261f523e56c8f12e9c08fbe693786595cc7e3959207a9232/ruff-0.16.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:fbd85d2875fdd67e833213a651f613bbf25303abf6aa822a5121f4531195678d", size = 10697071, upload-time = "2026-08-20T17:43:49.891Z" }, + { url = "https://files.pythonhosted.org/packages/aa/28/0c6dd865859c6d17bc8ccc34cb72b0e02d6c7eb25e8a1e22b5bea681e2c0/ruff-0.16.4-py3-none-win32.whl", hash = "sha256:312769988007aaeb8e189b443ccdd03c0e6374489e053467be6d96518ebff76e", size = 10021687, upload-time = "2026-08-20T17:43:52.281Z" }, + { url = "https://files.pythonhosted.org/packages/a3/03/e724450f621698117f9aa6dd241c94d0274ae96781378dc86745ae29f0e7/ruff-0.16.4-py3-none-win_amd64.whl", hash = "sha256:05d9d27a18c4bcbefada602480ec9e01e0bc949d432e0ced5df77edac195919c", size = 10567657, upload-time = "2026-08-20T17:43:54.78Z" }, + { url = "https://files.pythonhosted.org/packages/0e/fe/da8b9e1347696bb22120b77280ec5ce25d500ca5cb39d5ad6e5c18de19c1/ruff-0.16.4-py3-none-win_arm64.whl", hash = "sha256:a3a61621c9b6f6a89573e938a080e648f1695baa3f58570a3a707bc51ff65a21", size = 10451579, upload-time = "2026-08-20T17:43:57.135Z" }, +] + +[[package]] +name = "types-jsonschema" +version = "4.26.0.20260518" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dd/46/73b6a5d61a61015c4248030a8cb07e5bdddb4041430fae9e585a68692578/types_jsonschema-4.26.0.20260518.tar.gz", hash = "sha256:e1dd53dc97a64f5eccdd6fa9839666e09bb500a8ebba2db6fdaf1789faea81a6", size = 16638, upload-time = "2026-05-18T06:06:44.106Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/d5/134f8a147dcecda10db7f60cfc6af0578a25a5c53c87b3907a64385e0184/types_jsonschema-4.26.0.20260518-py3-none-any.whl", hash = "sha256:30b30a518c7fe335df85c919fcbcc631b69c03d4a4b5b632fa916bea03065307", size = 16072, upload-time = "2026-05-18T06:06:43.264Z" }, +] + +[[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" }, +]