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

"""SIMPLE declared-sensor humanoid tracks with a private native WBC worker.

No simulator, torch, WBC training package, or native task module is imported here.
The 36D public action is physical joint/nav targets, NOT a 7D arm delta action.
"""

from __future__ import annotations

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

from benchkit.contracts import (
    ActionSpec, BenchmarkDescriptor, EpisodeSpec, Observation, ObservationSpec, Transition,
)
from benchkit.errors import CompatibilityError, ProtocolError
from benchmarks.simBenchmarks.SIMPLE.bench_server.native_worker_client import NativeWorkerClient

SIMPLE_REVISION = "5e3d6f84e85343e34e9bca8d157f0d7813231185"
TRACK = "simple-native-wbc-development-v1"
SEED = 20260907
TASKS = ("G1WholebodyBendPickMP-v0", "G1WholebodyOpenFaucetTeleop-v0")
INSTRUCTIONS = ("bend to pick up the cracker box", "move forward to the faucet and open it")
INVENTORY_PATH = Path(__file__).with_name("protocol") / "simple_released_tasks.json"
TASK_INVENTORY = json.loads(INVENTORY_PATH.read_text())
INVENTORY_SHA256 = hashlib.sha256(INVENTORY_PATH.read_bytes()).hexdigest()
TASK_CONFIGS = {row["task_id"]: row for row in TASK_INVENTORY["tasks"]}
FULL_TASKS = tuple(TASK_CONFIGS)
HORIZONS = {task: row["reference_native_horizon"] for task, row in TASK_CONFIGS.items()}


def task_config(task: str, task_scope: str = "pilot") -> Mapping[str, Any]:
    """Select an explicit frozen scope without expanding legacy pilot defaults."""
    if task_scope not in ("pilot", "released-12"):
        raise ValueError("task_scope must be pilot or released-12")
    if not isinstance(task, str) or task not in (TASKS if task_scope == "pilot" else FULL_TASKS):
        raise ValueError(f"task outside the frozen SIMPLE {task_scope} scope")
    config = TASK_CONFIGS[task]
    if config["backend_gate"] or config["backend"] not in ("amo", "sonic"):
        raise CompatibilityError(f"unsupported native SIMPLE backend: {config['backend_gate']}")
    return config
ARM_SUFFIXES = (
    "shoulder_pitch_joint", "shoulder_roll_joint", "shoulder_yaw_joint", "elbow_joint",
    "wrist_roll_joint", "wrist_pitch_joint", "wrist_yaw_joint",
)
# These names explicitly preserve the aligned PSI0 codec's legacy left hand order.
LEFT_HAND = tuple("left_hand_" + name + "_joint" for name in (
    "thumb_0", "thumb_1", "thumb_2", "middle_0", "middle_1", "index_0", "index_1",
))
RIGHT_HAND = tuple("right_hand_" + name + "_joint" for name in (
    "thumb_0", "thumb_1", "thumb_2", "index_0", "index_1", "middle_0", "middle_1",
))
ACTION_NAMES = (
    *LEFT_HAND, *RIGHT_HAND,
    *("left_" + name for name in ARM_SUFFIXES),
    *("right_" + name for name in ARM_SUFFIXES),
    "waist_roll_joint", "waist_pitch_joint", "waist_yaw_joint",
    "base_height_m", "forward_velocity_m_s", "lateral_velocity_m_s",
    "native_turn_command", "target_yaw_rad",
)
ACTION_SPEC = ActionSpec(
    mode="simple_physical_joint_nav_36", size=36, names=ACTION_NAMES,
    control_hz=50.0, frame="native G1 joint coordinates; native controller navigation frame",
    rotation="joint radians; waist roll,pitch,yaw; heading radians",
    gripper="14 individual dexterous hand joint position targets (radians)",
)


def decode_action(values: Sequence[float]) -> dict[str, Any]:
    """Extract only physical commands; no normalization or learned statistics."""
    vector = ACTION_SPEC.validate(values)
    return {
        "joint_positions": dict(zip(ACTION_NAMES[:31], vector[:31])),
        "base_height": vector[31], "navigate_cmd": (vector[32], vector[33], vector[34], vector[35]),
    }


