Blame for common/source/starBenchserver/benchmarks/simBenchmarks/calvin/environment/runtime.py

"""Lazy, private CALVIN native loader. This module itself is stdlib-only."""
from __future__ import annotations

import hashlib
import importlib
import importlib.metadata
import json
import os
from pathlib import Path
import platform
import subprocess
import sys

from benchkit.errors import CompatibilityError, ProtocolError

NATIVE_REVISION = "fa03f01f19c65920e18cf37398a9ce859274af76"
SEQUENCE_SHA256 = "3fa343cf594d530b0b127030ff1c5cbeaee36fb3aa8c9d2a4063c09047c8d508"
SNAPSHOT_SHA256 = "ef2c0cfede0419651faf75b32366755832fb549109427047523af91db5b5786c"
TASK_CONFIG = "calvin_models/conf/callbacks/rollout/tasks/new_playtable_tasks.yaml"
LANGUAGE_CONFIG = "calvin_models/conf/annotations/new_playtable_validation.yaml"


def _frozen_json(name, digest):
    directory = (Path(__file__).parents[1] / "bench_server" / "protocol"
                 if name == "frozen_sequence.json" else Path(__file__).parent)
    raw = (directory / name).read_bytes()
    if hashlib.sha256(raw).hexdigest() != digest:
        raise CompatibilityError(f"CALVIN frozen input differs: {name}")
    return json.loads(raw)


def frozen_sequence():
    return _frozen_json("frozen_sequence.json", SEQUENCE_SHA256)


def _git(root, *arguments):
    return subprocess.check_output(["git", "-C", str(root), *arguments], stderr=subprocess.PIPE)


def verify_tree(root: Path, revision: str, expected_count: int):
    if (Path(_git(root, "rev-parse", "--show-toplevel").decode().strip()).resolve() != root.resolve()
            or _git(root, "rev-parse", "HEAD").decode().strip() != revision):
        raise CompatibilityError(f"CALVIN own Git root/revision differs: {root}")
    if _git(root, "status", "--porcelain", "--untracked-files=all"):
        raise CompatibilityError(f"CALVIN native Git tree/index is not clean: {root}")
    rows = []
    for entry in _git(root, "ls-tree", "-rz", "HEAD").split(b"\0"):
        if not entry:
            continue
        header, relative = entry.split(b"\t", 1)
        mode, kind, blob = header.split()
        if kind == b"commit":
            continue  # Each pinned nested repository is checked independently.
        name = relative.decode("utf-8")
        path = root / name
        if mode not in (b"100644", b"100755") or path.is_symlink() or not path.is_file():
            raise CompatibilityError(f"CALVIN source must be an original regular file: {name}")
        data = path.read_bytes()
        actual = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest()
        if actual != blob.decode() or data.startswith(b"version https://git-lfs.github.com/spec/v1"):
            raise CompatibilityError(f"CALVIN actual source/asset bytes differ: {name}")
        rows.append({"path": name, "bytes": len(data), "sha256": hashlib.sha256(data).hexdigest()})
    if len(rows) != expected_count:
        raise CompatibilityError("CALVIN native regular-file inventory differs")
    # Ignored bytecode is harmless only because launch requires -B and the
    # loader below rejects every pre-existing .pyc in the imported package.
    return {"root": str(root), "revision": revision, "regular_files": rows}


def readiness(source_root: Path, dataset_root: Path):
    snapshot = _frozen_json("runtime_snapshot.json", SNAPSHOT_SHA256)
    if (list(sys.version_info[:2]) != snapshot["python"] or platform.system() != "Linux"
            or platform.machine() != "x86_64" or not sys.dont_write_bytecode):
        raise CompatibilityError("CALVIN debug runtime requires Linux x86_64 Python 3.10 launched with -B")
    sources = [verify_tree(source_root / relative, revision,
                           snapshot["native_regular_file_counts"][relative])
               for relative, revision in snapshot["native_revisions"].items()]
    for relative, digest in snapshot["native_files"].items():
        if hashlib.sha256((source_root / relative).read_bytes()).hexdigest() != digest:
            raise CompatibilityError(f"CALVIN native evaluator/config identity differs: {relative}")
    config = dataset_root / snapshot["debug_config"]["path"]
    data = config.read_bytes()
    if (config.is_symlink() or len(data) != snapshot["debug_config"]["bytes"]
            or hashlib.sha256(data).hexdigest() != snapshot["debug_config"]["sha256"]):
        raise CompatibilityError("only the unchanged official debug configuration is implemented")
    packages = {}
    for line in Path(__file__).with_name("requirements-rgb-setup.txt").read_text().splitlines():
        if not line.strip() or line.lstrip().startswith("#"):
            continue
        name, version = line.split("==")
        if importlib.metadata.version(name) != version:
            raise CompatibilityError(f"CALVIN dependency version differs: {name}")
        packages[name] = version
    for package, files in snapshot["package_binary_sha256"].items():
        distribution = importlib.metadata.distribution(package)
        for name, digest in files.items():
            if hashlib.sha256(Path(distribution.locate_file(name)).read_bytes()).hexdigest() != digest:
                raise CompatibilityError(f"CALVIN runtime binary differs: {package}/{name}")
    return {"source_trees": sources, "native_source_revision": NATIVE_REVISION,
            "runtime_snapshot_sha256": SNAPSHOT_SHA256, "runtime_scope": snapshot["scope"],
            "dependency_versions": packages, "debug_config": {**snapshot["debug_config"], "root": str(dataset_root)},
            "original_debug_archive": snapshot["original_debug_archive"],
            "frozen_sequence_sha256": SEQUENCE_SHA256, "sequence": frozen_sequence(),
            "runtime_environment": {key: os.environ.get(key) for key in
                                    ("CUDA_VISIBLE_DEVICES", "EGL_VISIBLE_DEVICES", "PYOPENGL_PLATFORM")}}


