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

"""RoboDojo Direct v2 sensors and EEF control behind the SIM service.

Robot-only kinematics is a fixed benchmark control conversion, not an action
proposer.  The public server exposes only ``DirectEEFBenchmarkAdapter`` with
the versioned robot-control ACK enabled.
"""
from __future__ import annotations

import json
import hashlib
import math
from numbers import Real
import os
from pathlib import Path
from pathlib import PurePosixPath
import subprocess
from typing import Any, Mapping, Sequence

from benchkit.contracts import ActionSpec, BenchmarkDescriptor, EpisodeSpec, Observation, ObservationSpec, Transition
from benchkit.errors import ActionRejected, CompatibilityError, ProtocolError
from benchkit.validation import ValidationIssue, validate_action_vector
from benchmarks.simBenchmarks.RoboDojo.bench_server.native_worker_client import CAMERAS, RoboDojoEpisode, SEED, validate_tick_result
from benchmarks.simBenchmarks.RoboDojo.environment.reference_eef_runtime import load_runtime, pins
from benchmarks.simBenchmarks.RoboDojo.bench_server.protocol.robot_feedback import (
    SCHEMA as ROBOT_FEEDBACK_SCHEMA, validate_robot_feedback,
)
from benchmarks.simBenchmarks.RoboDojo.bench_server.protocol.task_catalog import load_catalog, task_spec

CONTROL_ALIGNMENT = "gpt-as-policy-direct/8f3d362b"
TARGET_QUATERNION_TOLERANCE = 1e-4
TASK = "classify_objects"
TASK_SPEC = task_spec(TASK)
NATIVE_INSTRUCTION = TASK_SPEC["native_instruction"]
INSTRUCTION = TASK_SPEC["public_instruction"]
HORIZON = TASK_SPEC["native_horizon"]
INTERFACE_PROTOCOL = load_catalog()["interface_protocol"]
POSE_FIELDS = ("x_m", "y_m", "z_m", "qw", "qx", "qy", "qz")
STATE_NAMES = tuple(name for side in ("left", "right")
    for name in (*(f"{side}_joint{i}_rad" for i in range(1, 7)), f"{side}_gripper_open_01")) + tuple(
    f"{side}_eef_{field}" for side in ("left", "right") for field in POSE_FIELDS)
ACTION_SPEC = ActionSpec(mode="robodojo_dual_x5_world_eef_target_16", size=16,
    names=tuple(name for side in ("left", "right") for name in (
        *(f"{side}_eef_{field}" for field in POSE_FIELDS), f"{side}_gripper_open_01")),
    control_hz=25.0, frame="world-frame measured ARX X5 link6 poses, not a gripper-tip offset",
    rotation="absolute unit quaternion wxyz for each arm",
    gripper="absolute continuous [0,1], 0 closed / 1 open; pinned native conversion")
OBSERVATION_SPEC = ObservationSpec(cameras=CAMERAS, state_names=STATE_NAMES,
    modalities=("rgb", "language", "proprioception"), privileged=False,
    control_feedback_schema=ROBOT_FEEDBACK_SCHEMA)


def validate_action(values: Sequence[float]) -> tuple[float, ...]:
    tolerance = TARGET_QUATERNION_TOLERANCE
    vector = ACTION_SPEC.validate(values)
    for offset in (0, 8):
        norm = math.sqrt(sum(value * value for value in vector[offset + 3:offset + 7]))
        if abs(norm - 1.0) > tolerance:
            raise ProtocolError("EEF target quaternion must be unit length; no silent normalization")
        if not 0 <= vector[offset + 7] <= 1:
            raise ProtocolError("EEF gripper target must be in [0,1]")
    return vector


def validate_direct_tick_result(message: Mapping[str, Any], expected_targets: int, *, horizon: int = HORIZON):
    """Reuse strict native counter/reward checks, with reference timeout flags."""
    metrics = message.get("metrics")
    if not isinstance(metrics, Mapping):
        raise ProtocolError("native RPC metrics must be an object")
    if any(type(message.get(name)) is not bool for name in ("terminated", "truncated")):
        raise ProtocolError("native RPC terminal flags must be boolean")
    if type(horizon) is not int or horizon <= 0 or type(expected_targets) is not int or not 1 <= expected_targets <= horizon:
        raise ProtocolError("reference control count is outside native horizon")
    legacy_projection = {**message, "terminated": metrics.get("native_end_flag"), "truncated": False}
    success, ended, _, reward = validate_tick_result(legacy_projection, expected_targets)
    if expected_targets == horizon and not ended:
        raise ProtocolError("native horizon reached without native termination")
    truncated = bool(ended and not success and expected_targets >= horizon)
    terminated = bool(ended and not truncated)
    if message["terminated"] is not terminated or message["truncated"] is not truncated:
        raise ProtocolError("reference native terminal flags disagree")
    return success, terminated, truncated, reward


