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

"""Benchmark-owned LIBERO service adapter and private native session."""

from __future__ import annotations

import hashlib
import importlib.metadata
import importlib.util
import json
import os
import subprocess
from importlib import resources
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

LIBERO_REVISION = "8f1084e3132a39270c3a13ebe37270a43ece2a01"
FIRST_PASS_SEED = 20260907
# Historical public name retained for compatibility. This is the retained
# StarVLA LIBERO-10 evaluator reference, not a universal official LIBERO limit.
NATIVE_HORIZON = 520
SETTLE_STEPS = 10
CAMERAS = ("agentview", "robot0_eye_in_hand")
TASK_NAMES = (
    "LIVING_ROOM_SCENE2_put_both_the_alphabet_soup_and_the_tomato_sauce_in_the_basket",
    "LIVING_ROOM_SCENE2_put_both_the_cream_cheese_box_and_the_butter_in_the_basket",
    "KITCHEN_SCENE3_turn_on_the_stove_and_put_the_moka_pot_on_it",
    "KITCHEN_SCENE4_put_the_black_bowl_in_the_bottom_drawer_of_the_cabinet_and_close_it",
    "LIVING_ROOM_SCENE5_put_the_white_mug_on_the_left_plate_and_put_the_yellow_and_white_mug_on_the_right_plate",
)
INSTRUCTIONS = (
    "put both the alphabet soup and the tomato sauce in the basket",
    "put both the cream cheese box and the butter in the basket",
    "turn on the stove and put the moka pot on it",
    "put the black bowl in the bottom drawer of the cabinet and close it",
    "put the white mug on the left plate and put the yellow and white mug on the right plate",
)


def task_catalog() -> dict[str, dict[str, Any]]:
    """Load the packaged native task identities without importing a simulator."""
    path = resources.files("benchmarks.simBenchmarks.LIBERO.bench_server.protocol").joinpath("libero_catalog.json")
    payload = json.loads(path.read_text(encoding="utf-8"))
    if (payload.get("schema_version") != "starvla-rsi.libero-task-catalog/v1"
            or payload.get("upstream_revision") != LIBERO_REVISION):
        raise CompatibilityError("LIBERO catalog schema or source revision differs")
    expected_counts = {"libero_spatial": 10, "libero_object": 10, "libero_goal": 10,
                       "libero_90": 90, "libero_10": 10}
    rows = payload["suites"]
    result = {row["suite"]: row for row in rows}
    if len(rows) != 5 or set(result) != set(expected_counts):
        raise CompatibilityError("LIBERO catalog must contain the five frozen suites")
    for name, count in expected_counts.items():
        row = result[name]
        if (row["task_count"] != count or row["task_order_index"] != 0
                or len(row["tasks"]) != count
                or [task["native_id"] for task in row["tasks"]] != list(range(count))):
            raise CompatibilityError(f"LIBERO catalog task count/order differs for {name}")
    if (tuple(row["native_name"] for row in result["libero_10"]["tasks"][:5]) != TASK_NAMES
            or tuple(row["instruction"] for row in result["libero_10"]["tasks"][:5]) != INSTRUCTIONS):
        raise CompatibilityError("LIBERO catalog differs from historical first-five identities")
    return result


