assests / common /source /starBenchserver /benchmarks /simBenchmarks /VLA-Arena /environment /runtime.py
| """Read-only native source and bundled asset verification before SIM creation.""" | |
| from __future__ import annotations | |
| import hashlib | |
| import importlib | |
| import importlib.metadata | |
| import json | |
| import os | |
| from pathlib import Path | |
| import subprocess | |
| import sys | |
| from benchkit.errors import CompatibilityError | |
| REVISION = "babe582ebffc82b979b77964a7e56417d02f63a4" | |
| NATIVE_INVENTORY = "32f0caf4a8efcf7179bdb8075b05bb9fa02d22bac526fb33ceb3ae21c25d65c7" | |
| ROBOSUITE_INVENTORY = "29971f30ce2d9999caa0527bf6fac42cf1e60ef498d8e3bffa2e84f679020222" | |
| VERSIONS = {"robosuite": "1.5.1", "mujoco": "3.3.0", "numpy": "1.26.4", | |
| "bddl": "1.0.1", "torch": "2.5.1+cpu", "gym": "0.26.2", "future": "1.0.0"} | |
| _PROCESS_NUMBA_CACHE: Path | None = None | |
| def file_sha256(path: Path) -> str: | |
| h = hashlib.sha256() | |
| with path.open("rb") as stream: | |
| for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): | |
| h.update(chunk) | |
| return h.hexdigest() | |
| def inventory(root: Path, paths, *, installed_bytecode: bool = False) -> dict: | |
| root = root.resolve(strict=True) | |
| rows = [] | |
| for path in sorted(paths): | |
| if path.is_symlink(): | |
| raise CompatibilityError("native source/assets must not contain symlinks") | |
| if "__pycache__" in path.parts or path.suffix in (".pyc", ".pyo"): | |
| # Only wheel-install caches beside a real source file may be | |
| # excluded. Native checkouts must be clean and run with -B. | |
| source = path.parent.parent / (path.name.split(".")[0] + ".py") | |
| if (installed_bytecode and path.parent.name == "__pycache__" and path.is_file() | |
| and path.name.endswith(".cpython-311.pyc") and source.is_file()): | |
| continue | |
| if installed_bytecode and path.name == "__pycache__" and path.is_dir(): | |
| continue | |
| raise CompatibilityError("unexpected executable bytecode in native source/package") | |
| if not path.is_file(): | |
| continue | |
| path = path.resolve(strict=True) | |
| if not path.is_relative_to(root): | |
| raise CompatibilityError("native source inventory escaped its root") | |
| rows.append({"path": path.relative_to(root).as_posix(), "size_bytes": path.stat().st_size, | |
| "sha256": file_sha256(path)}) | |
| rows.sort(key=lambda row: row["path"]) | |
| return {"files": len(rows), "bytes": sum(r["size_bytes"] for r in rows), | |
| "inventory_sha256": hashlib.sha256(json.dumps(rows, sort_keys=True, separators=(",", ":")).encode()).hexdigest()} | |
| def verify_native_source(root: Path) -> dict: | |
| root = root.resolve(strict=True) | |
| try: | |
| def git(*args): | |
| return subprocess.check_output(["git", "-C", str(root), *args], text=True, | |
| timeout=30, env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"}).strip() | |
| if Path(git("rev-parse", "--show-toplevel")).resolve() != root or git("rev-parse", "HEAD") != REVISION: | |
| raise CompatibilityError("VLA-Arena needs its own pinned native Git checkout") | |
| if git("status", "--porcelain", "--untracked-files=all", "--ignored=matching"): | |
| raise CompatibilityError("native VLA-Arena checkout has modified, untracked or ignored files") | |
| except (OSError, subprocess.SubprocessError) as exc: | |
| raise CompatibilityError("cannot verify native VLA-Arena Git identity") from exc | |
| paths = list((root / "vla_arena").rglob("*")) + [root / "pyproject.toml"] | |
| actual = inventory(root, paths) | |
| pin = json.loads(Path(__file__).with_name("native_source_pin.json").read_text()) | |
| if (pin.get("upstream_revision") != REVISION or pin.get("inventory_sha256") != NATIVE_INVENTORY | |
| or any(actual[key] != pin.get(key) for key in actual)): | |
| raise CompatibilityError("native VLA-Arena code/task/asset inventory differs") | |
| return {**actual, "revision": REVISION, "groups": pin["groups"], "root": str(root)} | |
| def verify_numba_cache(native_root: Path, robosuite_root: Path) -> Path: | |
| """Require a fresh caller-owned cache, outside both pinned code trees.""" | |
| global _PROCESS_NUMBA_CACHE | |
| setting = os.environ.get("NUMBA_CACHE_DIR", "") | |
| path = Path(setting) | |
| if not setting or not path.is_absolute() or path.is_symlink() or not path.is_dir(): | |
| raise CompatibilityError("set NUMBA_CACHE_DIR to a new existing private absolute directory") | |
| path = path.resolve(strict=True) | |
| if any(path.is_relative_to(root.resolve()) for root in (native_root, robosuite_root)): | |
| raise CompatibilityError("Numba cache must be outside pinned native/Robosuite trees") | |
| if _PROCESS_NUMBA_CACHE is None: | |
| if any(path.iterdir()): | |
| raise CompatibilityError("Numba cache must start empty for each fresh server process") | |
| _PROCESS_NUMBA_CACHE = path | |
| elif path != _PROCESS_NUMBA_CACHE: | |
| raise CompatibilityError("cannot switch Numba caches within one server process") | |
| return path | |
| def prepare_runtime(root: Path) -> dict: | |
| """Imports selected native modules only after checking code and assets; no SIM.""" | |
| if not sys.dont_write_bytecode: | |
| raise CompatibilityError("launch the VLA-Arena server with python -B to preserve its clean native tree") | |
| source = verify_native_source(root) | |
| if sys.version_info[:2] != (3, 11): | |
| raise CompatibilityError("the VLA-Arena runtime is pinned to Python 3.11") | |
| for name, version in VERSIONS.items(): | |
| try: | |
| actual = importlib.metadata.version(name) | |
| except importlib.metadata.PackageNotFoundError as exc: | |
| raise CompatibilityError(f"missing VLA-Arena native dependency {name}") from exc | |
| if actual != version: | |
| raise CompatibilityError(f"VLA-Arena requires {name}=={version}, found {actual}") | |
| rs = Path(importlib.metadata.distribution("robosuite").locate_file("robosuite")).resolve(strict=True) | |
| package = inventory(rs.parent, rs.rglob("*"), installed_bytecode=True) | |
| if package["inventory_sha256"] != ROBOSUITE_INVENTORY: | |
| raise CompatibilityError("Robosuite native code/assets differ from the pinned public wheel") | |
| cache = verify_numba_cache(root, rs) | |
| config = os.environ.get("LIBERO_CONFIG_PATH") | |
| if not config or not (Path(config) / "config.yaml").is_file(): | |
| raise CompatibilityError("set LIBERO_CONFIG_PATH to a pre-created isolated native utility config") | |
| root = root.resolve(strict=True) | |
| resource = root / "vla_arena/vla_arena" | |
| expected_config = {"benchmark_root": str(resource), "bddl_files": str(resource / "bddl_files"), | |
| "init_states": str(resource / "init_files"), "datasets": str(resource.parent / "datasets")} | |
| try: | |
| if json.loads((Path(config) / "config.yaml").read_text()) != expected_config: | |
| raise ValueError("different resource paths") | |
| except (OSError, ValueError) as exc: | |
| raise CompatibilityError("use the unchanged isolated JSON/YAML config produced by environment.configure") from exc | |
| # The native utils package otherwise writes ~/.libero at import time. | |
| if "vla_arena" in sys.modules: | |
| if Path(sys.modules["vla_arena"].__file__).resolve() != root / "vla_arena/__init__.py": | |
| raise CompatibilityError("another VLA-Arena package is already loaded") | |
| if str(root) not in sys.path: | |
| sys.path.insert(0, str(root)) | |
| native = importlib.import_module("vla_arena.vla_arena") | |
| if Path(native.__file__).resolve() != root / "vla_arena/vla_arena/__init__.py": | |
| raise CompatibilityError("VLA-Arena import was shadowed") | |
| for field, relative in (("bddl_files", "bddl_files"), ("init_states", "init_files"), ("assets", "assets")): | |
| if Path(native.get_vla_arena_path(field)).resolve() != root / "vla_arena/vla_arena" / relative: | |
| raise CompatibilityError("native VLA-Arena resource path differs") | |
| robosuite = importlib.import_module("robosuite") | |
| if Path(robosuite.__file__).resolve() != rs / "__init__.py": | |
| raise CompatibilityError("Robosuite import was shadowed") | |
| numba_config = importlib.import_module("numba.core.config") | |
| if numba_config.CACHE_DIR != str(cache): | |
| raise CompatibilityError("Numba was imported with a different compiled-cache location") | |
| pin = json.loads(Path(__file__).with_name("robosuite_pin.json").read_text()) | |
| controller = robosuite.load_composite_controller_config(robot="Panda") | |
| # The native loader flattens body_parts.arms into body_parts; the pin keeps | |
| # the original public JSON bytes instead of pretending they are identical. | |
| expected = {"type": pin["panda_controller"]["type"], | |
| "body_parts": pin["panda_controller"]["body_parts"]["arms"]} | |
| if controller != expected: | |
| raise CompatibilityError("native Panda composite controller configuration differs") | |
| checked_modules = ("vla_arena.vla_arena.benchmark", "vla_arena.vla_arena.envs", | |
| "vla_arena.vla_arena.utils.eval_cost", "vla_arena.vla_arena.utils.eval_init_state") | |
| for name in checked_modules: | |
| importlib.import_module(name) # Registers native classes; does not instantiate a SIM. | |
| for name, module in tuple(sys.modules.items()): | |
| if name == "vla_arena" or name.startswith("vla_arena."): | |
| origin = getattr(module, "__file__", None) | |
| if origin and not Path(origin).resolve().is_relative_to(root / "vla_arena"): | |
| raise CompatibilityError("a loaded VLA-Arena module escaped the pinned package") | |
| return {"native": source, "robosuite": {**package, "root": str(rs), | |
| "excluded_bytecode": "standard CPython 3.11 installation caches adjacent to source"}, "versions": dict(VERSIONS), | |
| "controller_config": controller, "imported_native_apis": list(checked_modules), | |
| "numba_cache": {"root": str(cache), "initially_empty": True, "scope": "process-owned generated cache; not a source pin"}, | |
| "source_memory_attestation": False} | |
| if __name__ == "__main__": | |
| import argparse | |
| parser = argparse.ArgumentParser(description="Read-only native source/runtime check; creates no SIM") | |
| parser.add_argument("--native-root", required=True, type=Path) | |
| args = parser.parse_args() | |
| print(json.dumps(prepare_runtime(args.native_root), indent=2, sort_keys=True)) | |