def verify_loaded_native_modules(package_root):
    for name, module in tuple(sys.modules.items()):
        if name == "calvin_env" or name.startswith("calvin_env."):
            origin = getattr(module, "__file__", None)
            if origin:
                valid = Path(origin).resolve().is_relative_to(package_root)
            else:
                # The pinned source has PEP 420 namespace subdirectories (envs,
                # robot, camera). Verify their actual search roots, not a
                # fabricated __init__.py requirement.
                paths = list(getattr(module, "__path__", ()))
                expected = package_root.joinpath(*name.split(".")[1:])
                valid = len(paths) == 1 and Path(paths[0]).resolve() == expected
            if not valid:
                raise CompatibilityError(f"CALVIN loaded module outside the pinned source: {name}")


def _native_imports(source_root):
    package_root = (source_root / "calvin_env" / "calvin_env").resolve()
    # Do not run stale bytecode or ignored/untracked Python import overrides.
    known = {row.split(b"\t", 1)[1].decode() for row in
             _git(source_root / "calvin_env", "ls-tree", "-rz", "HEAD").split(b"\0") if row}
    for path in package_root.rglob("*"):
        if path.is_symlink():
            raise CompatibilityError(f"native CALVIN import tree must not contain symlinks: {path}")
        if path.is_file() and (path.suffix in (".pyc", ".pyo", ".so")
                               or path.suffix == ".py" and str(path.relative_to(package_root.parent)) not in known):
            raise CompatibilityError(f"unexpected native CALVIN executable file: {path}")
    for name in sys.modules:
        if name == "torch" or name.startswith(("torch.", "calvin_agent.")) or name == "calvin_agent":
            raise CompatibilityError("CALVIN RGB service must not import learned-model evaluation helpers")
    verify_loaded_native_modules(package_root)
    expected_path = str(package_root.parent)
    if expected_path in sys.path:
        sys.path.remove(expected_path)
    sys.path.insert(0, expected_path)
    env_module = importlib.import_module("calvin_env.envs.play_table_env")
    importlib.import_module("calvin_env.envs.tasks")
    verify_loaded_native_modules(package_root)
    return env_module


def resolved_config(source_root, dataset_root):
    from omegaconf import OmegaConf
    cfg = OmegaConf.load(dataset_root / "validation/.hydra/merged_config.yaml")
    if (cfg.env._target_ != "calvin_env.envs.play_table_env.PlayTableSimEnv"
            or cfg.env.seed != 0 or cfg.env.bullet_time_step != 240.0 or cfg.env.control_freq != 30
            or not cfg.env.use_egl or list(cfg.env.cameras) != ["static", "gripper", "tactile"]
            or cfg.env.robot_cfg.use_ik_fast or cfg.env.robot_cfg.filename != "franka_panda/panda_longer_finger.urdf"):
        raise CompatibilityError("CALVIN original debug configuration semantics differ")
    del cfg.env.cameras.tactile  # Same RGB-only omission as the retained evaluator.
    cfg.env.show_gui, cfg.env.use_vr, cfg.env.use_scene_info = False, False, True
    annotation = OmegaConf.load(source_root / LANGUAGE_CONFIG)
    sequence = frozen_sequence()
    if [annotation[task][0] for task in sequence["tasks"]] != sequence["instructions"]:
        raise CompatibilityError("CALVIN selected native language differs")
    return cfg