def policy_observation(
    raw: Mapping[str, Any], step: int, instruction: str, proprioception: bool = False,
) -> Observation:
    """Copy only the two fixed RGB views and optionally robot joint encoders."""
    import numpy as np

    images: dict[str, Any] = {}
    for camera in CAMERAS:
        if f"{camera}_image" not in raw:
            raise ProtocolError(f"native observation omitted {camera}")
        frame = np.asarray(raw[f"{camera}_image"])
        if frame.dtype != np.uint8 or frame.shape != (256, 256, 3):
            raise ProtocolError(f"{camera} must be a 256x256 uint8 RGB image")
        # Fixed retained-LIBERO orientation transform, shared by every policy.
        images[camera] = np.ascontiguousarray(frame[::-1, ::-1]).copy()
    state = None
    if proprioception:
        if "robot0_joint_pos" not in raw or "robot0_gripper_qpos" not in raw:
            raise ProtocolError("native observation omitted declared robot joint encoders")
        arm = np.asarray(raw["robot0_joint_pos"])
        gripper = np.asarray(raw["robot0_gripper_qpos"])
        if arm.shape != (7,) or gripper.shape != (2,):
            raise ProtocolError("LIBERO qpos track requires 7 arm and 2 gripper positions")
        values = np.concatenate((arm, gripper))
        if not np.isfinite(values).all():
            raise ProtocolError("robot joint encoders must be finite")
        state = tuple(float(value) for value in values)
    # No object-state, EEF/object true poses, reward, success, reset seed, camera
    # calibration, simulator state or other native fields cross this boundary.
    return Observation(step=step, instruction=instruction, images=images, state=state)


def _source_root() -> Path:
    package = importlib.util.find_spec("libero")
    if package is None or not package.submodule_search_locations:
        raise CompatibilityError(
            "LIBERO namespace is not importable: add the pinned source root to PYTHONPATH; "
            "this is required even after its editable install (see the LIBERO README)"
        )
    root = Path(next(iter(package.submodule_search_locations))).resolve().parent
    git_env = {**os.environ, "GIT_OPTIONAL_LOCKS": "0"}
    try:
        top_level = subprocess.run(
            ["git", "-C", str(root), "rev-parse", "--show-toplevel"], check=True,
            capture_output=True, text=True, timeout=20, env=git_env,
        ).stdout.strip()
        if Path(top_level).resolve() != root:
            raise CompatibilityError("LIBERO source must have its own Git checkout, not inherit a parent")
        revision = subprocess.run(
            ["git", "-C", str(root), "rev-parse", "HEAD"], check=True,
            capture_output=True, text=True, timeout=20, 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=60, env=git_env,
        ).stdout.strip()
    except (OSError, subprocess.SubprocessError) as exc:
        raise CompatibilityError("cannot verify the installed LIBERO source checkout") from exc
    if revision != LIBERO_REVISION or dirty:
        raise CompatibilityError(f"LIBERO must be a clean checkout at {LIBERO_REVISION}")
    for package_name, expected in (
        ("robosuite", "1.4.0"), ("mujoco", "3.2.3"), ("numpy", "1.24.4"), ("torch", "2.5.1+cpu"),
    ):
        if importlib.metadata.version(package_name) != expected:
            raise CompatibilityError(f"this LIBERO track requires {package_name}=={expected}")
    config_dir = os.environ.get("LIBERO_CONFIG_PATH")
    if not config_dir or not (Path(config_dir) / "config.yaml").is_file():
        raise CompatibilityError(
            "set LIBERO_CONFIG_PATH to the configured environment directory before importing LIBERO"
        )
    return root