def amo_payload(values: Sequence[float], stabilized_torso_ypr: Sequence[float]) -> dict[str, Any]:
    """Aligned MP mapping: waist targets must NOT replace AMO torso orientation."""
    command = decode_action(values)
    torso = tuple(float(value) for value in stabilized_torso_ypr)
    if len(torso) != 3 or not all(math.isfinite(value) for value in torso):
        raise ProtocolError("native stabilized AMO torso must be finite YPR")
    joints = command["joint_positions"]
    vx, vy, yaw_rate, target_yaw = command["navigate_cmd"]
    return {
        "target_qpos": {name: value for name, value in joints.items() if not name.startswith("waist_")},
        "waist_qpos": {name: value for name, value in joints.items() if name.startswith("waist_")},
        "action_command": [vx, target_yaw, vy, command["base_height"] - 0.75, *torso, yaw_rate],
    }


def public_observation(raw: Mapping[str, Any], step: int, instruction: str,
    proprioception: bool = False) -> Observation:
    """RGB and optional named robot encoders; no task state, scores or native info."""
    import numpy as np

    if "head_stereo_left" not in raw:
        raise ProtocolError("native observation omitted head_stereo_left")
    frame = np.asarray(raw["head_stereo_left"])
    if frame.dtype != np.uint8 or frame.shape != (360, 640, 3):
        raise ProtocolError("head_stereo_left must be native 360x640 uint8 RGB")
    if not isinstance(instruction, str) or not instruction.strip():
        raise ProtocolError("native language instruction is missing")
    state = None
    if proprioception:
        joints = raw.get("joint_positions")
        if not isinstance(joints, Mapping) or set(joints) != set(ACTION_NAMES[:31]):
            raise ProtocolError("proprioception requires exactly the 31 declared joint encoders")
        state = tuple(float(joints[name]) for name in ACTION_NAMES[:31])
        if not all(math.isfinite(value) for value in state):
            raise ProtocolError("joint encoders must be finite")
    return Observation(step=step, instruction=instruction, images={"head_stereo_left": frame.copy()}, state=state)


def validate_tick_result(message: Mapping[str, Any], expected_steps: int) -> tuple[bool, bool, bool, float]:
    """Fail closed on malformed worker fields; do not coerce RPC truthiness."""
    for name in ("success", "terminated", "truncated"):
        if type(message.get(name)) is not bool:
            raise ProtocolError(f"native RPC {name} must be a JSON boolean")
    reward = message.get("reward")
    if isinstance(reward, bool) or not isinstance(reward, Real) or not math.isfinite(float(reward)):
        raise ProtocolError("native RPC reward must be a finite real number")
    if type(message.get("native_steps")) is not int or message["native_steps"] != expected_steps:
        raise ProtocolError("native RPC step counter differs from the requested single tick")
    return message["success"], message["terminated"], message["truncated"], float(reward)


