| """``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: |
| |
| 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()) |
|
|
