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 <noreply@anthropic.com>
This commit is contained in:
Alexander Baranov
2026-08-24 14:57:34 +03:00
co-authored by Claude Sonnet 5
parent 9a39b8a941
commit 96d4d08230
75 changed files with 4259 additions and 0 deletions
+41
View File
@@ -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
+3
View File
@@ -0,0 +1,3 @@
"""Repository Stewardship protocol implementation."""
__version__ = "0.1.0"
+396
View File
@@ -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,
}
+235
View File
@@ -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
+334
View File
@@ -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())
+20
View File
@@ -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()
+75
View File
@@ -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()]
+19
View File
@@ -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"}
+149
View File
@@ -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
+151
View File
@@ -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)
+35
View File
@@ -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()}
+86
View File
@@ -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"
+176
View File
@@ -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"(?<!!)\[[^\]]*\]\(([^)\s]+)(?:\s+\"[^\"]*\")?\)")
_MERMAID_HEADERS = {
"flowchart",
"graph",
"sequenceDiagram",
"stateDiagram-v2",
"stateDiagram",
"classDiagram",
"erDiagram",
"gantt",
"pie",
"journey",
"mindmap",
"timeline",
}
@dataclass
class MarkdownCheckResult:
findings: list[Finding]
def check_markdown_file(repo_root: Path, rel_path: str) -> 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
+51
View File
@@ -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]
+48
View File
@@ -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']}")
+83
View File
@@ -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 "<root>"
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)
@@ -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" } }
}
}
@@ -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" }
}
}
@@ -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" } }
}
}
@@ -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" }
}
}
@@ -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" }
}
}
}
}
}
}
}
@@ -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" } }
}
}
}
}
@@ -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" }
}
}
}
}
}
}
@@ -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"] }
}
}
}
}
@@ -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" }
}
}
}
}
}
@@ -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 }
}
}
+82
View File
@@ -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 <path> --answers <answers-file> --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 <path> --apply --plan <plan-file> --approve <planHash>`.
5. Report the resulting `repoctl validate --repo <path>` 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 <path> --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 <path> --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 <path> --mode apply --plan <plan-file> --approve <planHash>`.
6. Run `repoctl adopt --repo <path> --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 <name-or-path> --intent <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.
"""
+24
View File
@@ -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),
)
+416
View File
@@ -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)]
+48
View File
@@ -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/<name>/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
+2
View File
@@ -0,0 +1,2 @@
custom_format: true
notes: Pre-existing custom knowledge base that already occupies kdb/kdb.yaml
+2
View File
@@ -0,0 +1,2 @@
windows_agent_rollout:
summary: Legacy root-level knowledge base, predates Repository Stewardship
@@ -0,0 +1,2 @@
name: default
config: {}
@@ -0,0 +1,2 @@
name: default
config: {}
+15
View File
@@ -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
+20
View File
@@ -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
+15
View File
@@ -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
+11
View File
@@ -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
+18
View File
@@ -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 /"
+10
View File
@@ -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
+3
View File
@@ -0,0 +1,3 @@
# infra-lxd agent instructions
Read `ops/contract.yaml`, then use `repoctl context` for the task at hand.
+3
View File
@@ -0,0 +1,3 @@
# CLAUDE.md
@AGENTS.md
@@ -0,0 +1,3 @@
# Container deployment
Create containers from `profiles-source/`.
+22
View File
@@ -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
+46
View File
@@ -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
@@ -0,0 +1,2 @@
name: default
config: {}
@@ -0,0 +1,2 @@
name: default
config: {}
+3
View File
@@ -0,0 +1,3 @@
# example-project agent instructions
Read `ops/contract.yaml`, then use `repoctl context`.
+3
View File
@@ -0,0 +1,3 @@
# CLAUDE.md
@AGENTS.md
@@ -0,0 +1,3 @@
# ADR 0001
Placeholder decision record.
@@ -0,0 +1,3 @@
# Deliverable one
Placeholder deliverable content for a fixture repository.
+9
View File
@@ -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: []
@@ -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
+3
View File
@@ -0,0 +1,3 @@
# services-antivirus agent instructions
Read `ops/contract.yaml`, then use `repoctl context`.
+3
View File
@@ -0,0 +1,3 @@
# CLAUDE.md
@AGENTS.md
@@ -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: []
@@ -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
+3
View File
@@ -0,0 +1,3 @@
# example-software agent instructions
Read `ops/contract.yaml`, then use `repoctl context`.
+3
View File
@@ -0,0 +1,3 @@
# CLAUDE.md
@AGENTS.md
+9
View File
@@ -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: []
@@ -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
+1
View File
@@ -0,0 +1 @@
print("example")
@@ -0,0 +1,2 @@
def test_placeholder():
assert True
+91
View File
@@ -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
+51
View File
@@ -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"
+41
View File
@@ -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
+35
View File
@@ -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
+64
View File
@@ -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)
+32
View File
@@ -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"]
+23
View File
@@ -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
+27
View File
@@ -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()
Generated
+511
View File
@@ -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" },
]