class SimpleHumanoidEpisode(NativeWorkerClient):
    def __init__(self, benchmark: SimpleHumanoidBenchmarkAdapter, episode: EpisodeSpec) -> None:
        super().__init__(benchmark, episode)
        self.steps = 0
        self.success = False
        self.finished = False
        self.return_sum = 0.0

    def _observation(self, message: Mapping[str, Any]) -> Observation:
        import numpy as np
        from PIL import Image

        assert self.artifact_dir is not None
        frame = (self.artifact_dir / str(message["frame"])).resolve()
        if not frame.is_relative_to(self.artifact_dir):
            raise ProtocolError("worker image path escaped this episode artifact directory")
        with Image.open(frame) as image:
            raw = {"head_stereo_left": np.asarray(image).copy()}
        if self.benchmark.proprioception:
            raw["joint_positions"] = message["joint_positions"]
        return public_observation(raw, self.steps, str(message["instruction"]), self.benchmark.proprioception)

    def reset(self) -> Observation:
        self._start_worker()
        source = self.benchmark.simple_root
        result = self._rpc({"op": "reset", "task": self.episode.task, "seed": self.episode.seed,
            "artifact_dir": str(self.artifact_dir), "simple_root": str(source),
            "eval_root": str(self.benchmark.eval_root), "diagnostic": self.benchmark.diagnostic,
            "budget_mode": self.benchmark.budget_mode, "environment_step_cap": self.benchmark.environment_step_cap,
            "max_policy_calls": self.benchmark.max_policy_calls, "replan_interval": self.benchmark.replan_interval,
            "proprioception": self.benchmark.proprioception, "protocol_version": self.benchmark.descriptor.protocol_version,
            "task_scope": self.benchmark.task_scope})
        if result["native_horizon"] != HORIZONS[self.episode.task]:
            raise CompatibilityError("native task horizon changed")
        self.worker_artifacts = result.get("artifacts", {})
        return self._observation(result)

    def step(self, action: Sequence[float]) -> Transition:
        if self.finished:
            raise ProtocolError("cannot step a finished SIMPLE episode")
        result = self._rpc({"op": "step", "action": self.benchmark.action_spec.validate(action)})
        success, terminated, truncated, reward = validate_tick_result(result, self.steps + 1)
        self.steps += 1
        self.success = success
        self.finished = terminated or truncated
        self.return_sum += reward
        return Transition(self._observation(result), reward, terminated, truncated,
            {"native_success": self.success, "native_steps": self.steps})

    def diagnostic_hold(self) -> Transition:
        """Evaluator-only one-tick probe; never exposed to policy or rollout RPC."""
        if not self.benchmark.diagnostic or self.steps:
            raise ProtocolError("hold is restricted to the first diagnostic tick")
        result = self._rpc({"op": "diagnostic_hold"})
        success, terminated, truncated, reward = validate_tick_result(result, self.steps + 1)
        self.steps += 1
        self.success = success
        self.finished = terminated or truncated
        self.return_sum += reward
        return Transition(self._observation(result), reward, terminated, truncated,
            {"native_success": self.success, "native_steps": self.steps})

    def metrics(self) -> Mapping[str, Any]:
        return {"success": self.success, "native_steps": self.steps, "native_return": self.return_sum,
            "reference_native_horizon": HORIZONS[self.episode.task],
            "environment_step_cap": self.benchmark.environment_step_cap,
            "track": self.benchmark.descriptor.protocol_version,
            "diagnostic_only": self.benchmark.diagnostic}



