Blame for common/source/starBenchserver/benchmarks/simBenchmarks/Robotwin/bench_server/adapter.py

"""RoboTwin clean fixed-seed track: RGB, language and robot state to native qpos."""
from __future__ import annotations

import gc
import hashlib
from pathlib import Path
from typing import Any, Mapping, Sequence

from benchkit.artifacts import append_jsonl, atomic_write_json
from benchkit.contracts import (ActionSpec, BenchmarkDescriptor, EpisodeSpec, JsonValue,
                               Observation, ObservationSpec, Transition)
from benchkit.errors import CompatibilityError, ProtocolError
from benchkit.registry import register_benchmark
from benchmarks.simBenchmarks.Robotwin.environment import official, runtime

CAMERAS = ("head_camera", "left_camera", "right_camera")
IMAGE_SHAPE = (240, 320, 3)
NATIVE_HORIZON = 400
PROTOCOL = "robotwin-local-content/clean-fixed-seed/qpos14-rgb320-state14/fast-v3"
COMPAT_PROTOCOL = "robotwin-local-content/clean-fixed-seed/qpos14-rgb320-state14-oidn233/fast-v4"


def policy_observation(raw: Any, step: int, instruction: str, state: Sequence[float]) -> Observation:
    import numpy as np
    if not isinstance(raw, Mapping) or not isinstance(raw.get("observation"), Mapping):
        raise ProtocolError("native RoboTwin observation must contain cameras")
    images = {}
    for camera in CAMERAS:
        item = raw["observation"].get(camera)
        frame = item.get("rgb") if isinstance(item, Mapping) else None
        if not isinstance(frame, np.ndarray) or frame.shape != IMAGE_SHAPE or frame.dtype != np.uint8:
            raise ProtocolError(f"RoboTwin {camera} must be native 240x320 uint8 RGB")
        images[camera] = np.array(frame, copy=True, order="C")
    # joint_action.vector is commanded drive targets, NOT measured encoders.
    # State is supplied separately by the declared native measured-state APIs.
    # No endpose, front view, calibration, task info, reset seed or native score.
    return Observation(step=step, instruction=instruction, images=images,
                       state=runtime.validate_robot_state(state))


