react-manip 0.1.0__py3-none-any.whl

react_manip/instances/variation.py

@@ -0,0 +1,118 @@
+"""Explicit, evaluator-private Episode variations for four feedback tasks.
+
+Task parameters remain the baseline. Resolved variations are saved, validated,
+and applied before compilation; no sampling takes place during replay or step.
+"""
+from copy import deepcopy
+import numpy as np
+
+TASKS = ('leveling_board1', 'conveyor_grasp', 'box_insertion', 'car_drive2')
+DOMAINS = {
+    'leveling_board1': {'ordinary_dimension_m': [.06, .14], 'thin_dimensions_m': [.03, .04, .05]},
+    'conveyor_grasp': {'belt_speed_m_s': [.08, .20], 'target_size_scale': [.8, 1.15]},
+    'box_insertion': {'friction_multiplier': [.6, 1.4], 'friction_limits': [.01, .6], 'mass_scale': [.7, 1.3]},
+    'car_drive2': {'nominal_speed_m_s': [.9, 1.15]},
+}
+
+
+def _number(value, lo, hi):
+    if type(value) not in (int, float) or not np.isfinite(value) or not lo-1e-12 <= value <= hi+1e-12:
+        raise ValueError('Episode parameter outside its finite sampling domain')
+
+
+def sample_variation(task_id, base, seed, index, attempt=0):
+    """Each consecutive five Episodes cover five shuffled strata, in both phases.
+
+    Rejection retries stay in the original stratum. Seeds and indices are private.
+    Independent dimensions use independently shuffled strata.
+    """
+    if task_id not in TASKS or not 0 <= index < 15:
+        raise ValueError('unsupported Episode variation request')
+    rng = np.random.default_rng(np.random.SeedSequence([seed, index, attempt, 261012]))
+    axis = 0
+    def draw(lo, hi):
+        nonlocal axis
+        order = np.random.default_rng(np.random.SeedSequence([seed, index//5, axis, 73])).permutation(5)
+        axis += 1
+        u = (int(order[index % 5]) + rng.uniform(.05, .95))/5
+        return float(lo + (hi-lo)*u)
+    if task_id == 'leveling_board1':
+        from tasks.leveling_board1.instances import SHIM_NAMES
+        useful = rng.choice(SHIM_NAMES, 3, replace=False).tolist()
+        heights = rng.permutation([.03,.04,.05])
+        axes = {n:int(rng.integers(3)) for n in useful}
+        dims = {n:[draw(.06,.14) for _ in range(3)] for n in SHIM_NAMES}
+        for n,h in zip(useful, heights):
+            dims[n][axes[n]] = float(h)
+        result = dict(shim_dimensions=dims, solution_axes=axes)
+    elif task_id == 'conveyor_grasp':
+        result = dict(belt_speed_m_s=draw(.08,.20),
+                      target_size_scales=[draw(.8,1.15) for _ in range(base['task']['n_objects'])])
+    elif task_id == 'box_insertion':
+        result = dict(mass_scale=draw(.7,1.3), sliding_friction={
+            side:draw(max(.01,base['block_friction'][side]*.6), min(.6,base['block_friction'][side]*1.4))
+            for side in ('left','right')})
+    else:
+        result = dict(nominal_speed_m_s=draw(.9,1.15))
+    effective_parameters(task_id, base, result)
+    return result
+
+
+def effective_parameters(task_id, base, variation):
+    """Validate a strict whitelist and derive resolved parameters from the base."""
+    p = deepcopy(base)
+    expected = {
+        'leveling_board1': {'shim_dimensions','solution_axes'},
+        'conveyor_grasp': {'belt_speed_m_s','target_size_scales'},
+        'box_insertion': {'mass_scale','sliding_friction'},
+        'car_drive2': {'nominal_speed_m_s'},
+    }
+    if task_id not in expected or not isinstance(variation,dict):
+        raise ValueError('invalid Episode variation fields')
+    if set(variation) != expected[task_id]:
+        raise ValueError('invalid Episode variation fields')
+    v = deepcopy(variation)
+    if task_id == 'leveling_board1':
+        from tasks.leveling_board1.instances import validate_task_instance
+        p.update(v)
+        validate_task_instance(p)
+    elif task_id == 'conveyor_grasp':
+        _number(v['belt_speed_m_s'], .08,.20)
+        scales = v['target_size_scales']
+        if not isinstance(scales,list) or len(scales) != base['task']['n_objects']:
+            raise ValueError('one size scale per target is required')
+        for scale in scales:
+            _number(scale,.8,1.15)
+        p['belt']['speed'] = v['belt_speed_m_s']
+    elif task_id == 'box_insertion':
+        _number(v['mass_scale'],.7,1.3)
+        if not isinstance(v['sliding_friction'],dict) or set(v['sliding_friction']) != {'left','right'}:
+            raise ValueError('both block contact patches are required')
+        for side, value in v['sliding_friction'].items():
+            _number(value,max(.01,base['block_friction'][side]*.6),min(.6,base['block_friction'][side]*1.4))
+            p['block_friction'][side] = value
+    else:
+        _number(v['nominal_speed_m_s'],.9,1.15)
+        p['vehicle']['nominal_speed_m_s'] = v['nominal_speed_m_s']
+    return p
+
+
+def episode_scenario(scenario, variation):
+    resolved = deepcopy(scenario)
+    resolved.parameters = effective_parameters(scenario.task_id, scenario.parameters, variation)
+    resolved.metadata.pop('initial_episode_scene', None)
+    resolved.metadata['episode_variation'] = deepcopy(variation)
+    return resolved
+
+
+def construct_sampled_episode(scenario, robot, index, scene_seed, *, render=False):
+    """Task-default practice/exam uses the same sampler as saved question banks."""
+    from .runtime import _construct
+    variation = sample_variation(scenario.task_id, scenario.parameters, scenario.seed, index)
+    resolved = episode_scenario(scenario, variation)
+    scene = None
+    if scenario.task_id == 'leveling_board1':
+        from tasks.leveling_board1.instances import sample_episode_instance
+        scene = sample_episode_instance(resolved.parameters, scene_seed)
+    env = _construct(scenario.task_id, resolved, robot, episode=scene, render=render)
+    return env, variation

react_manip/legacy.py

@@ -0,0 +1,318 @@
+"""Compatibility helpers for migrating existing robosuite tasks.
+
+The v1 environments remain untouched.  These helpers only provide metadata
+and factory conventions so they can be evaluated by the v2 runner while task
+implementations are migrated one at a time.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Mapping
+
+from .core.protocol import normalize_reset, normalize_step
+from .core.language import runtime_language_prompt
+
+
+class TaskRobotProxy:
+    """Embodiment context for task-level environments without arm physics.
+
+    Native scene tasks (for example vehicle or board actuators) can accept a
+    robot selection while keeping their explicit task-level action API.  This
+    proxy makes that choice visible to generic frontends and benchmark logs;
+    it intentionally exposes no EEF/controller attributes, so callers cannot
+    mistake it for a simulated manipulator.
+    """
+
+    def __init__(self, robot_id: str):
+        from .robots.catalog import normalize_robot_id
+        self.robot_id = normalize_robot_id(robot_id)
+        # Context is a label, not a loaded robot model. Do not load assets or
+        # fabricate joints/arms for a native task-level scene.
+        self.name = self.robot_id
+        self.arms = ()
+
+    @property
+    def spec(self):
+        from .robots.base import RobotSpec
+        return RobotSpec(
+            robot_id=self.robot_id, arm_names=(),
+            arm_dof=(), gripper_type=None,
+            control_modes=("task_level",), capabilities=frozenset({"task_level_proxy"}),
+        )
+
+
+def attach_robot_context(env: Any, robot_id: str | None) -> Any:
+    """Attach a normalized robot context to native task-level environments."""
+    if robot_id is None:
+        return env
+    from .robots.catalog import normalize_robot_id
+    normalized = normalize_robot_id(robot_id)
+    env.robot_id = normalized
+    if getattr(env, 'robots', None):
+        return env
+    # Do not populate ``env.robots``: frontends reserve that attribute for
+    # physically compiled robot models with controllers and EEF sites.
+    env.robot_context = TaskRobotProxy(normalized)
+    return env
+
+
+class _NativeModelView:
+    """Expose a raw ``mujoco.MjModel`` through robosuite's model surface."""
+
+    def __init__(self, model: Any):
+        self._model = model
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._model, name)
+
+
+class _NativeSimView:
+    # Marker consumed by frontends that need to distinguish a raw MuJoCo
+    # scene from robosuite's MjSim wrapper.  The model is intentionally still
+    # exposed through the same ``sim.model / sim.data`` surface.
+    native_mujoco = True
+
+    def __init__(self, env: Any):
+        self.model = _NativeModelView(env.model)
+        self.data = env.data
+
+
+class LegacyTaskAdapter:
+    """Thin wrapper adding a v2-friendly signal surface to an existing env."""
+
+    def __init__(self, env: Any):
+        self.env = env
+        self._counter_snapshot: dict[str, float] = {}
+        self._episode_index = -1
+        self.language_prompt: dict[str, Any] = {}
+        self._camera_renderers = {}
+        self._camera_observation_ids = ()
+        self._camera_resolution = (640, 480)
+
+    def get_camera_specs(self):
+        from .cameras import camera_specs
+        return camera_specs(self.env)
+
+    def get_camera_calibration(self, camera_id, *, width=640, height=480):
+        """Internal diagnostics only: optical +Z forward, +Y down."""
+        import mujoco
+        import numpy as np
+        from .cameras import raw_sim
+        _, model, data = raw_sim(self.env)
+        cid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_CAMERA, camera_id)
+        if cid < 0:
+            raise ValueError(f'Unknown camera: {camera_id}')
+        f = .5 * height / np.tan(np.deg2rad(model.cam_fovy[cid] / 2))
+        rotation = data.cam_xmat[cid].reshape(3, 3) @ np.diag([1., -1., -1.])
+        world_from_optical = np.eye(4)
+        world_from_optical[:3, :3] = rotation
+        world_from_optical[:3, 3] = data.cam_xpos[cid]
+        return dict(K=np.array([[f, 0, width / 2], [0, f, height / 2], [0, 0, 1]]),
+                    world_from_optical=world_from_optical, width=width, height=height)
+
+    def render_camera(self, camera_id='workspace_oblique', *, width=640, height=480):
+        from react_manip.rendering import NativeRGBRenderer
+        key = (int(width), int(height))
+        if key not in self._camera_renderers:
+            self._camera_renderers[key] = NativeRGBRenderer(*key)
+        return self._camera_renderers[key].render(self.sim, camera_id).copy()
+
+    def get_camera_observation(self, camera_ids=None, *, width=640, height=480):
+        if camera_ids is None:
+            camera_ids = [s['id'] for s in self.get_camera_specs() if s['policy_default']]
+        elif isinstance(camera_ids, str):
+            camera_ids = (camera_ids,)
+        return {name: self.render_camera(name, width=width, height=height) for name in camera_ids}
+
+    def set_camera_observations(self, camera_ids=(), *, width=640, height=480):
+        """Opt-in RGB under observation['images']; no implicit room/debug input."""
+        if isinstance(camera_ids, str):
+            camera_ids = (camera_ids,)
+        available = {s['id'] for s in self.get_camera_specs()}
+        missing = set(camera_ids) - available
+        if missing:
+            raise ValueError(f'Unavailable cameras: {sorted(missing)}')
+        if width <= 0 or height <= 0:
+            raise ValueError('camera resolution must be positive')
+        self._camera_observation_ids = tuple(camera_ids)
+        self._camera_resolution = (int(width), int(height))
+
+    def _with_camera_observations(self, observation):
+        if not self._camera_observation_ids:
+            return observation
+        if not isinstance(observation, Mapping):
+            observation = {'state': observation}
+        width, height = self._camera_resolution
+        return dict(observation, images=self.get_camera_observation(
+            self._camera_observation_ids, width=width, height=height))
+
+    @property
+    def robot_id(self) -> str | None:
+        explicit = getattr(self.env, "robot_id", None)
+        if explicit:
+            return str(explicit)
+        robots = getattr(self.env, "robots", ()) or ()
+        if robots:
+            from .robots.resolution import robot_id_from_model
+            try:
+                return robot_id_from_model(getattr(robots[0], 'name', ''))
+            except ValueError:
+                pass
+        return None
+
+    @property
+    def task_id(self) -> str:
+        explicit = getattr(self.env, "task_id", None)
+        if explicit:
+            return str(explicit)
+        name = self.env.__class__.__name__
+        import re
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()
+
+    def get_language_prompt(self) -> dict[str, Any]:
+        """Return the current episode's structured language instruction."""
+        return runtime_language_prompt(self.env)
+
+    _EVENT_COUNTERS = (
+        ("in_box_count", "object_in_box"),
+        ("hits", "hit"),
+        ("counted", "juggle"),
+        ("op", "round"),
+    )
+
+    @property
+    def action_dim(self) -> int:
+        return int(self.env.action_dim)
+
+    @property
+    def sim(self) -> Any:
+        """Expose the simulator for read-only recorders and diagnostics."""
+        sim = getattr(self.env, "sim", None)
+        if sim is not None:
+            return sim
+        if hasattr(self.env, "model") and hasattr(self.env, "data"):
+            return _NativeSimView(self.env)
+        return self.env
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.env, name)
+
+    def reset(self, *args: Any, **kwargs: Any) -> Any:
+        self._counter_snapshot.clear()
+        self._episode_index += 1
+        value = self.env.reset(*args, **kwargs)
+        sim = self.sim
+        model = getattr(sim, 'model', None)
+        if model is not None and hasattr(model, 'ncam'):
+            from .cameras import configure_fixed_cameras, configure_policy_camera
+            configure_policy_camera(self.env)
+            configure_fixed_cameras(self.env)
+        for attr, _ in self._EVENT_COUNTERS:
+            current = getattr(self.env, attr, None)
+            if isinstance(current, (int, float)):
+                self._counter_snapshot[attr] = float(current)
+        self._counter_snapshot["drop_count"] = float(getattr(self.env, "drop_count", 0))
+        prompt = self.get_language_prompt()
+        self.language_prompt = prompt
+        if isinstance(value, tuple) and len(value) == 2 and isinstance(value[1], dict):
+            info = dict(value[1])
+            info["language_prompt"] = prompt["text"]
+            info["language_prompt_structured"] = prompt
+            return self._with_camera_observations(value[0]), info
+        return self._with_camera_observations(value)
+
+    def step(self, action: Any) -> Any:
+        value = normalize_step(self.env.step(action))
+        info = dict(value.info)
+        self.language_prompt = self.get_language_prompt()
+        info["language_prompt"] = self.language_prompt["text"]
+        info["language_prompt_structured"] = self.language_prompt
+        events = list(_as_events(info))
+        for attr, event_name in self._EVENT_COUNTERS:
+            value_now = getattr(self.env, attr, None)
+            if isinstance(value_now, (int, float)):
+                previous = self._counter_snapshot.get(attr, float(value_now))
+                delta = int(max(0, float(value_now) - previous))
+                events.extend([event_name] * delta)
+                self._counter_snapshot[attr] = float(value_now)
+        # Common v1 task fields use ``in`` or a positive score for one-shot
+        # events but did not expose the new ``events`` key.
+        if info.get("in") is True:
+            events.append("in")
+        if isinstance(info.get("score"), (int, float)) and info["score"] > 0:
+            events.append("score")
+        if events:
+            info["events"] = events
+        if getattr(self.env, "drop_count", 0) > self._counter_snapshot.get("drop_count", 0):
+            info.setdefault("failure", {"recoverable": True})
+        self._counter_snapshot["drop_count"] = float(getattr(self.env, "drop_count", 0))
+        if "success_state" not in info:
+            if hasattr(self.env, "_check_success"):
+                info["success_state"] = bool(self.env._check_success())
+            else:
+                info["success_state"] = bool(value.reward > 0)
+        if "success" not in info and "terminal_success" not in info:
+            info["terminal_success"] = bool(info["success_state"] and value.done)
+        sim = getattr(self.env, "sim", None)
+        cfrc = getattr(getattr(sim, "data", None), "cfrc_ext", None)
+        if cfrc is not None:
+            try:
+                info["peak_force_N"] = float(abs(cfrc).max())
+            except (AttributeError, TypeError, ValueError):
+                pass
+        return self._with_camera_observations(value.observation), value.reward, value.terminated, value.truncated, info
+
+    def close(self) -> None:
+        for renderer in self._camera_renderers.values():
+            renderer.close()
+        self._camera_renderers.clear()
+        self.env.close()
+
+    def render(self, *args: Any, **kwargs: Any) -> Any:
+        """Forward interactive rendering to the wrapped robosuite env."""
+
+        viewer = getattr(self.env, "viewer", None)
+        update_fn = getattr(viewer, "update", None)
+        if callable(update_fn):
+            # robosuite's native ``mjviewer`` has a no-op render() method;
+            # update() is the operation that creates / presents the window.
+            return update_fn()
+        render_fn = getattr(self.env, "render", None)
+        if not callable(render_fn):
+            return None
+        return render_fn(*args, **kwargs)
+
+
+def legacy_factory(
+    constructor: Callable[..., Any],
+    *,
+    robot_keyword: str = "robots",
+    default_robot: str | None = None,
+    fixed_kwargs: Mapping[str, Any] | None = None,
+) -> Callable[..., LegacyTaskAdapter]:
+    """Create a factory compatible with :class:`BenchmarkRunner`."""
+
+    fixed_kwargs = dict(fixed_kwargs or {})
+
+    def factory(*, seed: int | None = None, robot_id: str | None = None, **kwargs: Any) -> LegacyTaskAdapter:
+        params = dict(fixed_kwargs)
+        params.update(kwargs)
+        if seed is not None:
+            params.setdefault("seed", seed)
+        if robot_id is not None or default_robot is not None:
+            params.setdefault(robot_keyword, robot_id or default_robot)
+        return LegacyTaskAdapter(constructor(**params))
+
+    return factory
+
+
+def _as_events(info: Mapping[str, Any]) -> list[Any]:
+    events = info.get("events", info.get("event", ()))
+    if events is None:
+        return []
+    if isinstance(events, (str, bytes)):
+        return [events]
+    try:
+        return list(events)
+    except TypeError:
+        return [events]

react_manip/policies/__init__.py

@@ -0,0 +1,5 @@
+"""Policy interfaces and small reference policies."""
+
+from .base import CallablePolicy, Policy, RandomPolicy
+
+__all__ = ["CallablePolicy", "Policy", "RandomPolicy"]

react_manip/policies/base.py

@@ -0,0 +1,79 @@
+"""Policy adapters kept independent from model frameworks."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any, Callable, Mapping
+
+import numpy as np
+
+
+class Policy:
+    """Small base class for model adapters.
+
+    External models may subclass this class or simply expose compatible
+    ``reset`` and ``act`` methods (duck typing is supported by the runner).
+    """
+
+    policy_id = "policy"
+
+    def reset(self, *, seed: int | None = None, task_spec: Any = None) -> None:
+        del seed, task_spec
+
+    def act(self, observation: Any, info: Mapping[str, Any] | None = None) -> Any:
+        raise NotImplementedError
+
+
+class RandomPolicy(Policy):
+    """Reference policy used for smoke tests and legacy comparisons."""
+
+    policy_id = "random"
+
+    def __init__(self, action_dim: int | None = None, seed: int | None = None):
+        self.action_dim = action_dim
+        self.rng = np.random.default_rng(seed)
+
+    def set_action_dim(self, action_dim: int) -> None:
+        self.action_dim = int(action_dim)
+
+    def reset(self, *, seed: int | None = None, task_spec: Any = None) -> None:
+        del task_spec
+        if seed is not None:
+            self.rng = np.random.default_rng(seed)
+
+    def begin_episode(self, *, seed=None, **kwargs):
+        self.reset(seed=seed)
+
+    def end_episode(self, **feedback):
+        pass
+
+    def get_adaptation_state(self):
+        # RandomPolicy has no learned state. Its RNG is reseeded per episode.
+        return None
+
+    def set_adaptation_state(self, state):
+        if state is not None:
+            raise ValueError('RandomPolicy has no adaptation state')
+
+    def act(self, observation: Any, info: Mapping[str, Any] | None = None) -> np.ndarray:
+        del observation, info
+        if self.action_dim is None:
+            raise RuntimeError("RandomPolicy action_dim was not set by the runner")
+        return self.rng.uniform(-1.0, 1.0, size=self.action_dim)
+
+
+class CallablePolicy(Policy):
+    """Wrap a plain callable while supporting one- or two-argument callables."""
+
+    def __init__(self, fn: Callable[..., Any], policy_id: str | None = None):
+        self.fn = fn
+        self.policy_id = policy_id or getattr(fn, "__name__", "callable")
+
+    def act(self, observation: Any, info: Mapping[str, Any] | None = None) -> Any:
+        try:
+            parameters = inspect.signature(self.fn).parameters
+            if len(parameters) >= 2:
+                return self.fn(observation, info)
+        except (TypeError, ValueError):
+            pass
+        return self.fn(observation)

react_manip/rendering.py

@@ -0,0 +1,58 @@
+"""Native RGB rendering with explicit model lifetime and visual-only groups."""
+import mujoco
+
+
+class NativeRGBRenderer:
+    def __init__(self, width=640, height=480, include_collision=False):
+        self.width, self.height = width, height
+        self.include_collision = include_collision
+        self._model = None
+        self._renderer = None
+        self._option = mujoco.MjvOption()
+        self._option.geomgroup[0] = 0
+        self._option.geomgroup[1] = 1
+        self._option.geomgroup[2] = 0
+        if include_collision:
+            self._option.geomgroup[0] = 1
+
+    def render(self, sim, camera):
+        """Render robosuite ``MjSim`` and native MuJoCo task objects."""
+        model_wrapper = getattr(sim, "model", sim)
+        data_wrapper = getattr(sim, "data", sim)
+        model = getattr(model_wrapper, "_model", model_wrapper)
+        data = getattr(data_wrapper, "_data", data_wrapper)
+        # ``LegacyTaskAdapter`` exposes native tasks through _NativeSimView,
+        # whose model/data wrappers are deliberately compatible with
+        # robosuite.  Check the explicit marker as well as the direct raw
+        # model case; otherwise the visual-only group filter hides native
+        # scenes that keep their only geometry in collision group 0.
+        native_mujoco = bool(getattr(sim, "native_mujoco", False)) or model_wrapper is model
+        # Robosuite tasks use group 1 for their visual geometry and keep
+        # collision-only geoms in group 0. Imported native scenes generally
+        # put their only geometry in group 0, so hiding it yields a blank UI.
+        self._option.geomgroup[0] = int(native_mujoco or self.include_collision)
+        if model is not self._model:
+            self.close()
+            model.vis.global_.offwidth = max(model.vis.global_.offwidth, self.width)
+            model.vis.global_.offheight = max(model.vis.global_.offheight, self.height)
+            self._renderer = mujoco.Renderer(model, height=self.height, width=self.width)
+            self._model = model
+        camera_arg = camera
+        if camera == '__free__':
+            free = mujoco.MjvCamera()
+            free.type = mujoco.mjtCamera.mjCAMERA_FREE
+            free.lookat[:] = model.stat.center
+            free.distance = max(0.5, 2.2 * float(model.stat.extent))
+            free.azimuth, free.elevation = 38, -25
+            camera_arg = free
+        elif isinstance(camera, str) and mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_CAMERA, camera) < 0:
+            raise ValueError(f'Unknown camera: {camera}')
+        self._renderer.update_scene(data, camera=camera_arg, scene_option=self._option)
+        # Native Renderer already returns top-down RGB (no [::-1]).
+        return self._renderer.render()
+
+    def close(self):
+        if self._renderer is not None:
+            self._renderer.close()
+        self._renderer = None
+        self._model = None

react_manip/robot_registry.py

@@ -0,0 +1,31 @@
+"""Default robot metadata registrations.
+
+Calling ``register_default_robots`` is optional.  It is deliberately separate
+from imports of robosuite so registry tooling also works in a lightweight
+development environment.
+"""
+
+from __future__ import annotations
+
+from .core.registry import get_robot_registry
+from .robots.adapters import RobosuiteRobotAdapter
+from .robots.agilex_adapter import AgileXAdapter
+
+
+ROBOSUITE_NAMES = (
+    "Panda", "UR5e", "XArm7", "Kinova3", "IIWA", "Sawyer", "Jaco", "Tiago",
+    "SpotWithArm", "Baxter", "GR1ArmsOnly", "PandaOmron",
+)
+
+
+def register_default_robots(*, replace: bool = False) -> None:
+    from integrations.rpent_embodiments import register
+    register()
+    registry = get_robot_registry()
+    for name in ROBOSUITE_NAMES:
+        key = name.lower()
+        if key not in {item[0] for item in registry.list()} or replace:
+            registry.register(key, RobosuiteRobotAdapter(name), replace=replace)
+    for robot_id in ("piperx", "dual_piperx", "mobile_dual_piperx", "legacy_piperx", "aloha", "aloha_mobile"):
+        if robot_id not in {item[0] for item in registry.list()} or replace:
+            registry.register(robot_id, AgileXAdapter(robot_id), replace=replace)

react_manip/robots/__init__.py

@@ -0,0 +1,33 @@
+"""Robot embodiment specifications and adapters.
+
+The default PiPER-X family is downloaded and generated by
+``scripts/build_agilex_assets.py``. Generic model-backed legacy adapters remain
+for explicit external assets; the built-in registry uses AgileXAdapter.
+"""
+
+from .base import RobotAdapter, RobotSpec
+from .agilex_adapter import AgileXAdapter
+from .adapters import AlohaAdapter, PiperXAdapter, RobosuiteRobotAdapter
+from .catalog import ALL_ROBOT_IDS, SINGLE_ARM_ROBOT_IDS, normalize_robot_id
+from .resolution import (RobosuiteResolution, resolve_robosuite_robot,
+                         register_robosuite_robot, registered_robot_ids)
+from .sensors import MountedCamera, SensorProfile, register_sensor_profile
+
+__all__ = [
+    "AgileXAdapter",
+    "AlohaAdapter",
+    "PiperXAdapter",
+    "RobotAdapter",
+    "RobotSpec",
+    "RobosuiteRobotAdapter",
+    "ALL_ROBOT_IDS",
+    "SINGLE_ARM_ROBOT_IDS",
+    "normalize_robot_id",
+    "RobosuiteResolution",
+    "resolve_robosuite_robot",
+    "register_robosuite_robot",
+    "registered_robot_ids",
+    "SensorProfile",
+    "MountedCamera",
+    "register_sensor_profile",
+]