def public_state(values: Sequence[float]) -> tuple[float, ...]:
    if not isinstance(values, (tuple, list)) or len(values) != len(STATE_NAMES):
        raise ProtocolError("expected measured qpos14 and EEF14, in the declared fixed order")
    if any(isinstance(v, bool) or not isinstance(v, Real) or not math.isfinite(float(v)) for v in values):
        raise ProtocolError("proprioception must contain finite real measurements")
    result = tuple(float(v) for v in values)
    for start in (17, 24):
        if abs(math.sqrt(sum(v * v for v in result[start:start + 4])) - 1) > 1e-4:
            raise ProtocolError("measured EEF quaternion is not unit length")
    return result


def open_frame(root: Path, relative: str):
    """Open only a regular relative path, rejecting every symlink component."""
    if not isinstance(relative, str):
        raise ProtocolError("invalid worker image path")
    name = PurePosixPath(relative)
    if (not relative or relative == "." or "\\" in relative or name.is_absolute()
            or ".." in name.parts or name.as_posix() != relative):
        raise ProtocolError("worker image escaped its artifact directory")
    parent = os.open(root, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
    try:
        for part in name.parts[:-1]:
            child = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent)
            os.close(parent)
            parent = child
        fd = os.open(name.parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=parent)
    finally:
        os.close(parent)
    import stat
    if not stat.S_ISREG(os.fstat(fd).st_mode):
        os.close(fd)
        raise ProtocolError("worker image is not a regular file")
    return os.fdopen(fd, "rb")


class ReferenceEEFEpisode(RoboDojoEpisode):
    """Reuse only correlated private RPC and acknowledged process cleanup."""

    def _observation(self, result: Mapping[str, Any]) -> Observation:
        from PIL import Image
        import numpy as np
        if result.get("instruction") != self.benchmark.instruction or set(result.get("frames", {})) != set(CAMERAS):
            raise ProtocolError("unexpected task language or camera channels")
        images = {}
        for camera in CAMERAS:
            with open_frame(self.artifact_dir, result["frames"][camera]) as stream, Image.open(stream) as image:
                rgb = np.asarray(image).copy()
            if rgb.dtype != np.uint8 or rgb.shape != (480, 640, 3):
                raise ProtocolError("reference cameras require original uint8 480x640x3 RGB")
            images[camera] = rgb
        # No worker metrics, layout fields, object identities or calibration are
        # copied. State is measured joints/EEF and native last gripper commands.
        state = public_state(result["state"])
        feedback = None
        if self.steps:
            feedback = validate_robot_feedback(result.get("control_feedback"),
                expected_control_target=self.steps, expected_robot_state=state)
        elif "control_feedback" in result:
            raise ProtocolError("robot feedback was not declared or no control was acknowledged")
        if feedback is None:
            return Observation(self.steps, self.benchmark.instruction, images, state)
        return Observation(self.steps, self.benchmark.instruction, images, state, control_feedback=feedback)

    def reset(self) -> Observation:
        if self.process is not None or self.artifact_dir is None:
            raise ProtocolError("bind artifacts before the one permitted reset")
        benchmark = self.benchmark
        document = benchmark.runtime_document()
        repo = Path(__file__).resolve().parents[4]
        worker = Path(__file__).resolve().parents[1] / "environment" / benchmark.worker_filename
        if not benchmark.python.is_file() or not worker.is_file():
            raise CompatibilityError("missing native interpreter or reference EEF worker")
        accepted = os.environ.get("OMNI_KIT_ACCEPT_EULA", "N").lower() in ("y", "yes", "1")
        marker = benchmark.python.parent.parent / "lib/python3.11/site-packages/isaacsim/kit/EULA_ACCEPTED"
        if marker.is_file():
            accepted = accepted or (marker.read_text().splitlines() or [""])[0].strip().lower() in ("y", "yes", "1")
        if not accepted:
            raise CompatibilityError("Isaac Sim licence acceptance is unresolved")
        env = os.environ.copy()
        for name in ("CUDA_VISIBLE_DEVICES", "ROBODOJO_USD_ASSET_PREFIX", "EVAL_NUM", "RSI_SIM_SERVER_TOKEN"):
            env.pop(name, None)
        env.update(PYTHONPATH=os.pathsep.join((str(repo), str(benchmark.source_root),
                                             *benchmark.worker_pythonpath(document))),
            PYTHONNOUSERSITE="1", PYTHONDONTWRITEBYTECODE="1", PYTHONUNBUFFERED="1",
            OMP_NUM_THREADS="2", MKL_NUM_THREADS="2", XDG_CACHE_HOME=str(self.artifact_dir / "cache"),
            TORCH_EXTENSIONS_DIR=str(self.artifact_dir / "cache/torch_extensions"))
        self.log = (self.artifact_dir / "native_worker.log").open("x")
        self.process = subprocess.Popen([str(benchmark.python), "-B", str(worker)],
            cwd=benchmark.source_root, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
            stderr=self.log, text=True, bufsize=1)
        request = {"op": "reset", "task": benchmark.task, "layout_id": self.episode.metadata["layout_id"],
            "runtime_manifest": str(benchmark.runtime_manifest),
            "runtime_manifest_sha256": benchmark.runtime_manifest_sha256,
            "artifact_dir": str(self.artifact_dir), "gpu_id": benchmark.gpu_id,
            "diagnostic": benchmark.diagnostic}
        return self._observation(self._rpc(request))

    def _accept_step(self, result: Mapping[str, Any]) -> Transition:
        success, terminated, truncated, reward = validate_direct_tick_result(result, self.steps + 1,
            horizon=self.benchmark.native_horizon)
        self.steps += 1
        self.finished = terminated or truncated
        return Transition(self._observation(result), reward, terminated, truncated,
            {"native_success": success, "control_targets": result["metrics"]["control_targets"],
                "physics_ticks": result["metrics"]["physics_ticks"]})

    def step(self, action: Sequence[float]):
        if self.finished:
            raise ProtocolError("cannot step a finished episode")
        return self._accept_step(self._rpc({"op": "step", "action": validate_action(action)}))

    def metrics(self) -> Mapping[str, Any]:
        return {**self.latest, "adapter_step_returns": self.steps,
            "track": self.benchmark.descriptor.protocol_version,
            "diagnostic_only": self.benchmark.diagnostic,
            "reference_native_horizon": self.benchmark.native_horizon, "native_horizon": self.benchmark.native_horizon,
            "native_step_lim_override": None}