class LiberoEpisode:
    """Private native environment, reset-state loader and native success scorer."""

    def __init__(self, benchmark: LiberoBenchmarkAdapter, episode: EpisodeSpec) -> None:
        self.benchmark = benchmark
        self.episode = episode
        self.env: Any = None
        self.artifact_dir: Path | None = None
        self.writers: dict[str, Any] = {}
        self.step_count = 0
        self.success = False
        self.finished = False

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

    def reset(self) -> Observation:
        root = _source_root()
        import numpy as np
        import robosuite
        from libero.libero import benchmark as native_benchmark
        from libero.libero import get_libero_path
        from libero.libero.envs import OffScreenRenderEnv

        for key, suffix in (("bddl_files", "bddl_files"), ("init_states", "init_files"), ("assets", "assets")):
            if Path(get_libero_path(key)).resolve() != root / "libero" / "libero" / suffix:
                raise CompatibilityError(f"LIBERO {key} path is outside the pinned source checkout")
        suite_name = self.benchmark.suite
        suite = native_benchmark.get_benchmark_dict()[suite_name](task_order_index=0)
        task_id = int(self.episode.metadata["task_id"])
        task = suite.get_task(task_id)
        frozen = self.benchmark.suite_catalog["tasks"][task_id]
        if (suite.n_tasks != self.benchmark.suite_catalog["task_count"]
                or task.name != frozen["native_name"] or task.language != frozen["instruction"]):
            raise CompatibilityError("native LIBERO task identity/order differs from the frozen catalog")
        bddl = Path(suite.get_task_bddl_file_path(task_id))
        if hashlib.sha256(bddl.read_bytes()).hexdigest() != frozen["bddl_sha256"]:
            raise CompatibilityError("native task BDDL hash differs from the frozen catalog")
        initial_file = Path(get_libero_path("init_states")) / task.problem_folder / task.init_states_file
        initial_states = suite.get_task_init_states(task_id)
        if len(initial_states) != frozen["released_initial_state_count"]:
            raise CompatibilityError("pinned LIBERO task initial-state count differs from the catalog")
        controller = robosuite.load_controller_config(default_controller="OSC_POSE")
        if (
            controller["input_min"] != -1 or controller["input_max"] != 1
            or controller["output_max"] != [0.05, 0.05, 0.05, 0.5, 0.5, 0.5]
            or controller["output_min"] != [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5]
            or controller["control_delta"] is not True
        ):
            raise CompatibilityError("native OSC_POSE action scaling differs from the declared contract")
        provenance = {
            "upstream_revision": LIBERO_REVISION,
            "suite": suite_name, "selection_scope": self.benchmark.scope,
            "task_order_index": 0, "task_id": task_id,
            "task_name": task.name, "initial_state_index": 0,
            "available_initial_states": len(initial_states), "reset_seed": self.episode.seed,
            "bddl_sha256": hashlib.sha256(bddl.read_bytes()).hexdigest(),
            "initial_states_file_sha256": hashlib.sha256(initial_file.read_bytes()).hexdigest(),
            "selected_state_sha256": hashlib.sha256(np.asarray(initial_states[0]).tobytes()).hexdigest(),
            **self.benchmark.budget_metadata(), "settle_steps": SETTLE_STEPS,
            "native_engine_horizon": self.benchmark.native_engine_horizon,
            "image_transform": "native_rgb[::-1,::-1], contiguous copy; no resize or crop",
            "controller": controller,
            "versions": {name: importlib.metadata.version(name) for name in (
                "libero", "robosuite", "mujoco", "numpy", "torch", "imageio", "imageio-ffmpeg",
            )},
        }
        if self.artifact_dir is not None:
            atomic_write_json(self.artifact_dir / "native_provenance.json", provenance)
        np.random.seed(self.episode.seed)
        self.env = OffScreenRenderEnv(
            bddl_file_name=str(bddl), camera_heights=256, camera_widths=256,
            camera_names=list(CAMERAS), camera_depths=False, camera_segmentations=None,
            render_gpu_device_id=self.benchmark.render_gpu_device_id,
            # Keep native observable construction intact: this pin crashes when
            # use_object_obs=False. policy_observation drops all object fields.
            control_freq=20, horizon=self.benchmark.native_engine_horizon,
        )
        low, high = self.env.env.action_spec
        if not np.array_equal(low, np.full(7, -1.0)) or not np.array_equal(high, np.full(7, 1.0)):
            raise CompatibilityError("native LIBERO action bounds must be seven dimensions in [-1, 1]")
        self.env.seed(self.episode.seed)
        self.env.reset()
        raw = self.env.set_init_state(initial_states[0])
        for _ in range(SETTLE_STEPS):
            raw, _reward, native_success, _info = self.env.step([0.0] * 6 + [-1.0])
            if native_success:
                raise ProtocolError("task succeeded during initialization before any policy decision")
        self.step_count = 0
        self.success = False
        self.finished = False
        return self._observe(raw)

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

            for camera, rgb in observation.images.items():
                path = self.artifact_dir / f"{camera}-{self.step_count:06d}.png"
                Image.fromarray(rgb).save(path)
                if camera not in self.writers:
                    self.writers[camera] = imageio.get_writer(
                        str(self.artifact_dir / f"{camera}.mp4"), fps=20, codec="libx264", macro_block_size=1,
                    )
                self.writers[camera].append_data(rgb)
                append_jsonl(self.artifact_dir / "frames.jsonl", {
                    "step": self.step_count, "camera": camera, "path": path.name,
                    "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
                })
        return observation

    def step(self, action: tuple[float, ...]) -> Transition:
        if self.env is None or self.finished:
            raise ProtocolError("cannot step an uninitialized or finished LIBERO episode")
        action = self.benchmark.action_spec.validate(action)
        raw, reward, done, _private_info = self.env.step(list(action))
        self.step_count += 1
        # Pinned BDDLBaseDomain.step assigns done = self._check_success(). Never
        # call that predicate again or infer success from generated model text.
        self.success = bool(done)
        truncated = self.step_count >= self.benchmark.environment_step_cap and not self.success
        self.finished = self.success or truncated
        return Transition(
            observation=self._observe(raw), reward=float(reward), terminated=self.success, truncated=truncated,
            info={"native_success": self.success, "native_steps": self.step_count},
        )

    def metrics(self) -> Mapping[str, JsonValue]:
        return {"success": self.success, "native_steps": self.step_count, "settle_steps": SETTLE_STEPS,
                **self.benchmark.budget_metadata()}

    def _close_writers(self) -> None:
        for writer in self.writers.values():
            writer.close()
        self.writers.clear()

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

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