class PhysicsTrace:
    """Passive ticks; reject alien/nested clients before native default-client APIs."""
    def __init__(self, bullet):
        self.bullet = bullet
        self.original_connect, self.original_step = bullet.connect, bullet.stepSimulation
        self.clients = []
        self.phase = "construction"
        self.completed_ticks = {"construction": 0, "reset": 0, "control": 0}
        self.started_ticks = {"construction": 0, "reset": 0, "control": 0}
        self.installed = False

    def connect(self, *args, **kwargs):
        result = self.original_connect(*args, **kwargs)
        if isinstance(result, int) and result >= 0:
            self.clients.append(result)
            if result != 0 or len(self.clients) != 1:
                raise CompatibilityError("CALVIN native construction requires its sole owned Bullet client 0")
        return result

    def step(self, *args, **kwargs):
        self.started_ticks[self.phase] += 1
        result = self.original_step(*args, **kwargs)
        self.completed_ticks[self.phase] += 1
        return result

    def install(self):
        if self.installed or getattr(self.bullet, "_rsi_calvin_trace_owner", None) is not None:
            raise ProtocolError("CALVIN supports one physics trace owner, never nested/shared runtimes")
        self.bullet.connect, self.bullet.stepSimulation = self.connect, self.step
        self.bullet._rsi_calvin_trace_owner = self
        self.installed = True

    def restore(self):
        if self.installed:
            self.bullet.connect, self.bullet.stepSimulation = self.original_connect, self.original_step
            del self.bullet._rsi_calvin_trace_owner
            self.installed = False


class NativeRuntime:
    """Own even a partially initialized native object; construction is explicit."""
    def __init__(self, module, cfg, oracle):
        self.env = module.PlayTableSimEnv.__new__(module.PlayTableSimEnv)
        self.env.p, self.env.cid, self.env.ownsPhysicsClient = module.p, -1, False
        self.trace = PhysicsTrace(module.p)
        self.cfg, self.oracle = cfg, oracle
        self.constructed = False
        self.previous_opengl = os.environ.get("PYOPENGL_PLATFORM")

    def construct(self):
        if self.env.p.isConnected(physicsClientId=0):
            raise CompatibilityError("CALVIN needs a fresh dedicated process with no existing Bullet client 0")
        self.trace.install()
        kwargs = {key: self.cfg.env[key] for key in self.cfg.env if not key.startswith("_")}
        self.env.__init__(**kwargs)
        self.constructed = True
        robot = self.env.robot
        if (self.env.cid != 0 or self.env.use_vr or self.env.show_gui or not self.env.use_egl or self.env.action_repeat != 8
                or self.env.control_freq != 30 or not self.env.use_scene_info
                or robot.use_ik_fast or not robot.use_target_pose or not robot.euler_obs
                or robot.max_rel_pos != 0.02 or robot.max_rel_orn != 0.05
                or robot.magic_scaling_factor_pos != 1 or robot.magic_scaling_factor_orn != 1
                or list(robot.gripper_joint_limits) != [0, 0.04]
                or [camera.name for camera in self.env.cameras] != ["static", "gripper"]):
            raise CompatibilityError("CALVIN compiled native control/camera contract differs")

    def close(self):
        receipt = {"constructed": self.constructed, "native_close_returned": False,
                   "clients": list(self.trace.clients), "orphan_disconnects": [],
                   "disconnected": [], "error_types": []}
        errors = []
        try:
            self.env.close()
            receipt["native_close_returned"] = True
        except BaseException as exc:
            errors.append(exc)
        for cid in self.trace.clients:
            try:
                # Native assigns self.cid only after EGL plugin loading. A
                # failure before that point needs cleanup of its recorded ID;
                # this is not a second attempt at an errored disconnect.
                if cid != self.env.cid and self.env.p.isConnected(physicsClientId=cid):
                    self.env.p.disconnect(physicsClientId=cid)
                    receipt["orphan_disconnects"].append(cid)
                if self.env.p.isConnected(physicsClientId=cid):
                    raise ProtocolError("native CALVIN physics client remains connected")
                receipt["disconnected"].append(cid)
            except BaseException as exc:
                errors.append(exc)
        # Native __del__ calls close again. Ownership is bookkeeping, not a
        # simulator operation; disarm it after this explicit cleanup attempt.
        self.env.ownsPhysicsClient = False
        self.trace.restore()
        if self.previous_opengl is None:
            os.environ.pop("PYOPENGL_PLATFORM", None)
        else:
            os.environ["PYOPENGL_PLATFORM"] = self.previous_opengl
        receipt["error_types"] = [type(exc).__name__ for exc in errors]
        return receipt, errors


def prepare_native(source_root, dataset_root):
    module = _native_imports(source_root)
    import hydra
    from omegaconf import OmegaConf
    cfg = resolved_config(source_root, dataset_root)
    oracle = hydra.utils.instantiate(OmegaConf.load(source_root / TASK_CONFIG))
    if oracle.num_tasks != 34:
        raise CompatibilityError("CALVIN native oracle must expose 34 configured predicates")
    return NativeRuntime(module, cfg, oracle)


def import_preflight(source_root, dataset_root):
    """Readiness plus module/config imports only: no native object allocated."""
    receipt = readiness(source_root, dataset_root)
    _native_imports(source_root)
    cfg = resolved_config(source_root, dataset_root)
    from omegaconf import OmegaConf
    receipt["resolved_environment_config"] = OmegaConf.to_container(cfg.env, resolve=True)
    receipt["native_constructions"] = receipt["native_resets"] = receipt["native_controls"] = 0
    return receipt