| |
| """Verify the publishable DEV15 runtime closure without Blender source archives.""" |
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| from pathlib import Path |
|
|
| import mujoco |
|
|
|
|
| SUITE = Path(__file__).resolve().parent |
| ROOT = SUITE.parents[1] |
|
|
|
|
| def load_json(path: Path) -> dict: |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def digest(path: Path) -> str: |
| value = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| value.update(chunk) |
| return value.hexdigest() |
|
|
|
|
| def iter_refs(value): |
| if isinstance(value, dict): |
| if {"path", "sha256", "bytes"} <= value.keys(): |
| yield value |
| for child in value.values(): |
| yield from iter_refs(child) |
| elif isinstance(value, list): |
| for child in value: |
| yield from iter_refs(child) |
|
|
|
|
| def verify_ref(ref: dict, errors: list[str]) -> None: |
| relative = Path(ref["path"]) |
| if relative.is_absolute() or ".." in relative.parts: |
| errors.append(f"invalid path: {relative}") |
| return |
| path = ROOT / relative |
| if not path.is_file(): |
| errors.append(f"missing: {relative}") |
| elif path.stat().st_size != ref["bytes"] or digest(path) != ref["sha256"]: |
| errors.append(f"hash/size mismatch: {relative}") |
|
|
|
|
| def verify_suite_path(ref: dict, errors: list[str]) -> None: |
| relative = Path(ref["path"]) |
| if relative.is_absolute() or ".." in relative.parts: |
| errors.append(f"invalid suite path: {relative}") |
| return |
| path = SUITE / relative |
| if not path.is_file(): |
| errors.append(f"missing: {path.relative_to(ROOT)}") |
| elif digest(path) != ref["sha256"]: |
| errors.append(f"hash mismatch: {path.relative_to(ROOT)}") |
|
|
|
|
| def main() -> int: |
| registry = load_json(SUITE / "config/suite.json") |
| lock = load_json(SUITE / "config/freeze_lock.json") |
| errors: list[str] = [] |
| refs = {ref["path"]: ref for ref in iter_refs(registry)} |
| if lock["suite_id"] != registry["suite_id"]: |
| errors.append("freeze lock suite ID differs from registry") |
| for ref in lock["files"]: |
| refs[ref["path"]] = ref |
| omitted_sources: set[str] = set() |
| cases = registry["cases"] |
| if len(cases) != 15: |
| errors.append(f"expected 15 cases, found {len(cases)}") |
| for case in cases: |
| spec_path = ROOT / case["case_spec"]["path"] |
| if not spec_path.is_file(): |
| continue |
| spec = load_json(spec_path) |
| for ref in iter_refs(spec): |
| if ref["path"].endswith(".blend") and ref == spec.get("source"): |
| omitted_sources.add(ref["path"]) |
| else: |
| refs[ref["path"]] = ref |
| dependency_path = ROOT / spec["artifacts"]["dependency_manifest"]["path"] |
| if dependency_path.is_file(): |
| for ref in iter_refs(load_json(dependency_path)): |
| refs[ref["path"]] = ref |
| verify_suite_path(spec["probe"], errors) |
| verify_suite_path(spec["validator"], errors) |
| for support in spec["probe"].get("support_modules", []): |
| verify_suite_path(support, errors) |
| for support in spec["validator"].get("support_modules", []): |
| verify_suite_path(support, errors) |
|
|
| for ref in refs.values(): |
| verify_ref(ref, errors) |
|
|
| if not errors: |
| for case in cases: |
| spec = load_json(ROOT / case["case_spec"]["path"]) |
| for label in ("m1_base", "runtime_model"): |
| path = ROOT / spec["artifacts"][label]["path"] |
| try: |
| mujoco.MjModel.from_xml_path(str(path)) |
| except Exception as exc: |
| errors.append(f"{case['case_id']} {label} MuJoCo load: {exc}") |
|
|
| print(json.dumps({ |
| "passed": not errors, |
| "case_count": len(cases), |
| "verified_files": len(refs), |
| "omitted_authoring_blends": len(omitted_sources), |
| "errors": errors, |
| }, indent=2)) |
| return 0 if not errors else 1 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