class SimpleHumanoidBenchmarkAdapter:
    """One native task/backend per runner; expansion requires an explicit scope."""

    def __init__(self, simple_root: str = "/mnt/workspace/users/jinhuiye/SIMPLE-5e3d6f8",
        eval_root: str = "/mnt/workspace/users/jinhuiye/SIMPLE/data/evals", gpu_id: int = 4,
        task_names: Sequence[str] = (TASKS[0],), worker_timeout: float = 900,
        diagnostic: bool = False, proprioception: bool = True, budget_mode: str = "decisions",
        max_policy_calls: int = 200, replan_interval: int = 5, task_scope: str = "pilot") -> None:
        self.simple_root, self.eval_root = Path(simple_root).resolve(), Path(eval_root).resolve()
        if type(gpu_id) is not int or gpu_id < 0:
            raise ValueError("gpu_id must be a nonnegative integer")
        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 a positive finite number")
        if type(diagnostic) is not bool:
            raise ValueError("diagnostic must be an explicit boolean")
        self.gpu_id, self.worker_timeout, self.diagnostic = gpu_id, float(worker_timeout), diagnostic
        self.task_names = tuple(task_names)
        if len(self.task_names) != 1:
            raise ValueError("choose exactly one SIMPLE task/backend per adapter/runner")
        config = task_config(self.task_names[0], task_scope)
        self.task_scope = task_scope
        if budget_mode not in ("decisions", "horizon"):
            raise ValueError("budget_mode must be decisions or horizon")
        if type(max_policy_calls) is not int or max_policy_calls != 200 or type(replan_interval) is not int or replan_interval != 5:
            raise ValueError("this frozen development track requires 200 policy calls and prefix cap 5")
        if type(proprioception) is not bool:
            raise ValueError("proprioception must be an explicit boolean")
        if task_scope == "released-12" and (not proprioception or budget_mode != "decisions"):
            raise ValueError("released-12 requires RGB+qpos31 and the decision-200-prefix-5 track")
        self.proprioception, self.budget_mode = proprioception, budget_mode
        self.max_policy_calls, self.replan_interval = max_policy_calls, replan_interval
        self.native_horizon = HORIZONS[self.task_names[0]]
        self.environment_step_cap = 1000 if budget_mode == "decisions" else self.native_horizon
        backend = config["backend"]
        self.backend = backend
        names = list(ACTION_NAMES)
        names[34] = "turning_flag" if backend == "amo" else "turning_gate"
        self.action_spec = ActionSpec(mode=f"simple_{backend}_physical_joint_nav_36", size=36,
            names=tuple(names), control_hz=50.0, frame=ACTION_SPEC.frame,
            rotation=ACTION_SPEC.rotation, gripper=ACTION_SPEC.gripper)
        self.observation_spec = ObservationSpec(cameras=("head_stereo_left",),
            state_names=ACTION_NAMES[:31] if proprioception else (),
            modalities=("rgb", "language", "proprioception") if proprioception else ("rgb", "language"))
        modality = "rgb-qpos31" if proprioception else "rgb"
        budget = "decision-200-prefix-5" if budget_mode == "decisions" else f"native-horizon-{self.native_horizon}-200calls-prefix5"
        prefix = "simple" if task_scope == "pilot" else "simple/released-12"
        self.descriptor = BenchmarkDescriptor("simple_humanoid", "5e3d6f8-patched-native",
            f"{prefix}/{backend}/{modality}/{budget}/v2", SIMPLE_REVISION)

    def episodes(self, seed: int = SEED, limit: int | None = None) -> Sequence[EpisodeSpec]:
        if type(seed) is not int or seed != SEED:
            raise ProtocolError(f"frozen SIMPLE development seed is {SEED}")
        if limit is not None and (type(limit) is not int or limit <= 0):
            raise ValueError("episode limit must be a positive integer or None")
        episodes = tuple(EpisodeSpec(id=f"{task}/dr0/ep0", task=task, seed=SEED,
            instruction=TASK_CONFIGS[task]["instruction"], metadata={"dr_level": 0, "episode_index": 0,
                "reference_native_horizon": HORIZONS[task], "environment_step_cap": self.environment_step_cap,
                "budget_mode": self.budget_mode, "track": self.descriptor.protocol_version,
                **({"task_scope": self.task_scope, "task_inventory_sha256": INVENTORY_SHA256,
                    "native_task_uid": TASK_CONFIGS[task]["task_uid"], "native_backend": self.backend,
                    "reset_metadata_sha256": TASK_CONFIGS[task]["reset_metadata_sha256"],
                    "environment_config_sha256": TASK_CONFIGS[task]["environment_config_sha256"]}
                    if self.task_scope == "released-12" else {})}) for task in self.task_names)
        return episodes if limit is None else episodes[:limit]

    def open_episode(self, episode: EpisodeSpec) -> SimpleHumanoidEpisode:
        if episode not in self.episodes():
            raise ProtocolError("episode differs from the frozen SIMPLE task manifest")
        return SimpleHumanoidEpisode(self, episode)

    def aggregate(self, metrics: Sequence[Mapping[str, Any]]) -> Mapping[str, Any]:
        count = len(metrics)
        return {"episodes": count, "successes": sum(bool(item["success"]) for item in metrics),
            "success_rate": sum(bool(item["success"]) for item in metrics) / count if count else 0.0}


def make_simple_humanoid(parameters: Mapping[str, Any]) -> SimpleHumanoidBenchmarkAdapter:
    """CLI construction remains dependency-free; native imports happen at reset."""
    return SimpleHumanoidBenchmarkAdapter(**dict(parameters))