armnet-runtime 0.3.1__tar.gz → 0.3.2__tar.gz

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: armnet-runtime
-Version: 0.3.1
+Version: 0.3.2
 Summary: armnet runtime SDK — used by code running inside customer containers on a cell.
 Project-URL: Homepage, https://armnet.dev
 Project-URL: Documentation, https://docs.armnet.dev/packages/runtime/
@@ -8,7 +8,7 @@ Author: Ville Kuosmanen
 License-Expression: Apache-2.0
 License-File: LICENSE
 Requires-Python: <3.13,>=3.12
-Requires-Dist: armnet-core>=0.3.1
+Requires-Dist: armnet-core>=0.3.2
 Requires-Dist: protobuf<7,>=5
 Requires-Dist: pydantic<3,>=2.6
 Provides-Extra: dev

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "armnet-runtime"
 # 0.2.0 follows armnet-core: ctx.cell now carries an environment and hands
 # reset/scoring to it, and CompletionStatus moved to armnet-core.
-version = "0.3.1"
+version = "0.3.2"
 description = "armnet runtime SDK \u2014 used by code running inside customer containers on a cell."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"
@@ -15,7 +15,7 @@ license-files = ["LICENSE"]
 authors = [{ name = "Ville Kuosmanen" }]
 
 dependencies = [
-    "armnet-core>=0.3.1",
+    "armnet-core>=0.3.2",
     "pydantic>=2.6,<3",
     # Wire format for Rerun visualization packets (armnet_runtime.rerun).
     "protobuf>=5,<7",

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/src/armnet_runtime/__init__.py

@@ -37,6 +37,7 @@ from armnet_core import (
 
 from armnet_runtime.context import (
     BIMANUAL_SO101_EMBODIMENT,
+    BIMANUAL_YAM_EMBODIMENT,
     SO101_EMBODIMENT,
     Cell,
     CompletionStatus,
@@ -45,6 +46,8 @@ from armnet_runtime.context import (
     RuntimeCameraMount,
     RuntimeLightbox,
     RuntimeRail,
+    require_eval_embodiment,
+    require_bimanual_yam_embodiment,
     require_so101_embodiment,
 )
 from armnet_runtime.decorator import MainRegistrationError, main
@@ -57,6 +60,7 @@ from armnet_runtime.variation import (
 
 __all__ = [
     "BIMANUAL_SO101_EMBODIMENT",
+    "BIMANUAL_YAM_EMBODIMENT",
     "SO101_EMBODIMENT",
     "Cell",
     "CompletionStatus",
@@ -65,6 +69,8 @@ __all__ = [
     "NothingToVary",
     "Scenario",
     "sample_scenario",
+    "require_eval_embodiment",
+    "require_bimanual_yam_embodiment",
     "require_so101_embodiment",
     "Embodiment",
     "Job",

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/src/armnet_runtime/context.py

@@ -22,6 +22,7 @@ from typing import Any, Iterable, Mapping, Optional
 from urllib.parse import urlparse
 
 from armnet_core import (
+    BIMANUAL_YAM_EMBODIMENT,
     CellDeviceConfig,
     CompletionStatus,
     Embodiment,
@@ -29,6 +30,7 @@ from armnet_core import (
     InstrumentedCell,
     Reading,
     RobotCellConfig,
+    SceneCalibration,
     Task,
     environment_for,
 )
@@ -322,6 +324,9 @@ class Cell:
     immovable.
     """
 
+    scene_calibration: Optional[SceneCalibration] = None
+    """Manipulation-area snapshot selected when this cell process started."""
+
     device_config: Optional[CellDeviceConfig] = None
     """What this cell may vary and within what bounds.
 
@@ -896,8 +901,17 @@ class Cell:
         if not confirm:
             return
 
-        # 2. Operator confirmation on the cell-served operator-call endpoint
-        # (fallback to the dev local-control endpoint).
+        self.confirm_scene_reset()
+
+    def confirm_scene_reset(self) -> None:
+        """Wait for operator scene staging without moving the robot first.
+
+        Most callers should use :meth:`reset`, which returns the robot to rest
+        before requesting confirmation. A runtime that deliberately starts
+        from a non-rest pose can call ``reset(confirm=False)``, move to that
+        pose, then call this method so the operator stages objects around the
+        robot's actual rollout start configuration.
+        """
         request = {"op": "reset", "request": {"kind": "manual"}}
         operator_endpoint = self.operator_call_endpoint or self.local_control_endpoint
         if operator_endpoint:
@@ -1595,6 +1609,13 @@ class Context:
 SO101_EMBODIMENT = "lerobot/so-101"
 BIMANUAL_SO101_EMBODIMENT = "lerobot/bimanual_so101"
 
+_EVAL_EMBODIMENTS = (
+    SO101_EMBODIMENT,
+    BIMANUAL_SO101_EMBODIMENT,
+    BIMANUAL_YAM_EMBODIMENT,
+)
+_BIMANUAL_EVAL_EMBODIMENTS = (BIMANUAL_SO101_EMBODIMENT, BIMANUAL_YAM_EMBODIMENT)
+
 
 def require_so101_embodiment(ctx: "Context", runtime_name: str) -> bool:
     """Validate the job's embodiment is a (single or bimanual) SO-101.
@@ -1624,6 +1645,52 @@ def require_so101_embodiment(ctx: "Context", runtime_name: str) -> bool:
     return expect_bimanual
 
 
+def require_eval_embodiment(ctx: "Context", runtime_name: str) -> None:
+    """Validate the job's embodiment is one LeRobot eval can drive.
+
+    Accepts single SO-101, bimanual SO-101, and bimanual YAM. Both bimanual
+    types must land on a cell wired with left and right arms.
+
+    Raises :class:`NotImplementedError` for any other embodiment, and
+    :class:`RuntimeError` if the embodiment's arm count disagrees with the
+    cell's actual wiring.
+    """
+    if ctx.embodiment not in _EVAL_EMBODIMENTS:
+        supported = ", ".join(repr(name) for name in _EVAL_EMBODIMENTS)
+        raise NotImplementedError(
+            f"{runtime_name} supports {supported}, got {ctx.embodiment!r}"
+        )
+    expect_bimanual = ctx.embodiment in _BIMANUAL_EVAL_EMBODIMENTS
+    if expect_bimanual != ctx.cell.is_bimanual:
+        raise RuntimeError(
+            f"embodiment {ctx.embodiment!r} expects "
+            f"{'two arms (left+right)' if expect_bimanual else 'a single arm'}, "
+            f"but the cell exposes arms={sorted(ctx.cell.arms)}"
+        )
+
+
+def require_bimanual_yam_embodiment(ctx: "Context", runtime_name: str) -> None:
+    """Validate the job targets the bimanual YAM cell exactly.
+
+    Requires ``ctx.embodiment`` to be :data:`BIMANUAL_YAM_EMBODIMENT` and the
+    cell to expose exactly ``left`` and ``right`` arms — no other embodiment or
+    arm layout is accepted.
+
+    Raises :class:`NotImplementedError` for any other embodiment, and
+    :class:`RuntimeError` if the cell's arms are not exactly left and right.
+    """
+    if ctx.embodiment != BIMANUAL_YAM_EMBODIMENT:
+        raise NotImplementedError(
+            f"{runtime_name} supports {BIMANUAL_YAM_EMBODIMENT!r}, "
+            f"got {ctx.embodiment!r}"
+        )
+    if set(ctx.cell.arms) != {"left", "right"}:
+        raise RuntimeError(
+            f"embodiment {ctx.embodiment!r} expects arms left and right exactly, "
+            f"but the cell exposes arms={sorted(ctx.cell.arms)}"
+        )
+
+
 def build_context() -> Context:
     """Read the cell-injected env vars and construct a :class:`Context`.
 
@@ -1698,6 +1765,9 @@ def build_context() -> Context:
             rails=_build_runtime_rails(cell_config, args),
             lightbox=_build_runtime_lightbox(cell_config),
             camera_mounts=_build_runtime_camera_mounts(cell_config),
+            scene_calibration=(
+                cell_config.scene_calibration if cell_config else None
+            ),
             device_config=(
                 CellDeviceConfig.from_cell_config(cell_config) if cell_config else None
             ),

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/src/armnet_runtime/leaderboard.py

@@ -31,7 +31,7 @@ from typing import Optional
 logger = logging.getLogger(__name__)
 
 # Shared with demo_space/leaderboard.py — the demo reads from the same dataset.
-LEADERBOARD_REPO = "villekuosmanen/armnet-demo-leaderboard"
+LEADERBOARD_REPO = "armnet/armnet-demo-leaderboard"
 RUNS_FILE = "runs.jsonl"
 
 

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/src/armnet_runtime/lerobot/__init__.py

@@ -4,5 +4,12 @@ from armnet_runtime.lerobot.import_swap import install_lerobot_remote_mode
 from armnet_runtime.lerobot.remote_arx5 import RemoteARX5Arm
 from armnet_runtime.lerobot.remote_camera import RemoteOpenCVCamera
 from armnet_runtime.lerobot.remote_feetech import RemoteFeetechMotorsBus
+from armnet_runtime.lerobot.remote_yam import RemoteYAMFollower
 
-__all__ = ["RemoteARX5Arm", "RemoteFeetechMotorsBus", "RemoteOpenCVCamera", "install_lerobot_remote_mode"]
+__all__ = [
+    "RemoteARX5Arm",
+    "RemoteFeetechMotorsBus",
+    "RemoteOpenCVCamera",
+    "RemoteYAMFollower",
+    "install_lerobot_remote_mode",
+]

{armnet_runtime-0.3.1 → armnet_runtime-0.3.2}/src/armnet_runtime/lerobot/import_swap.py

@@ -10,6 +10,7 @@ from armnet_core import env as env_keys
 from armnet_runtime.lerobot.remote_camera import RemoteOpenCVCamera
 from armnet_runtime.lerobot.remote_arx5 import RemoteARX5Arm
 from armnet_runtime.lerobot.remote_feetech import RemoteFeetechMotorsBus
+from armnet_runtime.lerobot.remote_yam import RemoteYAMFollower
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +26,10 @@ _ARX5_MODULE_CANDIDATES = [
     "arx_common",
     "arx_common.arm",
 ]
+_YAM_MODULE_CANDIDATES = [
+    "lerobot_robot_yam",
+    "lerobot_robot_yam.yam_follower",
+]
 
 
 _feetech_is_remote = False
@@ -88,13 +93,26 @@ def install_lerobot_remote_mode() -> None:
             setattr(module, "ARX5Arm", RemoteARX5Arm)
             patched.append(f"{module_name}.ARX5Arm")
 
+    for module_name in _YAM_MODULE_CANDIDATES:
+        try:
+            module = importlib.import_module(module_name)
+        except ImportError:
+            continue
+        for attr in ("YAMFollower", "YAMFollowerRobot"):
+            if hasattr(module, attr):
+                setattr(module, attr, RemoteYAMFollower)
+                patched.append(f"{module_name}.{attr}")
+
     if patched:
         global _feetech_is_remote
         _feetech_is_remote = any(attr.endswith("FeetechMotorsBus") for attr in patched)
         logger.info("installed armnet LeRobot remote mode: patched %s", patched)
     else:
         logger.warning(
-            "LeRobot is installed, but no known Feetech bus, OpenCV camera, or ARX5 arm class was found to patch; "
+            "LeRobot is installed, but no known Feetech bus, OpenCV camera, ARX5 arm, or YAM follower class was found to patch; "
             "remote robot access may fail. Checked: %s",
-            _FEETECH_MODULE_CANDIDATES + _OPENCV_CAMERA_MODULE_CANDIDATES + _ARX5_MODULE_CANDIDATES,
+            _FEETECH_MODULE_CANDIDATES
+            + _OPENCV_CAMERA_MODULE_CANDIDATES
+            + _ARX5_MODULE_CANDIDATES
+            + _YAM_MODULE_CANDIDATES,
         )

armnet_runtime-0.3.2/src/armnet_runtime/lerobot/remote_yam.py

@@ -0,0 +1,319 @@
+"""Remote YAM follower used inside customer containers.
+
+Device-specific code only. Wire-protocol plumbing lives in
+:mod:`armnet_runtime.lerobot._remote_protocol`. This module does not import
+LeRobot or yam_common at module import time.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from armnet_runtime.lerobot._remote_protocol import (
+    IS_CONNECTED_TTL_S,
+    PersistentConnection,
+    RemoteAttributeError,
+    RemoteContextManager,
+    check_response,
+    decode,
+    jsonable,
+)
+from armnet_runtime.lerobot.remote_camera import RemoteOpenCVCamera
+
+__all__ = ["RemoteYAMFollower"]
+
+logger = logging.getLogger(__name__)
+
+ACTION_KEYS = (
+    "shoulder_pan.pos",
+    "shoulder_lift.pos",
+    "elbow_flex.pos",
+    "wrist_flex.pos",
+    "wrist_roll.pos",
+    "wrist_yaw.pos",
+    "gripper.pos",
+)
+
+
+class RemoteYAMFollower:
+    """LeRobot YAM follower replacement that keeps cameras on separate proxies."""
+
+    name = "yam_follower"
+
+    def __init__(self, config: Any, *args: Any, **kwargs: Any) -> None:
+        port = getattr(config, "port", None) or kwargs.get("port")
+        if not isinstance(port, str):
+            raise RuntimeError("RemoteYAMFollower requires config.port with ?arm=left or ?arm=right")
+        object.__setattr__(self, "_config", config)
+        object.__setattr__(self, "_socket_path", port)
+        object.__setattr__(self, "_arm_name", _arm_from_port(port))
+        object.__setattr__(self, "_object_id", None)
+        object.__setattr__(self, "_method_cache", set())
+        object.__setattr__(self, "_missing_cache", set())
+        object.__setattr__(self, "_connected", None)
+        object.__setattr__(self, "_connected_at", 0.0)
+        object.__setattr__(self, "_conn", PersistentConnection(self._socket_path))
+        object.__setattr__(self, "cameras", {})
+        object.__setattr__(
+            self,
+            "_object_id",
+            self._request(
+                {
+                    "op": "create",
+                    "class": "YAMFollower",
+                    "arm": self._arm_name,
+                }
+            )["object_id"],
+        )
+        try:
+            cameras: dict[str, RemoteOpenCVCamera] = {}
+            for name, cam_cfg in (getattr(config, "cameras", None) or {}).items():
+                cameras[str(name)] = RemoteOpenCVCamera(cam_cfg)
+            object.__setattr__(self, "cameras", cameras)
+        except Exception:
+            try:
+                self.disconnect()
+            except Exception:
+                pass
+            object.__setattr__(self, "_object_id", None)
+            raise
+
+    @property
+    def is_calibrated(self) -> bool:
+        return True
+
+    @property
+    def observation_features(self) -> dict[str, Any]:
+        features: dict[str, Any] = {key: float for key in ACTION_KEYS}
+        for name, cam_cfg in (getattr(self._config, "cameras", None) or {}).items():
+            height = getattr(cam_cfg, "height", None)
+            width = getattr(cam_cfg, "width", None)
+            if isinstance(cam_cfg, dict):
+                height = cam_cfg.get("height", height)
+                width = cam_cfg.get("width", width)
+            features[str(name)] = (height, width, 3)
+        return features
+
+    @property
+    def action_features(self) -> dict[str, type]:
+        return {key: float for key in ACTION_KEYS}
+
+    @property
+    def is_connected(self) -> bool:
+        arm = self._arm_connected()
+        cameras_ok = all(getattr(cam, "is_connected", True) for cam in self.cameras.values())
+        return bool(arm) and cameras_ok
+
+    def connect(self, calibrate: bool = True) -> None:  # noqa: ARG002
+        self._method_proxy("connect")()
+        try:
+            for cam in self.cameras.values():
+                cam.connect()
+        except Exception:
+            for cam in self.cameras.values():
+                try:
+                    cam.disconnect()
+                except Exception:
+                    pass
+            try:
+                self._method_proxy("emergency_cleanup")()
+            except Exception:
+                try:
+                    self._method_proxy("disconnect")()
+                except Exception:
+                    pass
+            object.__setattr__(self, "_connected", False)
+            raise
+        self._set_connected(True)
+
+    def disconnect(self) -> None:
+        for cam in self.cameras.values():
+            try:
+                cam.disconnect()
+            except Exception:
+                pass
+        try:
+            self._method_proxy("disconnect")()
+        except Exception:
+            pass
+        self._set_connected(False)
+
+    def get_observation(self) -> dict[str, Any]:
+        obs = dict(self._method_proxy("get_observation")() or {})
+        for name, cam in self.cameras.items():
+            obs[name] = cam.async_read()
+        return obs
+
+    def send_action(self, action: Any) -> Any:
+        return self._method_proxy("send_action")(action)
+
+    @property
+    def robot_type(self) -> str:
+        return str(getattr(self._config, "robot_type", None) or self.name)
+
+    @property
+    def config(self) -> Any:
+        return self._config
+
+    @property
+    def id(self) -> Any:
+        return getattr(self._config, "id", None)
+
+    @property
+    def calibration_dir(self) -> Any:
+        return getattr(self._config, "calibration_dir", None)
+
+    def calibrate(self) -> None:
+        return None
+
+    def configure(self) -> None:
+        return None
+
+    def close(self) -> None:
+        self.disconnect()
+
+    def zero_torque_mode(self) -> None:
+        return self._method_proxy("zero_torque_mode")()
+
+    def get_observations(self) -> Any:
+        return self._method_proxy("get_observations")()
+
+    def get_joint_pos(self) -> Any:
+        return self._method_proxy("get_joint_pos")()
+
+    def command_joint_pos(self, joint_pos: Any) -> Any:
+        return self._method_proxy("command_joint_pos")(joint_pos)
+
+    def __enter__(self) -> "RemoteYAMFollower":
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:  # noqa: ANN001
+        self.disconnect()
+        return False
+
+    def _set_connected(self, value: bool) -> None:
+        object.__setattr__(self, "_connected", value)
+        object.__setattr__(self, "_connected_at", time.monotonic())
+
+    def _arm_connected(self) -> bool:
+        if (
+            self._connected is not None
+            and (time.monotonic() - self._connected_at) < IS_CONNECTED_TTL_S
+        ):
+            return bool(self._connected)
+        try:
+            response = self._request(
+                {"op": "getattr", "object_id": self._object_id, "name": "is_connected"}
+            )
+            value = bool(decode(response.get("value")))
+            self._set_connected(value)
+            return value
+        except Exception as exc:
+            self._mark_disconnected_if_stale(exc)
+            if _is_unknown_object_error(exc):
+                return False
+            return bool(self._connected)
+
+    def __del__(self) -> None:
+        try:
+            object_id = object.__getattribute__(self, "_object_id")
+            conn = object.__getattribute__(self, "_conn")
+        except AttributeError:
+            return
+        if object_id:
+            try:
+                self.disconnect()
+            except Exception:
+                pass
+        if conn is not None:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        if name in self._method_cache:
+            return self._method_proxy(name)
+        if name in self._missing_cache:
+            raise AttributeError(name)
+        try:
+            response = self._request(
+                {"op": "getattr", "object_id": self._object_id, "name": name}
+            )
+            if response.get("callable"):
+                self._method_cache.add(name)
+                return self._method_proxy(name)
+            value = decode(response["value"])
+            if name == "is_connected":
+                self._set_connected(bool(value))
+            return value
+        except RemoteAttributeError:
+            self._missing_cache.add(name)
+            raise
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name.startswith("_") or name == "cameras":
+            object.__setattr__(self, name, value)
+            return
+        self._request(
+            {
+                "op": "setattr",
+                "object_id": self._object_id,
+                "name": name,
+                "value": jsonable(value),
+            }
+        )
+
+    def _method_proxy(self, name: str):
+        def method(*args: Any, **kwargs: Any) -> Any:
+            response = self._request(
+                {
+                    "op": "call",
+                    "object_id": self._object_id,
+                    "method": name,
+                    "args": jsonable(args),
+                    "kwargs": jsonable(kwargs),
+                }
+            )
+            if name == "connect":
+                self._set_connected(True)
+            elif name in {"disconnect", "emergency_cleanup", "close"}:
+                self._set_connected(False)
+            if response.get("context_manager"):
+                return RemoteContextManager(
+                    conn=self._conn,
+                    object_id=response["object_id"],
+                )
+            return decode(response.get("value"))
+
+        return method
+
+    def _request(self, payload: dict[str, Any]) -> dict[str, Any]:
+        logger.debug("YAM request op=%r path=%r", payload.get("op"), self._socket_path)
+        try:
+            return check_response(self._conn.request(payload), error_message="remote YAM call failed")
+        except Exception as exc:
+            self._mark_disconnected_if_stale(exc)
+            raise
+
+    def _mark_disconnected_if_stale(self, exc: BaseException) -> None:
+        if _is_unknown_object_error(exc):
+            self._set_connected(False)
+
+
+def _is_unknown_object_error(exc: BaseException) -> bool:
+    return "unknown connector object" in str(exc).lower()
+
+
+def _arm_from_port(port: str) -> str:
+    parsed = urlparse(port)
+    arms = parse_qs(parsed.query).get("arm")
+    if not arms:
+        raise ValueError("RemoteYAMFollower requires ?arm=left or ?arm=right on config.port")
+    return str(arms[0])