assests / common /source /starBenchserver /benchmarks /simBenchmarks /Behavior /environment /deployment.py
| """File/metadata-only readiness capture; never imports or initializes the SIM. | |
| Asset receipts establish archive/extraction provenance, not full live-asset | |
| attestation. Selected task/robot files are independently rehashed at reset. | |
| """ | |
| import argparse | |
| import hashlib | |
| import importlib.metadata | |
| import importlib.util | |
| import json | |
| import os | |
| from pathlib import Path | |
| import subprocess | |
| import sys | |
| from benchmarks.simBenchmarks.Behavior.bench_server.protocol import ( | |
| ARCHIVE_DEPLOYMENT, LIVE_DEPLOYMENT, REVISION, TASK_METADATA_SHA256, | |
| ) | |
| ARCHIVES = { | |
| "behavior-1k-assets": "09e9fce600f841dc611aa96c0b1b9f9074f56f0e67898b37b39bd00c38a0095e", | |
| "omnigibson-robot-assets": "3d813b2181e0581cf2300a40892de70f8475fe59346ceeea4fb9bf7ff21ce126", | |
| "2026-challenge-task-instances": "d4ac3d72dd585178e85d542f28d1b48233b886c80e196e2f9d3aa5993ba21f81", | |
| } | |
| ASSET_FILES = { | |
| "2026-challenge-task-instances/metadata/task.jsonl": TASK_METADATA_SHA256, | |
| "omnigibson-robot-assets/models/r1pro/r1pro.yaml": "63f841cffd5c499102416a797a22fa5b4cbaf146539df7dde8a4a1053e2326f1", | |
| "omnigibson-robot-assets/models/r1pro/urdf/r1pro.urdf": "b0d76760cbedfbcbe1ddc280380dd5f497bbca380313bc096d7239a2c50dae61", | |
| "2026-challenge-task-instances/scene_test/public/house_double_floor_lower/json/house_double_floor_lower_task_turning_on_radio_instances/house_double_floor_lower_task_turning_on_radio_0_301_template-tro_state.json": "30a0fe101da1cbf6eb3683d3f9da716399ccd7409974b459dc12a580d2c8ad13", | |
| } | |
| PACKAGES = ("omnigibson", "bddl", "joylo", "torch", "numpy", "isaacsim", "omegaconf", "hydra-core", "imageio", "imageio-ffmpeg") | |
| def digest(path): | |
| result = hashlib.sha256() | |
| with Path(path).open("rb") as stream: | |
| for block in iter(lambda: stream.read(1024 * 1024), b""): | |
| result.update(block) | |
| return result.hexdigest() | |
| def absolute(value): | |
| path = Path(value) | |
| if not path.is_absolute() or ".." in path.parts: | |
| raise ValueError("explicit absolute deployment paths required") | |
| return path | |
| def source_identity(source): | |
| source = absolute(source) | |
| def git(*args): | |
| return subprocess.run(["git", "-c", "safe.directory=" + str(source), "-C", str(source), *args], | |
| check=True, capture_output=True).stdout | |
| if git("rev-parse", "HEAD").decode().strip() != REVISION: | |
| raise ValueError("BEHAVIOR source revision differs") | |
| rows = [] | |
| roots = ("OmniGibson/omnigibson", "bddl3/bddl", "joylo/gello") | |
| for entry in git("ls-tree", "-rz", REVISION, "--", *roots).split(b"\0"): | |
| if not entry: | |
| continue | |
| meta, name = entry.split(b"\t", 1) | |
| mode, kind, expected = meta.decode().split() | |
| relative = name.decode() | |
| path = source / relative | |
| if kind != "blob" or mode not in ("100644", "100755") or path.is_symlink() or not path.is_file(): | |
| raise ValueError("unsupported or missing native source file") | |
| data = path.read_bytes() | |
| if hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() != expected: | |
| raise ValueError("modified native source: " + relative) | |
| rows.append(relative) | |
| if not rows: | |
| raise ValueError("empty native source inventory") | |
| # -B only disables writes: stale or untracked bytecode may still be loaded. | |
| known = set(rows) | |
| for root in roots: | |
| for path in (source / root).rglob("*"): | |
| if path.is_symlink(): | |
| raise ValueError("native source symlink is not part of this deployment") | |
| if path.is_file() and path.suffix in (".py", ".pyc", ".pyo", ".so", ".yaml", ".json") and path.relative_to(source).as_posix() not in known: | |
| raise ValueError("untracked executable/config native source: " + str(path)) | |
| return {"revision": REVISION, "tracked_files_verified": len(rows), "roots": list(roots)} | |
| def runtime_identity(source): | |
| source = absolute(source) | |
| origins = {} | |
| for name, relative in {"omnigibson": "OmniGibson/omnigibson/__init__.py", "bddl": "bddl3/bddl/__init__.py", "gello": "joylo/gello/__init__.py"}.items(): | |
| spec = importlib.util.find_spec(name) # top-level only: does not execute package | |
| if spec is None or spec.origin is None or Path(spec.origin).resolve() != (source / relative).resolve(): | |
| raise ValueError("native module origin differs: " + name) | |
| origins[name] = str(Path(spec.origin).resolve()) | |
| versions = {name: importlib.metadata.version(name) for name in PACKAGES} | |
| if not versions["isaacsim"].startswith("5.1.") or sys.version_info[:2] != (3, 11): | |
| raise ValueError("native runtime requires Python3.11 and Isaac Sim5.1") | |
| if not Path(sys.executable).is_file() or not Path(sys.base_prefix).is_dir(): | |
| raise ValueError("runtime base or interpreter unavailable on current node") | |
| return {"python": sys.version.split()[0], "executable": str(Path(sys.executable).absolute()), | |
| "executable_sha256": digest(sys.executable), "base_prefix": sys.base_prefix, | |
| "versions": versions, "origins": origins} | |
| def asset_identity(data_root, receipts): | |
| root = absolute(data_root) | |
| if set(receipts) != set(ARCHIVES): | |
| raise ValueError("all three archive extraction receipts required") | |
| result = {} | |
| for name, expected in ARCHIVES.items(): | |
| path = absolute(receipts[name]) | |
| receipt = json.loads(path.read_text()) | |
| if (receipt.get("archive_sha256") != expected or receipt.get("source_commit") != REVISION | |
| or Path(receipt.get("target", "")).resolve() != (root / name).resolve() | |
| or not (root / name).is_dir()): | |
| raise ValueError("asset extraction receipt differs: " + name) | |
| result[name] = {"path": str(path), "sha256": digest(path)} | |
| for name, expected in ASSET_FILES.items(): | |
| if digest(root / name) != expected: | |
| raise ValueError("selected native asset differs: " + name) | |
| return result | |
| def live_asset_identity(data_root): | |
| """Verify selected current bytes, without asserting archive/download origin.""" | |
| root = absolute(data_root).resolve(strict=True) | |
| for name in ARCHIVES: | |
| directory = root / name | |
| if directory.is_symlink() or not directory.is_dir(): | |
| raise ValueError("missing real native asset directory: " + name) | |
| files = {} | |
| for name, expected in ASSET_FILES.items(): | |
| path = root / name | |
| if (path.is_symlink() or not path.is_file() | |
| or not path.resolve(strict=True).is_relative_to(root) | |
| or digest(path) != expected): | |
| raise ValueError("selected live native asset differs: " + name) | |
| files[name] = {"sha256": expected, "size_bytes": path.stat().st_size} | |
| return {"selected_files": files, "archive_origin_verified": False, | |
| "complete_asset_inventory_verified": False} | |
| def verify_track(recorded, deployment_track): | |
| """Bind the public deployment choice before creating a native worker.""" | |
| if deployment_track == ARCHIVE_DEPLOYMENT: | |
| if recorded.get("schema") != "behavior2026-deployment/v1" or "deployment_track" in recorded: | |
| raise ValueError("archive deployment manifest/track differs") | |
| elif deployment_track == LIVE_DEPLOYMENT: | |
| if (recorded.get("schema") != "behavior2026-live-deployment/v1" | |
| or recorded.get("deployment_track") != LIVE_DEPLOYMENT): | |
| raise ValueError("live deployment manifest/track differs") | |
| else: | |
| raise ValueError("unknown BEHAVIOR deployment track") | |
| def capture(source_root, data_root, receipts=None, *, deployment_track=ARCHIVE_DEPLOYMENT): | |
| if deployment_track not in (ARCHIVE_DEPLOYMENT, LIVE_DEPLOYMENT): | |
| raise ValueError("unknown BEHAVIOR deployment track") | |
| if deployment_track == LIVE_DEPLOYMENT and receipts is not None: | |
| raise ValueError("live deployment does not accept archive receipts") | |
| if deployment_track == ARCHIVE_DEPLOYMENT and receipts is None: | |
| raise ValueError("archive deployment requires extraction receipts") | |
| source = source_identity(source_root) | |
| runtime = runtime_identity(source_root) | |
| if deployment_track == LIVE_DEPLOYMENT: | |
| assets = live_asset_identity(data_root) | |
| return {"schema": "behavior2026-live-deployment/v1", "deployment_track": LIVE_DEPLOYMENT, | |
| "source_root": str(absolute(source_root)), "data_root": str(absolute(data_root)), | |
| "source": source, "runtime": runtime, "live_assets": assets, | |
| "selected_asset_files": ASSET_FILES, | |
| "asset_attestation_scope": "current selected task/robot bytes only; no archive origin or complete asset inventory attestation"} | |
| assets = asset_identity(data_root, receipts) | |
| return {"schema": "behavior2026-deployment/v1", "source_root": str(absolute(source_root)), | |
| "data_root": str(absolute(data_root)), "source": source, "runtime": runtime, | |
| "asset_receipts": assets, "selected_asset_files": ASSET_FILES, | |
| "asset_attestation_scope": "verified archive extraction receipts and selected files; not all live asset bytes"} | |
| def verify(path, expected_sha256, *, deployment_track=ARCHIVE_DEPLOYMENT): | |
| path = absolute(path) | |
| if digest(path) != expected_sha256: | |
| raise ValueError("deployment manifest hash differs") | |
| recorded = json.loads(path.read_text()) | |
| verify_track(recorded, deployment_track) | |
| receipts = ({name: row["path"] for name, row in recorded["asset_receipts"].items()} | |
| if deployment_track == ARCHIVE_DEPLOYMENT else None) | |
| current = capture(recorded["source_root"], recorded["data_root"], receipts, | |
| deployment_track=deployment_track) | |
| if current != recorded: | |
| raise ValueError("native deployment changed since capture") | |
| return current | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--source-root", required=True) | |
| parser.add_argument("--data-root", required=True) | |
| parser.add_argument("--deployment-track", choices=(ARCHIVE_DEPLOYMENT, LIVE_DEPLOYMENT), | |
| default=ARCHIVE_DEPLOYMENT) | |
| parser.add_argument("--receipts", help="JSON mapping asset directory name to extraction receipt path (archive track only)") | |
| parser.add_argument("--output", required=True) | |
| args = parser.parse_args() | |
| if (args.deployment_track == ARCHIVE_DEPLOYMENT) != (args.receipts is not None): | |
| parser.error("--receipts is required only for archive-receipts/v1") | |
| receipts = json.loads(Path(args.receipts).read_text()) if args.receipts else None | |
| record = capture(args.source_root, args.data_root, receipts, deployment_track=args.deployment_track) | |
| with absolute(args.output).open("x") as stream: | |
| json.dump(record, stream, indent=2, allow_nan=False) | |
| print(digest(args.output)) | |
| if __name__ == "__main__": | |
| main() | |