class LiberoBenchmarkAdapter:
    """One fixed initial state per selected task; no sampling or success retries."""

    def __init__(
        self, task_ids: Sequence[int] | None = None, *,
        suite: str = "libero_10", scope: str = "development",
        proprioception: bool = False, render_gpu_device_id: int = 0,
        budget_mode: str = "horizon", max_policy_calls: int | None = None,
        replan_interval: int | None = None,
    ) -> None:
        catalog = task_catalog()
        if not isinstance(suite, str) or suite not in catalog:
            raise ValueError("suite must be one of the five packaged LIBERO suites")
        if scope not in ("development", "task_coverage"):
            raise ValueError("scope must be development or task_coverage")
        if scope == "development" and suite != "libero_10":
            raise ValueError("historical development scope only supports libero_10; select task_coverage explicitly")
        self.suite, self.scope = suite, scope
        self.suite_catalog = catalog[suite]
        count = 5 if scope == "development" else self.suite_catalog["task_count"]
        if task_ids is None:
            task_ids = (0, 1) if scope == "development" else tuple(range(count))
        if (
            not isinstance(task_ids, (list, tuple)) or not task_ids
            or any(type(index) is not int or index not in range(count) for index in task_ids)
            or len(set(task_ids)) != len(task_ids)
            or list(task_ids) != sorted(task_ids)
        ):
            raise ValueError(f"task_ids must be a unique, increasing subset of native indices 0..{count - 1}")
        if not isinstance(proprioception, bool):
            raise TypeError("proprioception must be boolean")
        if type(render_gpu_device_id) is not int or render_gpu_device_id < 0:
            raise ValueError("render_gpu_device_id must be a nonnegative integer")
        if budget_mode not in ("horizon", "decisions"):
            raise ValueError("budget_mode must be horizon or decisions")
        if budget_mode == "decisions":
            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_ids = tuple(task_ids)
        self.proprioception = proprioception
        self.render_gpu_device_id = render_gpu_device_id
        self.native_horizon = self.suite_catalog["reference_horizon"]
        self.budget_mode = budget_mode
        self.max_policy_calls = max_policy_calls
        self.replan_interval = replan_interval
        self.environment_step_cap = (max_policy_calls * replan_interval
                                     if budget_mode == "decisions" else self.native_horizon)
        self.evaluation_horizon = self.environment_step_cap
        # Fixed initialization steps are not policy decisions. Keep the engine
        # horizon clear of the complete predeclared action budget as well.
        self.native_engine_horizon = max(1000, self.environment_step_cap + SETTLE_STEPS)
        selection = "first2" if set(self.task_ids) <= {0, 1} else "first5"
        protocol = (f"libero10-{selection}-development" if scope == "development"
                    else f"libero-task-coverage/{suite}")
        budget_track = f"/decision-{max_policy_calls}-prefix-{replan_interval}" if budget_mode == "decisions" else ""
        self.descriptor = BenchmarkDescriptor(
            name="libero", version="0.1.0" if scope == "development" else "0.2.0",
            protocol_version=protocol + "/" + ("rgb-qpos" if proprioception else "rgb")
            + budget_track + "/v1",
            source_revision=LIBERO_REVISION,
        )
        self.observation_spec = ObservationSpec(
            cameras=CAMERAS,
            state_names=(tuple(f"arm_qpos_{index}" for index in range(7))
                         + ("gripper_qpos_0", "gripper_qpos_1")) if proprioception else (),
            modalities=("language", "rgb", "joint_position") if proprioception else ("language", "rgb"),
        )
        self.action_spec = ActionSpec(
            mode="normalized_osc_delta_pose", size=7,
            names=("dx_scaled", "dy_scaled", "dz_scaled", "rx_scaled", "ry_scaled", "rz_scaled", "gripper"),
            low=(-1.0,) * 7, high=(1.0,) * 7, control_hz=20.0,
            frame="world: translation component 1 means +0.05 m",
            rotation="world axis-angle delta: rotation component 1 means +0.5 rad",
            gripper="-1 open; +1 close; 0 hold native gripper target",
        )

    def budget_metadata(self) -> dict[str, JsonValue]:
        return {
            "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": ("retained_starvla_libero10_evaluator_reference" if self.suite == "libero_10"
                                      else f"retained_starvla_{self.suite}_evaluator_reference"),
            "evaluation_horizon": self.evaluation_horizon,
        }

    def episodes(self, seed: int, limit: int | None = None) -> Sequence[EpisodeSpec]:
        if type(seed) is not int or seed != FIRST_PASS_SEED:
            raise ValueError(f"frozen LIBERO selection requires seed={FIRST_PASS_SEED}")
        if limit is not None and (type(limit) is not int or not 1 <= limit <= len(self.task_ids)):
            raise ValueError("episode limit must select a nonempty prefix without repeating any task")
        return [EpisodeSpec(
            id=f"{('libero10' if self.scope == 'development' else self.suite)}-task{task_id:02d}-init00",
            task=f"{self.suite}/task-{task_id}",
            seed=seed, instruction=self.suite_catalog["tasks"][task_id]["instruction"],
            metadata={"suite": self.suite, "task_id": task_id,
                      "task_name": self.suite_catalog["tasks"][task_id]["native_name"],
                      "task_order_index": 0, "initial_state_index": 0, "attempt": 1,
                      **self.budget_metadata(), "settle_steps": SETTLE_STEPS},
        ) for task_id in self.task_ids[:limit]]

    def open_episode(self, episode: EpisodeSpec) -> LiberoEpisode:
        if episode not in self.episodes(FIRST_PASS_SEED):
            raise ProtocolError("episode differs from the frozen LIBERO selection")
        return LiberoEpisode(self, episode)


@register_benchmark("libero")
def make_libero(parameters: Mapping[str, JsonValue]) -> LiberoBenchmarkAdapter:
    unknown = set(parameters) - {"task_ids", "suite", "scope", "proprioception", "render_gpu_device_id",
                                 "budget_mode", "max_policy_calls", "replan_interval"}
    if unknown:
        raise ValueError(f"unknown LIBERO parameters: {sorted(unknown)}")
    return LiberoBenchmarkAdapter(**parameters)