"""``explicit-resource`` — exact-revision resource fetch and verification. Subcommands: list Show every pinned resource with its role, revision, required approval gates, and current block status given an approval file. fetch Download one or all resources at pinned revisions into the model/data roots, appending a ``resource_snapshot.jsonl`` row per success. A blocked gate skips the resource with a reason (never substitutes). verify Offline-verify a previously fetched resource against its recorded snapshot row (recompute the file-tree manifest, detect LFS pointers, reject a resolved/requested-commit mismatch or content drift). See ``docs/01_RESOURCE_CATALOG.md`` §7 and ``docs/07_IMPLEMENTATION_TASKS.md`` section 3. """ from __future__ import annotations import argparse import json import os import sys from pathlib import Path from .. import __version__ from ..config import ConfigError, load_resources from ..logging_setup import get_logger from ..paths import repo_root from ..resources import ( ResourceError, block_reason, fetch_one, load_approval, plan, verify_one, ) logger = get_logger("resource") def _add_config(parser: argparse.ArgumentParser) -> None: parser.add_argument( "--resources", type=Path, default=repo_root() / "configs" / "resources.yaml", ) def _token() -> str | None: """Read ``HF_TOKEN`` from the environment (never logged).""" return os.environ.get("HF_TOKEN") or None def cmd_list(args: argparse.Namespace) -> int: try: resources = load_resources(args.resources) except (ConfigError, FileNotFoundError) as exc: print(f"RESOURCE LIST FAILED: {exc}", file=sys.stderr) return 1 approval = load_approval(args.approval) rows = [] for ref in plan(resources): reason = block_reason(ref, approval) rows.append( { "logical_name": ref.logical_name, "kind": ref.kind, "role": ref.role, "repo_id": ref.repo_id, "revision": ref.revision, "local_path": str(ref.local_path), "required_gates": list(ref.required_gates), "blocked": reason is not None, "block_reason": reason, } ) print(json.dumps({"resources": rows}, sort_keys=True)) return 0 def _snapshot_path(args: argparse.Namespace) -> Path: return Path(args.snapshot) def cmd_fetch(args: argparse.Namespace) -> int: try: resources = load_resources(args.resources) except (ConfigError, FileNotFoundError) as exc: print(f"RESOURCE FETCH FAILED: {exc}", file=sys.stderr) return 1 approval = load_approval(args.approval) refs = plan(resources) if args.name: wanted = set(args.name) refs = [r for r in refs if r.logical_name in wanted] missing = wanted - {r.logical_name for r in refs} if missing: print(f"RESOURCE FETCH FAILED: unknown resource(s): {sorted(missing)}", file=sys.stderr) return 1 allow = tuple(args.include) if args.include else None snapshot_path = _snapshot_path(args) snapshot_path.parent.mkdir(parents=True, exist_ok=True) results = [] failures = 0 for ref in refs: try: result = fetch_one( ref, approval, snapshot_path=snapshot_path, allow_patterns=allow, token=_token(), ) except ResourceError as exc: # ResourceError messages must never carry the token; verify defensively. failures += 1 logger.error("fetch %s failed: %s", ref.logical_name, exc) results.append( {"status": "failed", "logical_name": ref.logical_name, "error": str(exc)} ) continue results.append(result) if result["status"] == "skipped": logger.info("skip %s: %s", ref.logical_name, result["reason"]) else: logger.info("fetched %s (%d files)", ref.logical_name, result["row"]["file_count"]) print(json.dumps({"results": results, "failures": failures}, sort_keys=True)) return 1 if failures else 0 def cmd_verify(args: argparse.Namespace) -> int: try: resources = load_resources(args.resources) except (ConfigError, FileNotFoundError) as exc: print(f"RESOURCE VERIFY FAILED: {exc}", file=sys.stderr) return 1 refs = plan(resources) if args.name: wanted = set(args.name) refs = [r for r in refs if r.logical_name in wanted] missing = wanted - {r.logical_name for r in refs} if missing: print( f"RESOURCE VERIFY FAILED: unknown resource(s): {sorted(missing)}", file=sys.stderr ) return 1 snapshot_path = _snapshot_path(args) results = [] failures = 0 for ref in refs: try: result = verify_one(ref, snapshot_path) except ResourceError as exc: failures += 1 result = {"logical_name": ref.logical_name, "ok": False, "error": str(exc)} results.append(result) print(json.dumps({"results": results, "failures": failures}, sort_keys=True)) return 1 if failures else 0 def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(prog="explicit-resource") parser.add_argument("--version", action="version", version=f"explicit-resource {__version__}") sub = parser.add_subparsers(dest="command", required=True) p_list = sub.add_parser("list", help="List pinned resources and their gate status.") _add_config(p_list) p_list.add_argument("--approval", type=Path, default=None, help="resource_approval.json path.") p_list.set_defaults(func=cmd_list) p_fetch = sub.add_parser("fetch", help="Download resources at pinned revisions.") _add_config(p_fetch) p_fetch.add_argument("--approval", type=Path, default=None) p_fetch.add_argument("--name", action="append", help="resource logical name (repeatable).") p_fetch.add_argument( "--include", action="append", help="glob allow-pattern forwarded to the downloader (repeatable, small-fetch fixture).", ) p_fetch.add_argument( "--snapshot", type=Path, default=repo_root() / "resource_snapshot.jsonl", help="resource_snapshot.jsonl path to append rows to.", ) p_fetch.set_defaults(func=cmd_fetch) p_verify = sub.add_parser( "verify", help="Offline-verify a fetched resource vs its snapshot row." ) _add_config(p_verify) p_verify.add_argument("--name", action="append", help="resource logical name (repeatable).") p_verify.add_argument( "--snapshot", type=Path, default=repo_root() / "resource_snapshot.jsonl", help="resource_snapshot.jsonl path to verify against.", ) p_verify.set_defaults(func=cmd_verify) return parser def main(argv: list[str] | None = None) -> int: parser = build_parser() args = parser.parse_args(argv) return int(args.func(args)) if __name__ == "__main__": raise SystemExit(main())