class RoboTwinEpisode:
    def __init__(self, benchmark: RoboTwinBenchmarkAdapter, episode: EpisodeSpec):
        self.benchmark, self.episode = benchmark, episode
        self.env = None
        self.scene_counter = None
        self.artifact_dir: Path | None = None
        self.writers = {}
        self.jit_cache = None
        self.step_count = self.native_steps = self.physics_ticks = 0
        self.acknowledged_controls = 0
        self.native_reset_returned = False
        self.reset_completed = False
        self.success = self.finished = self.reset_attempted = self.closed = self.finalized = False
        self.close_error: BaseException | None = None
        self.top_events = []
        self.control_error = False
        self.provenance = None

    def bind_artifact_dir(self, path: Path) -> None:
        if self.artifact_dir is not None or self.reset_attempted or self.closed or self.finalized:
            raise ProtocolError("RoboTwin artifacts must be bound once before reset")
        path.mkdir(parents=True, exist_ok=True)
        self.artifact_dir = path.resolve()

    def _log(self, event: str, **values) -> None:
        if self.artifact_dir is not None:
            append_jsonl(self.artifact_dir / "native_events.jsonl", {"event": event, **values})

    def reset(self) -> Observation:
        if self.reset_attempted or self.closed or self.finalized:
            raise ProtocolError("RoboTwin permits one reset attempt per predeclared episode")
        self.reset_attempted = True
        try:
            if self.artifact_dir is None:
                raise ProtocolError("RoboTwin native reset requires a model-owned artifact directory for its private JIT cache")
            self.jit_cache = self.artifact_dir / "cache" / "curobo-jit"
            self.jit_cache.mkdir(parents=True, exist_ok=False)
            if self.benchmark.deployment_track == official.TRACK:
                self.provenance = official.readiness(self.benchmark.source_root,
                                                    self.benchmark.deployment_manifest_sha256)
            else:
                self.provenance = runtime.readiness(self.benchmark.source_root,
                                                   self.benchmark.deployment_manifest_sha256,
                                                   self.benchmark.renderer_runtime)
            self.provenance["protocol_version"] = self.benchmark.descriptor.protocol_version
            # Retain the verified runtime choice even if native import/setup fails.
            atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance)
            self._log("native_construction_start", task=self.episode.task,
                      native_seed=self.benchmark.native_seed, expert_screening=False)
            with runtime.native_directory(self.benchmark.source_root, self.jit_cache):
                native_runtime = official if self.benchmark.deployment_track == official.TRACK else runtime
                self.env = native_runtime.create_native(self.benchmark.source_root, self.episode.task)
                runtime.verify_loaded_renderer(self.provenance, require_cuda_plugin=False)
                config = native_runtime.resolved_native_config(self.benchmark.source_root, self.episode.task)
                self._log("reset_start", native_seed=self.benchmark.native_seed,
                          initialization="native setup_demo, homestate/open-gripper/planner initialization/stability checks; no expert play_once")
                self.env.setup_demo(now_ep_num=0, seed=self.benchmark.native_seed, is_test=True, **config)
                self.native_reset_returned = True
                self._log("reset_returned")
                compiled = runtime.verify_compiled_control(self.env)
                # Native initialization is unchanged. Only subsequent task-side
                # scene.step calls are counted; no C++ scene handle is replaced.
                self.scene_counter = runtime.SceneStepCounter(self.env.scene)
                self.env.scene = self.scene_counter
                for side in ("left", "right"):
                    name = f"{side}_mplib_planner"
                    setattr(self.env.robot, name, runtime.TOPPRecorder(getattr(self.env.robot, name), side, self.top_events))
                self.provenance.update({"task": self.episode.task, "native_seed": self.benchmark.native_seed,
                                        "evaluation_mode": "fast", "sample_selection": "one predeclared unscreened native seed",
                                        "native_source_revision": self.benchmark.native_source_revision, "compiled_contract": compiled,
                                        "resolved_native_config": config, "protocol_version": self.benchmark.descriptor.protocol_version,
                                        "instruction_source": f"description/task_instruction/{self.episode.task}.json:full_description",
                                        "observation": {"cameras": list(CAMERAS), "shape": list(IMAGE_SHAPE),
                                                        "image_transform": "none; copy native RGB bytes",
                                                        "state": runtime.state_provenance()},
                                        "initialization_physics_ticks": None,
                                        "initialization_count_note": "native setup includes stability settling; not instrumented or counted as model controls",
                                        "jit_cache": {"path": str(self.jit_cache), "source": "per-episode evaluator-owned TORCH_EXTENSIONS_DIR",
                                                      "excluded_from_artifact_transfer": True, "identity": "derived native CUDA build cache; not loaded-memory attestation"},
                                        "video_timebase": "10-fps presentation of one public frame per control, not physical control frequency"})
                if self.artifact_dir is not None:
                    atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance)
                self._log("reset_end", native_horizon=NATIVE_HORIZON, policy_controls=0)
                observation = self._observe()
                renderer_loaded = runtime.verify_loaded_renderer(self.provenance, require_cuda_plugin=True)
                if renderer_loaded:
                    self.provenance["renderer_loaded_paths"] = renderer_loaded
                    atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance)
                self.reset_completed = True
                return observation
        except BaseException:
            self.finished = True
            try:
                self.close()
            except Exception as exc:
                self._log("reset_cleanup_error", error_type=type(exc).__name__)
            raise

    def _observe(self) -> Observation:
        observation = policy_observation(self.env.get_obs(), self.step_count, self.episode.instruction,
                                         runtime.robot_state(self.env))
        if self.artifact_dir is not None:
            import imageio.v2 as imageio
            from PIL import Image
            for camera, frame in observation.images.items():
                path = self.artifact_dir / f"{camera}-{self.step_count:06d}.png"
                Image.fromarray(frame).save(path)
                if camera not in self.writers:
                    self.writers[camera] = imageio.get_writer(str(self.artifact_dir / f"{camera}.mp4"),
                                                            fps=10, codec="libx264", macro_block_size=1)
                self.writers[camera].append_data(frame)
                append_jsonl(self.artifact_dir / "frames.jsonl", {
                    "camera": camera, "step": self.step_count, "control": self.step_count, "policy_physics_ticks": self.physics_ticks,
                    "policy_simulated_seconds": self.physics_ticks / 250, "path": path.name,
                    "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
                    "rgb_sha256": hashlib.sha256(frame.tobytes()).hexdigest(),
                })
        return observation

    def step(self, action: tuple[float, ...]) -> Transition:
        if self.env is None or self.closed or self.finished or self.finalized:
            raise ProtocolError("cannot control an uninitialized or finished RoboTwin episode")
        vector = self.benchmark.action_spec.validate(action)
        if self.native_steps >= NATIVE_HORIZON:
            raise ProtocolError("native RoboTwin control horizon exhausted")
        previous_top = len(self.top_events)
        self._log("action_start", control=self.step_count + 1, action=list(vector), action_type="qpos")
        try:
            with runtime.native_directory(self.benchmark.source_root, self.jit_cache):
                self.env.take_action(vector, action_type="qpos")
                self.native_steps = int(self.env.take_action_cnt)
                self.physics_ticks = self.scene_counter.steps
                if self.native_steps != self.step_count + 1 or type(self.env.eval_success) is not bool:
                    raise ProtocolError("native RoboTwin control count or cached success differs")
                self.step_count += 1
                self.success = self.env.eval_success  # Native take_action checks success each physics tick.
                self.finished = self.success or self.native_steps >= NATIVE_HORIZON
                self._log("action_end", control=self.step_count, native_steps=self.native_steps,
                          policy_physics_ticks=self.physics_ticks, native_success=self.success,
                          native_topp=self.top_events[previous_top:])
                observation = self._observe()
            transition = Transition(observation=observation, reward=float(self.success), terminated=self.success,
                              truncated=self.finished and not self.success,
                              info={"native_success": self.success, "native_steps": self.native_steps,
                                    "policy_physics_ticks": self.physics_ticks})
            self.acknowledged_controls += 1
            return transition
        except BaseException:
            self.finished = self.control_error = True
            self.native_steps = int(getattr(self.env, "take_action_cnt", self.native_steps))
            self.physics_ticks = self.scene_counter.steps
            self._log("action_error", native_started_controls=self.native_steps,
                      acknowledged_controls=self.acknowledged_controls, completed_physics_ticks=self.physics_ticks,
                      native_topp=self.top_events[previous_top:], replay_allowed=False)
            raise

    def metrics(self) -> Mapping[str, JsonValue]:
        return {"success": self.success, "native_steps": self.native_steps,
                "acknowledged_controls": self.acknowledged_controls, "completed_native_controls": self.step_count,
                "native_horizon": NATIVE_HORIZON, "reset_attempted": self.reset_attempted,
                "native_reset_returned": self.native_reset_returned, "reset_completed": self.reset_completed,
                "policy_physics_ticks": self.physics_ticks, "policy_simulated_seconds": self.physics_ticks / 250,
                "initialization_physics_ticks": None, "native_source_revision": self.benchmark.native_source_revision,
                "reward_semantics": "wrapper numeric encoding of cached native success; no shaped reward",
                "control_error": self.control_error,
                "native_topp_fallbacks": sum(row["status"] != "native_path" for row in self.top_events),
                "counter_scope": "started native qpos targets and completed task-side physics steps; errored native calls are never replayed"}

    def _close_writers(self) -> None:
        writers, self.writers = self.writers, {}
        errors = []
        for writer in writers.values():
            try:
                writer.close()
            except BaseException as exc:
                errors.append(exc)
        if errors:
            raise ProtocolError("RoboTwin media finalization failed") from errors[0]

    def artifacts(self) -> Mapping[str, str]:
        self.finalized = True
        self._close_writers()
        if self.artifact_dir is None:
            return {}
        files = {f"{camera}_video": f"{camera}.mp4" for camera in CAMERAS}
        files.update({"frames": "frames.jsonl", "native_events": "native_events.jsonl",
                      "native_provenance": "native_provenance.json", "native_cleanup": "native_cleanup.json"})
        return {key: str(self.artifact_dir / name) for key, name in files.items()
                if (self.artifact_dir / name).is_file()}

    def close(self) -> None:
        if self.closed:
            if self.close_error is not None:
                raise ProtocolError("previous RoboTwin cleanup failed") from self.close_error
            return
        self.closed = True
        errors = []
        try:
            self._close_writers()
        except BaseException as exc:
            errors.append(exc)
        env, self.env = self.env, None
        native_returned = False
        if env is not None:
            try:
                if self.scene_counter is not None:
                    env.scene = self.scene_counter.scene
                with runtime.native_directory(self.benchmark.source_root, self.jit_cache):
                    env.close_env()
                native_returned = True
            except BaseException as exc:
                errors.append(exc)
        self.scene_counter = None
        del env
        gc.collect()
        if self.artifact_dir is not None:
            try:
                atomic_write_json(self.artifact_dir / "native_cleanup.json", {
                    "native_close_returned": native_returned, "python_references_released": True,
                    "error_types": [type(exc).__name__ for exc in errors],
                    "scope": "native close_env and reference release; native gym close does not attest GPU reclamation; stop this one-episode server process after result transfer",
                })
            except BaseException as exc:
                errors.append(exc)
        if errors:
            self.close_error = errors[0]
            raise ProtocolError("RoboTwin native cleanup failed") from errors[0]


