"""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)