| """Offline JSON runner for the v2 runtime; no network service or real Host writes. |
| |
| The demo catalog ranks by category, typed capabilities and target-size distance. |
| Nuanced natural-language retrieval needs an external semantic Resolver adapter. |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
| import sys |
|
|
| from .runtime import Asset, AtomicMemoryHost, BoundedTranslationRepair, CatalogResolver, RuntimeBudget, SupportSurface, run_pipeline |
|
|
|
|
| def asset_from_dict(value): |
| allowed = {"ref", "category", "description", "actual_size_local_m", "canonical_transform", |
| "semantic_front_local", "capabilities", "support_surfaces", "provenance"} |
| if not isinstance(value, dict) or set(value) - allowed: |
| raise ValueError("invalid catalog asset fields") |
| required = {"ref", "category", "actual_size_local_m"} |
| if not required.issubset(value): |
| raise ValueError("asset needs ref, category and actual_size_local_m") |
| surfaces = tuple(SupportSurface(**surface) for surface in value.get("support_surfaces", ())) |
| return Asset(**{**value, "support_surfaces": surfaces}) |
|
|
|
|
| def load_catalog(path): |
| value = _read(path) |
| if isinstance(value, dict): |
| if set(value) != {"assets"}: |
| raise ValueError("catalog object must contain only assets") |
| value = value["assets"] |
| if not isinstance(value, list): |
| raise ValueError("catalog must be an asset array or {assets: array}") |
| return CatalogResolver(tuple(asset_from_dict(asset) for asset in value)) |
|
|
|
|
| def _read(path): |
| def reject_constant(value): |
| raise ValueError(f"nonfinite JSON constant {value}") |
| with Path(path).open() as handle: |
| return json.load(handle, parse_constant=reject_constant) |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--condition", required=True, type=Path) |
| parser.add_argument("--prediction", required=True, type=Path) |
| parser.add_argument("--catalog", required=True, type=Path) |
| parser.add_argument("--output", type=Path, help="New repository/output JSON path; defaults to stdout") |
| parser.add_argument("--max-asset-retries", type=int, default=2) |
| parser.add_argument("--max-repair-calls", type=int, default=0) |
| parser.add_argument("--repair-step-m", type=float, default=.25) |
| parser.add_argument("--max-seconds", type=float, default=10.) |
| parser.add_argument("--required-levels", nargs="+", choices=("bbox", "mesh", "physics", "solver"), default=["bbox"]) |
| parser.add_argument("--commit-in-memory", action="store_true", help="Exercise only the offline atomic Host contract") |
| parser.add_argument("--idempotency-key", default="offline-request") |
| args = parser.parse_args(argv) |
| try: |
| if args.output is not None: |
| forbidden = Path("/Volumes/harddisk/3D_Room_Collections").resolve() |
| if args.output.resolve().is_relative_to(forbidden): |
| raise ValueError("source datasets are read-only; choose a new output path") |
| if args.output.exists(): |
| raise ValueError("output already exists; choose a new path") |
| host = AtomicMemoryHost() if args.commit_in_memory else None |
| report = run_pipeline(_read(args.condition), _read(args.prediction), load_catalog(args.catalog), |
| host=host, budget=RuntimeBudget(args.max_asset_retries, args.max_repair_calls, args.max_seconds), |
| repair=BoundedTranslationRepair(args.repair_step_m) if args.max_repair_calls else None, |
| required_levels=tuple(args.required_levels), idempotency_key=args.idempotency_key, |
| expected_world_version=0 if host else None) |
| if host: |
| report = {**report, "offline_host_snapshot": host.snapshot()} |
| output = json.dumps(report, indent=2, allow_nan=False) + "\n" |
| if args.output: |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| with args.output.open("x") as handle: |
| handle.write(output) |
| else: |
| sys.stdout.write(output) |
| return 0 if report["ok"] else 2 |
| except (ValueError, TypeError, KeyError, OSError) as exc: |
| sys.stderr.write(json.dumps({"error": "invalid_runtime_request", "message": str(exc)}) + "\n") |
| return 2 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