class RoboTwinBenchmarkAdapter:
    budget_mode = "horizon"
    environment_step_cap = NATIVE_HORIZON

    def __init__(self, source_root: str, deployment_manifest_sha256: str, task: str = "lift_pot",
                 native_seed: int = 100000, evaluation_mode: str = "fast",
                 renderer_runtime: str = runtime.BUNDLED_RENDERER,
                 deployment_track: str = "local_archive"):
        if (not isinstance(source_root, str) or not source_root or not Path(source_root).is_absolute()
                or ".." in Path(source_root).parts):
            raise ValueError("source_root must be an explicit absolute deployment path")
        if (not isinstance(deployment_manifest_sha256, str) or len(deployment_manifest_sha256) != 64
                or any(c not in "0123456789abcdef" for c in deployment_manifest_sha256)):
            raise ValueError("deployment_manifest_sha256 must be 64 lowercase hexadecimal characters")
        if not isinstance(task, str) or task not in runtime.TASK_INSTRUCTIONS or evaluation_mode != "fast":
            raise ValueError("only explicit clean lift_pot/click_bell fast tasks are implemented; native full is unsupported")
        if type(native_seed) is not int or not 0 <= native_seed < 2**32:
            raise ValueError("native_seed must be an integer in [0, 2**32)")
        if not isinstance(renderer_runtime, str) or renderer_runtime not in runtime.RENDERER_RUNTIMES:
            raise ValueError("renderer_runtime must be a declared pinned track")
        if deployment_track not in ("local_archive", official.TRACK):
            raise ValueError("deployment_track must be a declared source/runtime track")
        if deployment_track == official.TRACK and renderer_runtime != runtime.BUNDLED_RENDERER:
            raise ValueError("official track cannot select an archived renderer overlay")
        self.source_root = Path(source_root)
        self.deployment_manifest_sha256 = deployment_manifest_sha256
        self.task, self.native_seed = task, native_seed
        self.renderer_runtime = renderer_runtime
        self.deployment_track = deployment_track
        self.native_source_revision = official.REVISION if deployment_track == official.TRACK else None
        self.claimed = False

    @property
    def descriptor(self) -> BenchmarkDescriptor:
        if self.deployment_track == official.TRACK:
            return BenchmarkDescriptor(name="robotwin", version="official-2.0-clean-development",
                                       protocol_version=official.PROTOCOL, source_revision=official.REVISION)
        return BenchmarkDescriptor(name="robotwin", version="local-2.0-clean-development",
                                   protocol_version=(PROTOCOL if self.renderer_runtime == runtime.BUNDLED_RENDERER else COMPAT_PROTOCOL),
                                   source_revision=f"content-inventory-sha256:{runtime.NATIVE_INVENTORY_SHA256}")

    @property
    def observation_spec(self) -> ObservationSpec:
        return ObservationSpec(cameras=CAMERAS, state_names=runtime.STATE_NAMES,
                               modalities=("language", "rgb", "joint_position", "gripper_command"), privileged=False)

    @property
    def action_spec(self) -> ActionSpec:
        names = (*runtime.JOINT_NAMES[:6], "left_gripper", *runtime.JOINT_NAMES[6:], "right_gripper")
        return ActionSpec(mode="robotwin_aloha_absolute_joint_targets", size=14, names=names,
                          low=((-10.0,) * 6 + (0.0,)) * 2, high=((10.0,) * 6 + (1.0,)) * 2,
                          control_hz=None, frame="absolute native Aloha arm joint coordinates in radians",
                          rotation="joint coordinates; no EEF pose, IK or task planning interface",
                          gripper="normalized absolute native gripper command: 0 closed, 1 open; native scale [-0.01,0.045] m")

    def episodes(self, seed: int, limit: int | None = None) -> Sequence[EpisodeSpec]:
        if type(seed) is not int or not 0 <= seed < 2**32:
            raise ValueError("harness seed must be an integer in [0, 2**32)")
        if limit is not None and (type(limit) is not int or limit != 1):
            raise ValueError("this single-task server permits exactly one episode")
        return (EpisodeSpec(id=f"{self.task}-native-seed{self.native_seed}-episode000", task=self.task,
                            seed=seed, instruction=runtime.TASK_INSTRUCTIONS[self.task], metadata={
                                "evaluation_mode": "fast", "native_seed": self.native_seed,
                                "task_config": "demo_clean", "native_horizon": NATIVE_HORIZON,
                                "native_horizon_source": ("env_cfg/task_config/_eval_step_limit.yml"
                                    if self.deployment_track == official.TRACK else "task_config/_eval_step_limit.yml"),
                                "native_source_revision": self.native_source_revision, "expert_screening": False,
                                "instruction_selection": "fixed native full_description; no expert-derived placeholders",
                                "sample_selection": "predeclared unscreened seed; one attempt; no retry",
                            }),)

    def open_episode(self, episode: EpisodeSpec) -> RoboTwinEpisode:
        if episode not in self.episodes(episode.seed):
            raise ProtocolError("RoboTwin episode differs from its fixed schedule")
        if self.claimed:
            raise ProtocolError("RoboTwin one-episode service already claimed; start no automatic retry")
        self.claimed = True
        return RoboTwinEpisode(self, episode)


@register_benchmark("robotwin")
def make_robotwin(parameters: Mapping[str, JsonValue]) -> RoboTwinBenchmarkAdapter:
    allowed = {"source_root", "deployment_manifest_sha256", "task", "native_seed", "evaluation_mode", "renderer_runtime", "deployment_track"}
    if set(parameters) - allowed:
        raise ValueError(f"unknown RoboTwin parameters: {sorted(set(parameters) - allowed)}")
    if not {"source_root", "deployment_manifest_sha256"}.issubset(parameters):
        raise ValueError("RoboTwin requires an explicit content-pinned deployment root and manifest digest")
    return RoboTwinBenchmarkAdapter(**parameters)