class DirectEEFBenchmarkAdapter:
    observation_spec = OBSERVATION_SPEC
    action_spec = ACTION_SPEC
    protocol_version = INTERFACE_PROTOCOL
    task = TASK
    instruction = INSTRUCTION
    native_horizon = HORIZON
    allowed_layout_ids = tuple(TASK_SPEC["panels"]["fast"]["layout_ids"])
    panel_name = TASK_SPEC["panels"]["fast"]["id"]
    worker_filename = "native_eef_worker.py"

    def runtime_document(self):
        return load_runtime(self.runtime_manifest, self.runtime_manifest_sha256)

    @staticmethod
    def worker_pythonpath(document):
        return [document["recording_support"]]

    @staticmethod
    def pinned_snapshot():
        return pins()

    @staticmethod
    def select_task_spec(task_id):
        spec = task_spec(task_id)
        if task_id != TASK:
            raise ValueError("task is declared but has no accepted native Direct worker")
        snapshot_path = Path(__file__).resolve().parents[1] / "environment/reference_eef_snapshot.json"
        if hashlib.sha256(snapshot_path.read_bytes()).hexdigest() != spec["layout_binding"]["snapshot_sha256"]:
            raise ValueError("task catalog and frozen layout snapshot differ")
        return spec

    def layout_inventory_digest(self):
        return self.pinned_snapshot()["classify_layout_inventory_sha256"]

    @classmethod
    def validate_action_input(cls, values):
        """Pure public action checks, before the service consumes a sequence.

        Per-decision motion limits/binary-gripper preferences belong to the
        model, not this benchmark. No native state or task feedback is read.
        """
        tolerance = TARGET_QUATERNION_TOLERANCE
        vector = validate_action_vector(ACTION_SPEC, values)
        for side, offset in (("left", 0), ("right", 8)):
            norm = math.hypot(*vector[offset + 3:offset + 7])
            if not math.isfinite(norm) or abs(norm - 1.0) > tolerance:
                raise ActionRejected(ValidationIssue("quaternion_not_unit", field=f"{side}.quaternion_norm",
                    actual=norm if math.isfinite(norm) else None, limit=tolerance))
            if not 0 <= vector[offset + 7] <= 1:
                raise ActionRejected(ValidationIssue("out_of_bounds", field=f"{side}.opening",
                    actual=vector[offset + 7], limit=0 if vector[offset + 7] < 0 else 1))
        return vector

    def __init__(self, *, runtime_manifest: str, runtime_manifest_sha256: str,
                 task_id: str = TASK,
                 panel: str = "fast", gpu_id: int = 0,
                 worker_timeout: float = 1200, diagnostic: bool = False) -> None:
        self.task_spec = self.select_task_spec(task_id)
        self.task = task_id
        self.native_horizon = self.task_spec["native_horizon"]
        if not isinstance(panel, str) or panel not in self.task_spec["panels"]:
            raise ValueError("panel must be a named task-catalog panel")
        selected_panel = self.task_spec["panels"][panel]
        self.allowed_layout_ids = tuple(selected_panel["layout_ids"])
        self.panel = panel
        self.panel_name = selected_panel["id"]
        self.instruction = self.task_spec["public_instruction"]
        self.robot_feedback = ROBOT_FEEDBACK_SCHEMA
        if type(gpu_id) is not int or gpu_id < 0 or type(diagnostic) is not bool:
            raise ValueError("invalid GPU or diagnostic selection")
        if isinstance(worker_timeout, bool) or not isinstance(worker_timeout, Real) or not math.isfinite(worker_timeout) or worker_timeout <= 0:
            raise ValueError("worker_timeout must be finite and positive")
        self.runtime_manifest = Path(runtime_manifest).absolute()
        self.runtime_manifest_sha256 = runtime_manifest_sha256
        document = self.runtime_document()
        self.source_root = self.runtime_manifest.parent.resolve() / "RoboDojo"
        self.python = Path(document["python"])
        self.layout_ids = self.allowed_layout_ids
        self.gpu_id, self.worker_timeout, self.diagnostic = gpu_id, float(worker_timeout), diagnostic
        self.budget_mode, self.max_policy_calls, self.replan_interval = "horizon", None, None
        self.environment_step_cap = self.native_horizon
        self.native_step_lim_override = None
        track = self.protocol_version
        if diagnostic:
            track += "-infrastructure-only"
        self.descriptor = BenchmarkDescriptor("robodojo", "ee67a146-native", track, self.pinned_snapshot()["native_revision"])

    def episodes(self, seed: int = SEED, limit: int | None = None) -> Sequence[EpisodeSpec]:
        if type(seed) is not int or seed != SEED:
            raise ProtocolError("use the declared RSI seed; native startup/eval seed is0")
        if limit is not None and (type(limit) is not int or not 1 <= limit <= len(self.layout_ids)):
            raise ValueError("limit must select a nonempty prefix of the frozen schedule")
        native_seed = self.task_spec["native_eval_seed"]
        simulator_seed = self.task_spec["simulator_initial_seed"]
        result = tuple(EpisodeSpec(f"{self.task}/arx_x5/eval-seed{native_seed}/layout{i}", self.task, seed, self.instruction,
            {"native_eval_seed": native_seed, "simulator_initial_seed": simulator_seed, "reset_seed": i, "layout_id": i,
             "layout_inventory_sha256": self.layout_inventory_digest(),
             "native_horizon": self.native_horizon,
             "runtime_manifest_sha256": self.runtime_manifest_sha256,
             "panel": self.panel, "panel_id": self.panel_name,
             "official_full_protocol": self.panel == "full",
             "robot_feedback_schema": self.robot_feedback,
             "control_alignment": CONTROL_ALIGNMENT,
             "target_quaternion_tolerance": TARGET_QUATERNION_TOLERANCE}) for i in self.layout_ids)
        return result if limit is None else result[:limit]

    def open_episode(self, episode: EpisodeSpec) -> ReferenceEEFEpisode:
        if episode not in self.episodes():
            raise ProtocolError("episode was not in the immutable service schedule")
        return ReferenceEEFEpisode(self, episode)


def make_reference_eef(parameters: Mapping[str, Any]) -> DirectEEFBenchmarkAdapter:
    """Construct the single Direct v2 adapter without protocol selection."""
    values = dict(parameters)
    if "protocol_track" in values or "robot_feedback" in values:
        raise ValueError("Direct v2 protocol and robot feedback are fixed")
    return DirectEEFBenchmarkAdapter(**values)