assests / common /source /starBenchserver /benchmarks /simBenchmarks /DOMINO /environment /deployment.py
| """File-only preparation of a new owned DOMINO deployment; never starts a SIM. | |
| Inputs are operator-supplied, existing source/assets. Runtime capture records | |
| the selected compatibility environment, not native Torch2.4.1 parity. No pip, | |
| installer, global configuration, expert or model invocation is performed. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import importlib.metadata | |
| import json | |
| from pathlib import Path | |
| import shutil | |
| import subprocess | |
| import sys | |
| from benchmarks.simBenchmarks.DOMINO.bench_server.protocol import ( | |
| NATIVE_REVISION, CUROBO_REVISION, RUNTIME_VERSIONS, | |
| ) | |
| def digest(path: Path) -> str: | |
| value = hashlib.sha256() | |
| with path.open("rb") as stream: | |
| for block in iter(lambda: stream.read(1024 * 1024), b""): | |
| value.update(block) | |
| return value.hexdigest() | |
| def inventory(root: Path) -> list[dict]: | |
| rows = [] | |
| for path in sorted(root.rglob("*")): | |
| if path.is_symlink(): | |
| raise ValueError(f"deployment source must not contain symlinks: {path}") | |
| if path.is_file(): | |
| rows.append({"path": path.relative_to(root).as_posix(), | |
| "size_bytes": path.stat().st_size, "sha256": digest(path)}) | |
| return rows | |
| def verify_rows(root: Path, rows: list[dict], *, exact: bool = True) -> None: | |
| names = [] | |
| for row in rows: | |
| relative = Path(row["path"]) | |
| if relative.is_absolute() or ".." in relative.parts or not relative.parts: | |
| raise ValueError("unsafe inventory path") | |
| path = root / relative | |
| if (any(parent.is_symlink() for parent in (path, *path.parents) if parent != root.parent) | |
| or not path.resolve().is_relative_to(root.resolve()) | |
| or not path.is_file() or path.stat().st_size != row["size_bytes"] | |
| or digest(path) != row["sha256"]): | |
| raise ValueError(f"content identity differs: {relative}") | |
| names.append(relative.as_posix()) | |
| if len(names) != len(set(names)): | |
| raise ValueError("duplicate inventory path") | |
| if exact: | |
| actual = [row["path"] for row in inventory(root)] | |
| if sorted(names) != sorted(actual): | |
| raise ValueError("unrecorded or missing deployment files") | |
| def verify_git_files(source: Path, git_reference: Path, revision: str, prefixes: tuple[str, ...]) -> dict: | |
| """Compare bytes to public Git blob identities, including archived sources.""" | |
| result = subprocess.run(["git", "-c", "safe.directory=" + str(git_reference), | |
| "-C", str(git_reference), "ls-tree", "-rz", revision, | |
| "--", *prefixes], check=True, capture_output=True) | |
| paths = [] | |
| for item in result.stdout.split(b"\0"): | |
| if not item: | |
| continue | |
| metadata, filename = item.split(b"\t", 1) | |
| mode, kind, expected = metadata.decode().split() | |
| name = filename.decode() | |
| if kind != "blob" or mode not in ("100644", "100755"): | |
| raise ValueError("unsupported upstream source entry") | |
| path = source / name | |
| if not path.is_file() or path.is_symlink(): | |
| raise ValueError(f"missing upstream file: {name}") | |
| data = path.read_bytes() | |
| actual = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() | |
| if actual != expected: | |
| raise ValueError(f"upstream source differs: {name}") | |
| paths.append(name) | |
| if not paths: | |
| raise ValueError("empty upstream source identity") | |
| return {"revision": revision, "git_blob_files_verified": len(paths), "verified_paths": paths} | |
| def capture_runtime() -> dict: | |
| versions = {} | |
| packages = {} | |
| for name, expected in RUNTIME_VERSIONS.items(): | |
| distribution = importlib.metadata.distribution(name) | |
| if distribution.version != expected: | |
| raise ValueError(f"{name} differs from declared SM120 compatibility runtime") | |
| versions[name] = distribution.version | |
| if name in ("sapien", "mplib", "toppra"): | |
| root = Path(distribution.locate_file(name)).resolve() | |
| packages[name] = {"root": str(root), "files": inventory(root)} | |
| return {"python": sys.version.split()[0], "versions": versions, "packages": packages, | |
| "scope": "listed versions and SAPIEN/MPLib/TOPPRA files, not all dependencies or loaded-memory attestation"} | |
| def expand_asset_root_template(template: str, deployment_root: Path) -> str: | |
| """Match native script/update_embodiment_config_path.py, not shell expansion. | |
| Despite its name, ASSETS_PATH is the repository root; the pinned templates | |
| themselves append /assets. Replace the whole placeholder, braces included. | |
| """ | |
| if not deployment_root.is_absolute(): | |
| raise ValueError("asset template requires an absolute deployment root") | |
| if "${ASSETS_PATH}" not in template and "$ASSETS_PATH" not in template: | |
| raise ValueError("native CuRobo asset-root placeholder missing") | |
| return template.replace("${ASSETS_PATH}", str(deployment_root)).replace( | |
| "$ASSETS_PATH", str(deployment_root)) | |
| def verify_curobo_asset_paths(root: Path, config: dict) -> dict: | |
| """Reject malformed/out-of-tree/missing materialized native config inputs.""" | |
| kinematics = config["robot_cfg"]["kinematics"] | |
| verified = {} | |
| for key in ("urdf_path", "collision_spheres"): | |
| value = kinematics[key] | |
| if not isinstance(value, str) or "$" in value: | |
| raise ValueError(f"unexpanded CuRobo asset path: {key}") | |
| path = Path(value) | |
| if (not path.is_absolute() or ".." in path.parts or not path.is_file() | |
| or not path.resolve().is_relative_to((root / "assets").resolve())): | |
| raise ValueError(f"missing or out-of-deployment CuRobo asset: {key}") | |
| verified[key] = str(path) | |
| return verified | |
| def prepare(source: Path, source_git: Path, assets: Path, curobo: Path, | |
| curobo_git: Path, destination: Path) -> dict: | |
| for path in (source, source_git, assets, curobo, curobo_git, destination): | |
| if not path.is_absolute(): | |
| raise ValueError("all deployment inputs must be absolute paths") | |
| if destination.exists(): | |
| raise ValueError("destination must be new; deployments are never merged or overwritten") | |
| source_identity = verify_git_files(source, source_git, NATIVE_REVISION, | |
| ("envs", "script", "task_config", "description", "LICENSE")) | |
| curobo_identity = verify_git_files(curobo, curobo_git, CUROBO_REVISION, | |
| ("src", "setup.py", "pyproject.toml", "setup.cfg", "LICENSE")) | |
| runtime = capture_runtime() | |
| destination.mkdir(parents=True, exist_ok=False) | |
| # Copy only verified Git entries, never arbitrary untracked source or .so. | |
| for name in source_identity["verified_paths"]: | |
| target = destination / name | |
| target.parent.mkdir(parents=True, exist_ok=True) | |
| shutil.copy2(source / name, target) | |
| for name in ("embodiments/aloha-agilex", "objects/050_bell", "objects/objaverse"): | |
| inventory(assets / name) # Reject links before copytree could follow one. | |
| shutil.copytree(assets / name, destination / "assets" / name) | |
| if (assets / "objects/same.json").is_file(): | |
| shutil.copy2(assets / "objects/same.json", destination / "assets/objects/same.json") | |
| for name in curobo_identity["verified_paths"]: | |
| target = destination / "envs/curobo" / name | |
| target.parent.mkdir(parents=True, exist_ok=True) | |
| shutil.copy2(curobo / name, target) | |
| derived = [] | |
| import yaml | |
| for side in ("left", "right"): | |
| name = f"assets/embodiments/aloha-agilex/curobo_{side}.yml" | |
| template = destination / f"assets/embodiments/aloha-agilex/curobo_{side}_tmp.yml" | |
| original = template.read_text() | |
| path = destination / name | |
| path.write_text(expand_asset_root_template(original, destination)) | |
| asset_paths = verify_curobo_asset_paths(destination, yaml.safe_load(path.read_text())) | |
| derived.append({"path": name, "template_sha256": digest(template), "sha256": digest(path), | |
| "transform": "native ${ASSETS_PATH}/$ASSETS_PATH expansion to deployment repository root only", | |
| "verified_asset_paths": asset_paths}) | |
| manifest = {"schema": "domino.owned-deployment/v1", "native_source": source_identity, | |
| "curobo_source": curobo_identity, "runtime": runtime, "derived_files": derived, | |
| "files": inventory(destination), "asset_scope": "aloha-agilex plus click_bell0/1; no full-suite asset claim"} | |
| (destination / "deployment.json").write_text(json.dumps(manifest, indent=2) + "\n") | |
| return {"root": str(destination), "deployment_manifest_sha256": digest(destination / "deployment.json"), | |
| "source": {k: v for k, v in source_identity.items() if k != "verified_paths"}, | |
| "curobo": {k: v for k, v in curobo_identity.items() if k != "verified_paths"}, "native_resets": 0} | |
| def main(argv=None): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| for name in ("source", "source-git", "assets", "curobo", "curobo-git", "destination"): | |
| parser.add_argument("--" + name, type=Path, required=True) | |
| args = parser.parse_args(argv) | |
| print(json.dumps(prepare(**vars(args)), indent=2)) | |
| return 0 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |