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

"""Benchmark-owned SimplerEnv service adapter and strict native observation bridge."""

from __future__ import annotations

import copy
import hashlib
import math
import os
import subprocess
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

SIMPLER_REVISION = "c701ea271b16b80616d6fed9713c4a50a0adea3b"
MANISKILL_REVISION = "ef7a4d4fdf4b69f2c2154db5b15b9ac8dfe10682"
TASK_HORIZONS = {
    "google_robot_pick_horizontal_coke_can": 80,
    "google_robot_pick_vertical_coke_can": 80,
    "google_robot_pick_standing_coke_can": 80,
    "google_robot_move_near_v0": 80,
    "google_robot_open_top_drawer": 113,
    "google_robot_open_middle_drawer": 113,
    "google_robot_open_bottom_drawer": 113,
    "google_robot_close_top_drawer": 113,
    "google_robot_close_middle_drawer": 113,
    "google_robot_close_bottom_drawer": 113,
    "google_robot_place_apple_in_closed_top_drawer": 200,
    "widowx_spoon_on_towel": 60,
    "widowx_carrot_on_plate": 60,
    "widowx_stack_cube": 60,
    "widowx_put_eggplant_in_basket": 120,
}


def _revision(root: Path, expected: str) -> dict[str, JsonValue]:
    """Refuse source drift before constructing any environment."""
    git_env = {**os.environ, "GIT_OPTIONAL_LOCKS": "0"}
    try:
        top = subprocess.run(
            ["git", "-C", str(root), "rev-parse", "--show-toplevel"], check=True,
            capture_output=True, text=True, timeout=15, env=git_env,
        ).stdout.strip()
        if Path(top).resolve() != root.resolve():
            raise CompatibilityError(f"native source must have its own Git root: {root}")
        revision = subprocess.run(
            ["git", "-C", str(root), "rev-parse", "HEAD"], check=True,
            capture_output=True, text=True, timeout=15, env=git_env,
        ).stdout.strip()
        dirty = subprocess.run(
            ["git", "-C", str(root), "status", "--porcelain", "--untracked-files=no"],
            check=True, capture_output=True, text=True, timeout=15, env=git_env,
        ).stdout.strip()
    except (OSError, subprocess.SubprocessError) as exc:
        raise CompatibilityError(f"cannot verify upstream Git checkout {root}") from exc
    if revision != expected or dirty:
        raise CompatibilityError(f"upstream must be clean at {expected}: {root} (found {revision})")
    return {"revision": revision, "tracked_dirty": False}


def policy_observation(raw: Mapping[str, Any], camera: str, step: int, instruction: str,
                       proprioception: bool = False) -> Observation:
    """Allowlist RGB and optional robot joint encoders; drop everything else."""
    import numpy as np

    rgb = np.asarray(raw["image"][camera]["rgb"])
    if rgb.dtype != np.uint8 or rgb.ndim != 3 or rgb.shape[-1] != 3:
        raise ProtocolError("native RGB must be uint8 H x W x 3")
    state = None
    if proprioception:
        qpos = np.asarray(raw["agent"]["qpos"])
        expected = 11 if camera == "overhead_camera" else 8
        if qpos.shape != (expected,) or not np.isfinite(qpos).all():
            raise ProtocolError(f"expected {expected} finite robot joint encoders")
        state = tuple(float(value) for value in qpos)
    # No raw extra, reset_info, camera matrices, depth, segmentation or metadata.
    return Observation(step=step, instruction=instruction, images={camera: rgb.copy()}, state=state)


def _native_metrics(info: Mapping[str, Any]) -> dict[str, JsonValue]:
    """Snapshot scalar native metrics without calling the stateful scorer again."""
    import numpy as np

    if "success" not in info or not isinstance(info["success"], (bool, np.bool_)):
        raise ProtocolError("native step info must contain boolean success")
    metrics: dict[str, JsonValue] = {"success": bool(info["success"])}
    for key, value in info.get("episode_stats", {}).items():
        if hasattr(value, "item"):
            value = value.item()
        if isinstance(key, str) and key != "success" and isinstance(value, (bool, int, float, str)):
            if isinstance(value, float) and not math.isfinite(value):
                raise ProtocolError("native metric is not finite")
            metrics[key] = value
    return metrics


class SimplerEnvEpisode:
    """Native runtime and private artifacts; never passed to a policy."""

    def __init__(self, benchmark: SimplerEnvBenchmarkAdapter, episode: EpisodeSpec) -> None:
        self.benchmark = benchmark
        self.episode = episode
        self.env: Any = None
        self.artifact_dir: Path | None = None
        self.writer: Any = None
        self.step_count = 0
        self.last_metrics: dict[str, JsonValue] = {"success": False}
        self.success_ever = False
        self.frame_count = 0
        self.horizon_checkpoints: dict[str, JsonValue] = {"native": None, "evaluation": None}

    def bind_artifact_dir(self, path: Path) -> None:
        self.artifact_dir = path
        path.mkdir(parents=True, exist_ok=True)

    def reset(self) -> Observation:
        import gymnasium as gym
        import mani_skill2_real2sim
        import simpler_env

        simpler_root = Path(simpler_env.__file__).resolve().parents[1]
        native_root = Path(mani_skill2_real2sim.__file__).resolve().parents[1]
        provenance = {
            "simpler_env": _revision(simpler_root, SIMPLER_REVISION),
            "mani_skill2_real2sim": _revision(native_root, MANISKILL_REVISION),
            "task": self.episode.task,
            **self.benchmark.budget_metadata(),
            "track": self.benchmark.descriptor.protocol_version,
        }
        if self.artifact_dir is not None:
            atomic_write_json(self.artifact_dir / "native_provenance.json", provenance)

        env_id, native_kwargs = simpler_env.ENVIRONMENT_MAP[self.episode.task]
        # Upstream make mutates ENVIRONMENT_MAP and has tuple obs_mode; use the
        # same registry and a fresh kwargs copy with the documented string mode.
        kwargs = copy.deepcopy(native_kwargs)
        kwargs.update(obs_mode="rgbd", prepackaged_config=True)
        kwargs["renderer_kwargs"] = {"offscreen_only": True, "device": self.benchmark.device}
        if gym.spec(env_id).max_episode_steps != self.benchmark.native_horizon:
            raise CompatibilityError("native horizon differs from the pinned task catalog")
        # Override the TimeLimit at construction, never ignore a truncation or
        # mutate the scorer. This is a predeclared, separately named track.
        self.env = gym.make(env_id, max_episode_steps=self.benchmark.evaluation_horizon, **kwargs)
        if self.benchmark.expected_gpu_uuid is not None:
            from benchmarks.simBenchmarks.SimplerEnv.environment.render_device import assert_render_device

            provenance["render_device"] = assert_render_device(self.benchmark.expected_gpu_uuid)
            if self.artifact_dir is not None:
                atomic_write_json(self.artifact_dir / "native_provenance.json", provenance)
        if self.env.spec.max_episode_steps != self.benchmark.evaluation_horizon:
            raise CompatibilityError("effective native TimeLimit differs from evaluation horizon")
        if self.env.action_space.shape != (7,):
            raise CompatibilityError("expected a seven-dimensional native action space")
        for actual, declared in zip(self.env.action_space.low, self.benchmark.action_spec.low or ()):
            if not math.isclose(float(actual), declared, rel_tol=1e-6, abs_tol=1e-6):
                raise CompatibilityError("native action lower bounds drifted")
        for actual, declared in zip(self.env.action_space.high, self.benchmark.action_spec.high or ()):
            if not math.isclose(float(actual), declared, rel_tol=1e-6, abs_tol=1e-6):
                raise CompatibilityError("native action upper bounds drifted")
        raw, _private_reset_info = self.env.reset(seed=self.episode.seed)
        if self.artifact_dir is not None:
            from importlib.metadata import version

            native = self.env.unwrapped
            provenance.update({
                "environment_id": env_id,
                "robot": native.robot_uid,
                "control_mode": native.control_mode,
                "control_hz": native.control_freq,
                "simulation_hz": native.sim_freq,
                "camera": self.benchmark.camera,
                "rgb_shape": list(raw["image"][self.benchmark.camera]["rgb"].shape),
                "packages": {name: version(name) for name in ("numpy", "scipy", "sapien", "gymnasium")},
            })
            atomic_write_json(self.artifact_dir / "native_provenance.json", provenance)
        self.step_count = 0
        self.last_metrics = {"success": False}
        self.success_ever = False
        self.horizon_checkpoints = {"native": None, "evaluation": None}
        return self._observe(raw)

    def _observe(self, raw: Mapping[str, Any]) -> Observation:
        observation = policy_observation(
            raw, self.benchmark.camera, self.step_count,
            self.env.unwrapped.get_language_instruction(), self.benchmark.proprioception,
        )
        if self.artifact_dir is not None:
            import imageio.v2 as imageio
            from PIL import Image

            rgb = observation.images[self.benchmark.camera]
            frame_path = self.artifact_dir / f"frame-{self.frame_count:06d}.png"
            Image.fromarray(rgb).save(frame_path)
            if self.writer is None:
                self.writer = imageio.get_writer(
                    str(self.artifact_dir / "video.mp4"), fps=self.benchmark.action_spec.control_hz,
                    codec="libx264", macro_block_size=1,
                )
            self.writer.append_data(rgb)
            append_jsonl(self.artifact_dir / "frames.jsonl", {
                "step": self.step_count, "camera": self.benchmark.camera,
                "path": frame_path.name, "sha256": hashlib.sha256(frame_path.read_bytes()).hexdigest(),
                "instruction": observation.instruction,
            })
            self.frame_count += 1
        return observation

    def step(self, action: tuple[float, ...]) -> Transition:
        import numpy as np

        raw, reward, native_terminated, truncated, info = self.env.step(np.asarray(action, dtype=np.float32))
        self.step_count += 1
        self.last_metrics = _native_metrics(info)
        self.success_ever = self.success_ever or bool(self.last_metrics["success"])
        for label, horizon in (("native", self.benchmark.native_horizon),
                               ("evaluation", self.benchmark.evaluation_horizon)):
            if self.step_count == horizon:
                self.horizon_checkpoints[label] = bool(self.last_metrics["success"])
        return Transition(
            observation=self._observe(raw), reward=float(reward),
            # Native evaluator continues past transient success until horizon or
            # explicit policy stop. Never award success merely by stopping here.
            terminated=False, truncated=bool(truncated),
            info={"native_terminated": bool(native_terminated), **self.last_metrics},
        )

    def metrics(self) -> Mapping[str, JsonValue]:
        return {**self.last_metrics, "success_ever": self.success_ever, "native_steps": self.step_count,
                **self.benchmark.budget_metadata(),
                "success_at_native_horizon": self.horizon_checkpoints["native"],
                "success_at_evaluation_horizon": self.horizon_checkpoints["evaluation"]}

    def artifacts(self) -> Mapping[str, str]:
        if self.writer is not None:
            self.writer.close()
            self.writer = None
        if self.artifact_dir is None:
            return {}
        return {
            name: str(self.artifact_dir / filename)
            for name, filename in (("video", "video.mp4"), ("frames", "frames.jsonl"),
                                   ("native_provenance", "native_provenance.json"))
            if (self.artifact_dir / filename).exists()
        }

    def close(self) -> None:
        try:
            if self.writer is not None:
                self.writer.close()
                self.writer = None
        finally:
            if self.env is not None:
                self.env.close()
                self.env = None


class SimplerEnvBenchmarkAdapter:
    """One robot/task cell; simulator dependencies are imported only on reset."""

    def __init__(self, task: str = "widowx_spoon_on_towel", *,
                 proprioception: bool = False, device: str = "cuda:0",
                 horizon_multiplier: int = 1, budget_mode: str = "horizon",
                 max_policy_calls: int | None = None, replan_interval: int | None = None,
                 action_rejection_feedback: bool = False,
                 interaction_mode: str = "single_response",
                 expected_gpu_uuid: str | None = None) -> None:
        if task not in TASK_HORIZONS:
            raise ValueError(f"unsupported development task {task!r}; choose one of {list(TASK_HORIZONS)}")
        if not isinstance(proprioception, bool):
            raise TypeError("proprioception must be boolean")
        if type(action_rejection_feedback) is not bool:
            raise TypeError("action_rejection_feedback must be boolean")
        if not isinstance(interaction_mode, str) or interaction_mode not in ("single_response", "agent_method"):
            raise ValueError("interaction_mode must be single_response or agent_method")
        if type(horizon_multiplier) is not int or horizon_multiplier not in (1, 2):
            raise ValueError("horizon_multiplier must be 1 (native) or 2 (extended)")
        if budget_mode not in ("horizon", "decisions"):
            raise ValueError("budget_mode must be horizon or decisions")
        if budget_mode == "decisions":
            if horizon_multiplier != 1:
                raise ValueError("decision budgets cannot also select a horizon multiplier")
            if any(type(value) is not int or value <= 0 for value in (max_policy_calls, replan_interval)):
                raise ValueError("decision budgets require positive integer max_policy_calls and replan_interval")
        elif max_policy_calls is not None or replan_interval is not None:
            raise ValueError("adapter decision limits require budget_mode=decisions; use runner limits for horizon mode")
        self.task = task
        self.proprioception = proprioception
        self.action_rejection_feedback = action_rejection_feedback
        self.interaction_mode = interaction_mode
        self.device = device
        if expected_gpu_uuid is not None:
            from benchmarks.simBenchmarks.SimplerEnv.environment.render_device import validate_gpu_uuid

            validate_gpu_uuid(expected_gpu_uuid)
        self.expected_gpu_uuid = expected_gpu_uuid
        self.native_horizon = TASK_HORIZONS[task]
        self.budget_mode = budget_mode
        self.max_policy_calls = max_policy_calls
        self.replan_interval = replan_interval
        self.horizon_multiplier = horizon_multiplier if budget_mode == "horizon" else None
        self.environment_step_cap = (
            max_policy_calls * replan_interval if budget_mode == "decisions"
            else self.native_horizon * horizon_multiplier
        )
        self.evaluation_horizon = self.environment_step_cap
        budget_track = (f"/decision-{max_policy_calls}-prefix-{replan_interval}" if budget_mode == "decisions"
                        else "/extended-2x" if horizon_multiplier == 2 else "")
        google = task.startswith("google_robot_")
        self.camera = "overhead_camera" if google else "3rd_view_camera"
        self.descriptor = BenchmarkDescriptor(
            name="simpler_env", version="0.0.1",
            protocol_version="simpler-prepackaged-development/" + ("rgb-qpos" if proprioception else "rgb")
            + budget_track + ("/action-feedback" if action_rejection_feedback else "")
            + ("/agent-method" if interaction_mode == "agent_method" else "") + "/v1",
            source_revision=SIMPLER_REVISION + ":" + MANISKILL_REVISION,
        )
        self.observation_spec = ObservationSpec(
            cameras=(self.camera,),
            state_names=tuple(f"qpos_{i}" for i in range(11 if google else 8)) if proprioception else (),
            modalities=("language", "rgb", "joint_position") if proprioception else ("language", "rgb"),
        )
        self.action_spec = ActionSpec(
            mode="ee_delta_pose", size=7,
            names=("dx_m", "dy_m", "dz_m", "rx_rad", "ry_rad", "rz_rad", "gripper"),
            low=(-1.0, -1.0, -1.0, -math.pi / 2, -math.pi / 2, -math.pi / 2, -1.0),
            high=(1.0, 1.0, 1.0, math.pi / 2, math.pi / 2, math.pi / 2, 1.0),
            control_hz=3.0 if google else 5.0,
            frame="ee_align (measured-pose delta)" if google else "ee_align2 (accumulated-target delta)",
            rotation="axis-angle rotation vector, radians",
            gripper="+1 close; -1 open; 0 hold (target delta)" if google else "+1 open; -1 close; 0 intermediate (absolute)",
        )

    def budget_metadata(self) -> dict[str, JsonValue]:
        return {
            "interaction_mode": self.interaction_mode,
            "budget_mode": self.budget_mode,
            "max_policy_calls": self.max_policy_calls, "replan_interval": self.replan_interval,
            "environment_step_cap": self.environment_step_cap,
            "native_horizon": self.native_horizon,
            "native_horizon_source": "pinned_gym_registration",
            "evaluation_horizon": self.evaluation_horizon, "horizon_multiplier": self.horizon_multiplier,
        }

    def episodes(self, seed: int, limit: int | None = None) -> Sequence[EpisodeSpec]:
        count = 1 if limit is None else limit
        return [EpisodeSpec(
            id=f"{self.task}-{index:06d}", task=self.task, seed=seed + index,
            instruction="Follow the current instruction in the camera observation.",
            metadata={**self.budget_metadata(),
                      "selection": "prepackaged_seeded_reset"},
        ) for index in range(count)]

    def open_episode(self, episode: EpisodeSpec) -> SimplerEnvEpisode:
        if episode.task != self.task:
            raise ProtocolError("episode task does not match adapter task")
        return SimplerEnvEpisode(self, episode)


@register_benchmark("simpler_env")
def make_simpler_env(parameters: Mapping[str, JsonValue]) -> SimplerEnvBenchmarkAdapter:
    unknown = set(parameters) - {"task", "proprioception", "device", "horizon_multiplier",
                                 "budget_mode", "max_policy_calls", "replan_interval",
                                 "action_rejection_feedback", "interaction_mode", "expected_gpu_uuid"}
    if unknown:
        raise ValueError(f"unknown SimplerEnv parameters: {sorted(unknown)}")
    return SimplerEnvBenchmarkAdapter(**parameters)