Potential noise injection for data recording: DART

.github/workflows/full_tests.yml

@@ -101,11 +101,9 @@ jobs:
     runs-on:
       group: aws-general-8-plus
     if: |
-      github.repository == 'huggingface/lerobot' && (
-        (github.event_name == 'pull_request_review' && github.event.review.state == 'approved' && github.event.pull_request.head.repo.fork == false) ||
-        github.event_name == 'push' ||
-        github.event_name == 'workflow_dispatch'
-      )
+      (github.event_name == 'pull_request_review' && github.event.review.state == 'approved' && github.event.pull_request.head.repo.fork == false) ||
+      github.event_name == 'push' ||
+      github.event_name == 'workflow_dispatch'
     outputs:
       image_tag: ${{ steps.set_tag.outputs.image_tag }}
     env:

.github/workflows/unbound_deps_tests.yml

@@ -91,7 +91,6 @@ jobs:
     name: Build and Push Docker
     runs-on:
       group: aws-general-8-plus
-    if: github.repository == 'huggingface/lerobot'
     outputs:
       image_tag: ${{ env.DOCKER_IMAGE_NAME }}
     env:

docs/source/installation.mdx

@@ -1,15 +1,13 @@
 # Installation
 
-This guide uses conda (via miniforge) to manage environments. If you prefer another environment manager (e.g. `uv`, `venv`), ensure you have Python >=3.10 and ffmpeg installed with the `libsvtav1` encoder, then skip ahead to [Install LeRobot](#step-3-install-lerobot-).
-
-## Step 1: Install [`miniforge`](https://conda-forge.org/download/)
+## Install [`miniforge`](https://conda-forge.org/download/)
 
 ```bash
 wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
 bash Miniforge3-$(uname)-$(uname -m).sh
 ```
 
-## Step 2: Environment Setup
+## Environment Setup
 
 Create a virtual environment with Python 3.10, using conda:
 
@@ -40,7 +38,7 @@ conda install ffmpeg -c conda-forge
 >
 > - _[On Linux only]_ If you want to bring your own ffmpeg: Install [ffmpeg build dependencies](https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu#GettheDependencies) and [compile ffmpeg from source with libsvtav1](https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu#libsvtav1), and make sure you use the corresponding ffmpeg binary to your install with `which ffmpeg`.
 
-## Step 3: Install LeRobot 🤗
+## Install LeRobot 🤗
 
 ### From Source
 

pyproject.toml

@@ -360,9 +360,9 @@ ignore_errors = false
 module = "lerobot.cameras.*"
 ignore_errors = false
 
-[[tool.mypy.overrides]]
-module = "lerobot.motors.*"
-ignore_errors = false
+# [[tool.mypy.overrides]]
+# module = "lerobot.motors.*"
+# ignore_errors = false
 
 # [[tool.mypy.overrides]]
 # module = "lerobot.robots.*"

src/lerobot/cameras/__init__.py

@@ -13,5 +13,5 @@
 # limitations under the License.
 
 from .camera import Camera
-from .configs import CameraConfig, ColorMode, Cv2Backends, Cv2Rotation
+from .configs import CameraConfig, ColorMode, Cv2Rotation
 from .utils import make_cameras_from_configs

src/lerobot/cameras/configs.py

@@ -25,10 +25,6 @@ class ColorMode(str, Enum):
     RGB = "rgb"
     BGR = "bgr"
 
-    @classmethod
-    def _missing_(cls, value: object) -> None:
-        raise ValueError(f"`color_mode` is expected to be in {list(cls)}, but {value} is provided.")
-
 
 class Cv2Rotation(int, Enum):
     NO_ROTATION = 0
@@ -36,25 +32,6 @@ class Cv2Rotation(int, Enum):
     ROTATE_180 = 180
     ROTATE_270 = -90
 
-    @classmethod
-    def _missing_(cls, value: object) -> None:
-        raise ValueError(f"`rotation` is expected to be in {list(cls)}, but {value} is provided.")
-
-
-# Subset from https://docs.opencv.org/3.4/d4/d15/group__videoio__flags__base.html
-class Cv2Backends(int, Enum):
-    ANY = 0
-    V4L2 = 200
-    DSHOW = 700
-    PVAPI = 800
-    ANDROID = 1000
-    AVFOUNDATION = 1200
-    MSMF = 1400
-
-    @classmethod
-    def _missing_(cls, value: object) -> None:
-        raise ValueError(f"`backend` is expected to be in {list(cls)}, but {value} is provided.")
-
 
 @dataclass(kw_only=True)
 class CameraConfig(draccus.ChoiceRegistry, abc.ABC):  # type: ignore  # TODO: add type stubs for draccus

src/lerobot/cameras/opencv/camera_opencv.py

@@ -32,11 +32,10 @@ if platform.system() == "Windows" and "OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"
     os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
 import cv2  # type: ignore  # TODO: add type stubs for OpenCV
 
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
-from lerobot.utils.errors import DeviceNotConnectedError
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 from ..camera import Camera
-from ..utils import get_cv2_rotation
+from ..utils import get_cv2_backend, get_cv2_rotation
 from .configuration_opencv import ColorMode, OpenCVCameraConfig
 
 # NOTE(Steven): The maximum opencv device index depends on your operating system. For instance,
@@ -118,7 +117,7 @@ class OpenCVCamera(Camera):
         self.new_frame_event: Event = Event()
 
         self.rotation: int | None = get_cv2_rotation(config.rotation)
-        self.backend: int = config.backend
+        self.backend: int = get_cv2_backend()
 
         if self.height and self.width:
             self.capture_width, self.capture_height = self.width, self.height
@@ -133,7 +132,6 @@ class OpenCVCamera(Camera):
         """Checks if the camera is currently connected and opened."""
         return isinstance(self.videocapture, cv2.VideoCapture) and self.videocapture.isOpened()
 
-    @check_if_already_connected
     def connect(self, warmup: bool = True) -> None:
         """
         Connects to the OpenCV camera specified in the configuration.
@@ -150,6 +148,8 @@ class OpenCVCamera(Camera):
             ConnectionError: If the specified camera index/path is not found or fails to open.
             RuntimeError: If the camera opens but fails to apply requested settings.
         """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} is already connected.")
 
         # Use 1 thread for OpenCV operations to avoid potential conflicts or
         # blocking in multi-threaded applications, especially during data collection.
@@ -178,7 +178,6 @@ class OpenCVCamera(Camera):
 
         logger.info(f"{self} connected.")
 
-    @check_if_not_connected
     def _configure_capture_settings(self) -> None:
         """
         Applies the specified FOURCC, FPS, width, and height settings to the connected camera.
@@ -198,6 +197,8 @@ class OpenCVCamera(Camera):
                           to the requested value.
             DeviceNotConnectedError: If the camera is not connected.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"Cannot configure settings for {self} as it is not connected.")
 
         # Set FOURCC first (if specified) as it can affect available FPS/resolution options
         if self.config.fourcc is not None:
@@ -347,7 +348,6 @@ class OpenCVCamera(Camera):
 
         return frame
 
-    @check_if_not_connected
     def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
         """
         Reads a single frame synchronously from the camera.
@@ -374,6 +374,9 @@ class OpenCVCamera(Camera):
                 f"{self} read() color_mode parameter is deprecated and will be removed in future versions."
             )
 
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
 
@@ -487,7 +490,6 @@ class OpenCVCamera(Camera):
             self.latest_timestamp = None
             self.new_frame_event.clear()
 
-    @check_if_not_connected
     def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
         """
         Reads the latest available frame asynchronously.
@@ -510,6 +512,8 @@ class OpenCVCamera(Camera):
             TimeoutError: If no frame becomes available within the specified timeout.
             RuntimeError: If an unexpected error occurs.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
@@ -529,7 +533,6 @@ class OpenCVCamera(Camera):
 
         return frame
 
-    @check_if_not_connected
     def read_latest(self, max_age_ms: int = 1000) -> NDArray[Any]:
         """Return the most recent frame captured immediately (Peeking).
 
@@ -545,6 +548,8 @@ class OpenCVCamera(Camera):
             DeviceNotConnectedError: If the camera is not connected.
             RuntimeError: If the camera is connected but has not captured any frames yet.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")

src/lerobot/cameras/opencv/configuration_opencv.py

@@ -15,9 +15,9 @@
 from dataclasses import dataclass
 from pathlib import Path
 
-from ..configs import CameraConfig, ColorMode, Cv2Backends, Cv2Rotation
+from ..configs import CameraConfig, ColorMode, Cv2Rotation
 
-__all__ = ["OpenCVCameraConfig", "ColorMode", "Cv2Rotation", "Cv2Backends"]
+__all__ = ["OpenCVCameraConfig", "ColorMode", "Cv2Rotation"]
 
 
 @CameraConfig.register_subclass("opencv")
@@ -50,7 +50,6 @@ class OpenCVCameraConfig(CameraConfig):
         rotation: Image rotation setting (0°, 90°, 180°, or 270°). Defaults to no rotation.
         warmup_s: Time reading frames before returning from connect (in seconds)
         fourcc: FOURCC code for video format (e.g., "MJPG", "YUYV", "I420"). Defaults to None (auto-detect).
-        backend: OpenCV backend identifier (https://docs.opencv.org/3.4/d4/d15/group__videoio__flags__base.html). Defaults to ANY.
 
     Note:
         - Only 3-channel color output (RGB/BGR) is currently supported.
@@ -63,12 +62,22 @@ class OpenCVCameraConfig(CameraConfig):
     rotation: Cv2Rotation = Cv2Rotation.NO_ROTATION
     warmup_s: int = 1
     fourcc: str | None = None
-    backend: Cv2Backends = Cv2Backends.ANY
 
     def __post_init__(self) -> None:
-        self.color_mode = ColorMode(self.color_mode)
-        self.rotation = Cv2Rotation(self.rotation)
-        self.backend = Cv2Backends(self.backend)
+        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+            raise ValueError(
+                f"`color_mode` is expected to be {ColorMode.RGB.value} or {ColorMode.BGR.value}, but {self.color_mode} is provided."
+            )
+
+        if self.rotation not in (
+            Cv2Rotation.NO_ROTATION,
+            Cv2Rotation.ROTATE_90,
+            Cv2Rotation.ROTATE_180,
+            Cv2Rotation.ROTATE_270,
+        ):
+            raise ValueError(
+                f"`rotation` is expected to be in {(Cv2Rotation.NO_ROTATION, Cv2Rotation.ROTATE_90, Cv2Rotation.ROTATE_180, Cv2Rotation.ROTATE_270)}, but {self.rotation} is provided."
+            )
 
         if self.fourcc is not None and (not isinstance(self.fourcc, str) or len(self.fourcc) != 4):
             raise ValueError(

src/lerobot/cameras/reachy2_camera/configuration_reachy2_camera.py

@@ -74,4 +74,7 @@ class Reachy2CameraConfig(CameraConfig):
                 f"`image_type` is expected to be 'left' or 'right' for teleop camera, and 'rgb' or 'depth' for depth camera, but {self.image_type} is provided."
             )
 
-        self.color_mode = ColorMode(self.color_mode)
+        if self.color_mode not in ["rgb", "bgr"]:
+            raise ValueError(
+                f"`color_mode` is expected to be 'rgb' or 'bgr', but {self.color_mode} is provided."
+            )

src/lerobot/cameras/reachy2_camera/reachy2_camera.py

@@ -32,7 +32,6 @@ if platform.system() == "Windows" and "OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"
 import cv2  # type: ignore  # TODO: add type stubs for OpenCV
 import numpy as np  # type: ignore  # TODO: add type stubs for numpy
 
-from lerobot.utils.decorators import check_if_not_connected
 from lerobot.utils.import_utils import _reachy2_sdk_available
 
 if TYPE_CHECKING or _reachy2_sdk_available:
@@ -124,7 +123,6 @@ class Reachy2Camera(Camera):
         """
         raise NotImplementedError("Camera detection is not implemented for Reachy2 cameras.")
 
-    @check_if_not_connected
     def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
         """
         Reads a single frame synchronously from the camera.
@@ -138,6 +136,9 @@ class Reachy2Camera(Camera):
         """
         start_time = time.perf_counter()
 
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
         if self.cam_manager is None:
             raise DeviceNotConnectedError(f"{self} is not connected.")
 
@@ -183,7 +184,6 @@ class Reachy2Camera(Camera):
 
         return frame
 
-    @check_if_not_connected
     def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
         """
         Same as read()
@@ -197,10 +197,11 @@ class Reachy2Camera(Camera):
             TimeoutError: If no frame becomes available within the specified timeout.
             RuntimeError: If an unexpected error occurs.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         return self.read()
 
-    @check_if_not_connected
     def read_latest(self, max_age_ms: int = 1000) -> NDArray[Any]:
         """Return the most recent frame captured immediately (Peeking).
 
@@ -218,6 +219,8 @@ class Reachy2Camera(Camera):
             DeviceNotConnectedError: If the camera is not connected.
             RuntimeError: If the camera is connected but has not captured any frames yet.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.latest_frame is None or self.latest_timestamp is None:
             raise RuntimeError(f"{self} has not captured any frames yet.")
@@ -230,7 +233,6 @@ class Reachy2Camera(Camera):
 
         return self.latest_frame
 
-    @check_if_not_connected
     def disconnect(self) -> None:
         """
         Stops the background read thread (if running).
@@ -238,6 +240,8 @@ class Reachy2Camera(Camera):
         Raises:
             DeviceNotConnectedError: If the camera is already disconnected.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} not connected.")
 
         if self.cam_manager is not None:
             self.cam_manager.disconnect()

src/lerobot/cameras/realsense/camera_realsense.py

@@ -30,8 +30,7 @@ try:
 except Exception as e:
     logging.info(f"Could not import realsense: {e}")
 
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
-from lerobot.utils.errors import DeviceNotConnectedError
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 from ..camera import Camera
 from ..configs import ColorMode
@@ -153,7 +152,6 @@ class RealSenseCamera(Camera):
         """Checks if the camera pipeline is started and streams are active."""
         return self.rs_pipeline is not None and self.rs_profile is not None
 
-    @check_if_already_connected
     def connect(self, warmup: bool = True) -> None:
         """
         Connects to the RealSense camera specified in the configuration.
@@ -171,6 +169,8 @@ class RealSenseCamera(Camera):
             ConnectionError: If the camera is found but fails to start the pipeline or no RealSense devices are detected at all.
             RuntimeError: If the pipeline starts but fails to apply requested settings.
         """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} is already connected.")
 
         self.rs_pipeline = rs.pipeline()
         rs_config = rs.config()
@@ -290,7 +290,6 @@ class RealSenseCamera(Camera):
             if self.use_depth:
                 rs_config.enable_stream(rs.stream.depth)
 
-    @check_if_not_connected
     def _configure_capture_settings(self) -> None:
         """Sets fps, width, and height from device stream if not already configured.
 
@@ -300,6 +299,8 @@ class RealSenseCamera(Camera):
         Raises:
             DeviceNotConnectedError: If device is not connected.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"Cannot validate settings for {self} as it is not connected.")
 
         if self.rs_profile is None:
             raise RuntimeError(f"{self}: rs_profile must be initialized before use.")
@@ -319,7 +320,6 @@ class RealSenseCamera(Camera):
                 self.width, self.height = actual_width, actual_height
                 self.capture_width, self.capture_height = actual_width, actual_height
 
-    @check_if_not_connected
     def read_depth(self, timeout_ms: int = 200) -> NDArray[Any]:
         """
         Reads a single frame (depth) synchronously from the camera.
@@ -345,6 +345,9 @@ class RealSenseCamera(Camera):
                 f"Failed to capture depth frame '.read_depth()'. Depth stream is not enabled for {self}."
             )
 
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
 
@@ -371,7 +374,6 @@ class RealSenseCamera(Camera):
 
         return frame
 
-    @check_if_not_connected
     def read(self, color_mode: ColorMode | None = None, timeout_ms: int = 0) -> NDArray[Any]:
         """
         Reads a single frame (color) synchronously from the camera.
@@ -401,6 +403,9 @@ class RealSenseCamera(Camera):
                 f"{self} read() timeout_ms parameter is deprecated and will be removed in future versions."
             )
 
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
 
@@ -529,7 +534,6 @@ class RealSenseCamera(Camera):
             self.new_frame_event.clear()
 
     # NOTE(Steven): Missing implementation for depth for now
-    @check_if_not_connected
     def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
         """
         Reads the latest available frame data (color) asynchronously.
@@ -552,6 +556,8 @@ class RealSenseCamera(Camera):
             TimeoutError: If no frame data becomes available within the specified timeout.
             RuntimeError: If the background thread died unexpectedly or another error occurs.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
@@ -572,7 +578,6 @@ class RealSenseCamera(Camera):
         return frame
 
     # NOTE(Steven): Missing implementation for depth for now
-    @check_if_not_connected
     def read_latest(self, max_age_ms: int = 1000) -> NDArray[Any]:
         """Return the most recent (color) frame captured immediately (Peeking).
 
@@ -588,6 +593,8 @@ class RealSenseCamera(Camera):
             DeviceNotConnectedError: If the camera is not connected.
             RuntimeError: If the camera is connected but has not captured any frames yet.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")

src/lerobot/cameras/realsense/configuration_realsense.py

@@ -60,8 +60,20 @@ class RealSenseCameraConfig(CameraConfig):
     warmup_s: int = 1
 
     def __post_init__(self) -> None:
-        self.color_mode = ColorMode(self.color_mode)
-        self.rotation = Cv2Rotation(self.rotation)
+        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+            raise ValueError(
+                f"`color_mode` is expected to be {ColorMode.RGB.value} or {ColorMode.BGR.value}, but {self.color_mode} is provided."
+            )
+
+        if self.rotation not in (
+            Cv2Rotation.NO_ROTATION,
+            Cv2Rotation.ROTATE_90,
+            Cv2Rotation.ROTATE_180,
+            Cv2Rotation.ROTATE_270,
+        ):
+            raise ValueError(
+                f"`rotation` is expected to be in {(Cv2Rotation.NO_ROTATION, Cv2Rotation.ROTATE_90, Cv2Rotation.ROTATE_180, Cv2Rotation.ROTATE_270)}, but {self.rotation} is provided."
+            )
 
         values = (self.fps, self.width, self.height)
         if any(v is not None for v in values) and any(v is None for v in values):

src/lerobot/cameras/utils.py

@@ -14,6 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import platform
 from typing import cast
 
 from lerobot.utils.import_utils import make_device_from_device_class
@@ -67,3 +68,14 @@ def get_cv2_rotation(rotation: Cv2Rotation) -> int | None:
         return int(cv2.ROTATE_90_COUNTERCLOCKWISE)
     else:
         return None
+
+
+def get_cv2_backend() -> int:
+    import cv2
+
+    if platform.system() == "Windows":
+        return int(cv2.CAP_MSMF)  # Use MSMF for Windows instead of AVFOUNDATION
+    # elif platform.system() == "Darwin":  # macOS
+    #     return cv2.CAP_AVFOUNDATION
+    else:  # Linux and others
+        return int(cv2.CAP_ANY)

src/lerobot/cameras/zmq/camera_zmq.py

@@ -34,8 +34,7 @@ import cv2
 import numpy as np
 from numpy.typing import NDArray
 
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
-from lerobot.utils.errors import DeviceNotConnectedError
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 from ..camera import Camera
 from ..configs import ColorMode
@@ -105,7 +104,6 @@ class ZMQCamera(Camera):
         """Checks if the ZMQ socket is initialized and connected."""
         return self._connected and self.context is not None and self.socket is not None
 
-    @check_if_already_connected
     def connect(self, warmup: bool = True) -> None:
         """Connect to ZMQ camera server.
 
@@ -113,6 +111,8 @@ class ZMQCamera(Camera):
             warmup (bool): If True, waits for the camera to provide at least one
                            valid frame before returning. Defaults to True.
         """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} is already connected.")
 
         logger.info(f"Connecting to {self}...")
 
@@ -211,7 +211,6 @@ class ZMQCamera(Camera):
 
         return frame
 
-    @check_if_not_connected
     def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
         """
         Reads a single frame synchronously from the camera.
@@ -229,6 +228,9 @@ class ZMQCamera(Camera):
                 f"{self} read() color_mode parameter is deprecated and will be removed in future versions."
             )
 
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
 
@@ -299,7 +301,6 @@ class ZMQCamera(Camera):
             self.latest_timestamp = None
             self.new_frame_event.clear()
 
-    @check_if_not_connected
     def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
         """
         Reads the latest available frame asynchronously.
@@ -316,6 +317,8 @@ class ZMQCamera(Camera):
             TimeoutError: If no frame data becomes available within the specified timeout.
             RuntimeError: If the background thread is not running.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")
@@ -332,7 +335,6 @@ class ZMQCamera(Camera):
 
         return frame
 
-    @check_if_not_connected
     def read_latest(self, max_age_ms: int = 1000) -> NDArray[Any]:
         """Return the most recent frame captured immediately (Peeking).
 
@@ -348,6 +350,8 @@ class ZMQCamera(Camera):
             DeviceNotConnectedError: If the camera is not connected.
             RuntimeError: If the camera is connected but has not captured any frames yet.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if self.thread is None or not self.thread.is_alive():
             raise RuntimeError(f"{self} read thread is not running.")

src/lerobot/cameras/zmq/configuration_zmq.py

@@ -32,7 +32,10 @@ class ZMQCameraConfig(CameraConfig):
     warmup_s: int = 1
 
     def __post_init__(self) -> None:
-        self.color_mode = ColorMode(self.color_mode)
+        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+            raise ValueError(
+                f"`color_mode` is expected to be {ColorMode.RGB.value} or {ColorMode.BGR.value}, but {self.color_mode} is provided."
+            )
 
         if self.timeout_ms <= 0:
             raise ValueError(f"`timeout_ms` must be positive, but {self.timeout_ms} is provided.")

src/lerobot/datasets/dataset_tools.py

@@ -37,7 +37,7 @@ import torch
 from tqdm import tqdm
 
 from lerobot.datasets.aggregate import aggregate_datasets
-from lerobot.datasets.compute_stats import aggregate_stats, compute_episode_stats, get_feature_stats
+from lerobot.datasets.compute_stats import aggregate_stats
 from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata
 from lerobot.datasets.utils import (
     DATA_DIR,
@@ -1522,122 +1522,6 @@ def modify_tasks(
     return dataset
 
 
-def recompute_stats(
-    dataset: LeRobotDataset,
-    skip_image_video: bool = True,
-    delta_action: bool = False,
-    delta_exclude_joints: list[str] | None = None,
-) -> LeRobotDataset:
-    """Recompute stats.json from scratch by iterating all episodes.
-
-    Args:
-        dataset: The LeRobotDataset to recompute stats for.
-        skip_image_video: If True (default), only recompute stats for numeric features
-            (action, state, etc.) and keep existing image/video stats unchanged.
-        delta_action: If True, compute action stats as delta (action - state).
-            Useful when training with use_delta_actions=True so normalization matches.
-        delta_exclude_joints: Joint names to exclude from delta conversion when
-            delta_action=True. These dims keep absolute stats. Uses dataset's
-            action feature names to build the mask. Default: ["gripper"].
-
-    Returns:
-        The same dataset with updated stats.
-    """
-    features = dataset.meta.features
-    numeric_features = {
-        k: v for k, v in features.items()
-        if v["dtype"] not in ["image", "video", "string"]
-        and k not in ["index", "episode_index", "task_index", "frame_index", "timestamp"]
-    }
-
-    if skip_image_video:
-        features_to_compute = numeric_features
-    else:
-        features_to_compute = {
-            k: v for k, v in features.items()
-            if v["dtype"] != "string"
-            and k not in ["index", "episode_index", "task_index", "frame_index", "timestamp"]
-        }
-
-    # Build delta mask if delta_action is enabled
-    delta_mask = None
-    if delta_action and "action" in features and "observation.state" in features:
-        if delta_exclude_joints is None:
-            delta_exclude_joints = ["gripper"]
-        action_names = features["action"].get("names")
-        if action_names is not None:
-            exclude = set(delta_exclude_joints)
-            delta_mask = [n not in exclude for n in action_names]
-        else:
-            action_dim = features["action"]["shape"][0]
-            delta_mask = [True] * action_dim
-        # Only recompute action stats when delta is enabled — state stays unchanged
-        features_to_compute = {"action": features["action"]}
-        logging.info(f"Recomputing action stats as delta (exclude: {delta_exclude_joints})")
-    else:
-        logging.info(f"Recomputing stats for features: {list(features_to_compute.keys())}")
-
-    data_dir = dataset.root / DATA_DIR
-    parquet_files = sorted(data_dir.glob("*/*.parquet"))
-    if not parquet_files:
-        raise ValueError(f"No parquet files found in {data_dir}")
-
-    all_episode_stats = []
-    numeric_keys = [k for k, v in features_to_compute.items() if v["dtype"] not in ["image", "video"]]
-    # Also need state for delta computation even though we don't recompute state stats
-    needs_state = delta_mask is not None
-
-    for parquet_path in tqdm(parquet_files, desc="Computing stats from data files"):
-        df = pd.read_parquet(parquet_path)
-
-        for ep_idx in sorted(df["episode_index"].unique()):
-            ep_df = df[df["episode_index"] == ep_idx]
-            episode_data = {}
-            for key in numeric_keys:
-                if key in ep_df.columns:
-                    values = ep_df[key].values
-                    if hasattr(values[0], "__len__"):
-                        episode_data[key] = np.stack(values)
-                    else:
-                        episode_data[key] = np.array(values)
-
-            # Apply delta conversion to actions before computing stats
-            if delta_mask is not None and "action" in episode_data:
-                from lerobot.processor.delta_action_processor import to_delta_actions
-
-                # Load state for delta even if we're not computing state stats
-                if needs_state and "observation.state" in ep_df.columns:
-                    state_values = ep_df["observation.state"].values
-                    if hasattr(state_values[0], "__len__"):
-                        states = np.stack(state_values)
-                    else:
-                        states = np.array(state_values)
-                    actions_t = torch.from_numpy(episode_data["action"]).float()
-                    states_t = torch.from_numpy(states).float()
-                    episode_data["action"] = to_delta_actions(actions_t, states_t, delta_mask).numpy()
-
-            ep_stats = compute_episode_stats(episode_data, features_to_compute)
-            all_episode_stats.append(ep_stats)
-
-    if not all_episode_stats:
-        logging.warning("No episode stats computed")
-        return dataset
-
-    new_stats = aggregate_stats(all_episode_stats)
-
-    # Merge: keep existing stats for features we didn't recompute
-    if dataset.meta.stats:
-        for key, value in dataset.meta.stats.items():
-            if key not in new_stats:
-                new_stats[key] = value
-
-    write_stats(new_stats, dataset.root)
-    dataset.meta.stats = new_stats
-
-    logging.info(f"Stats recomputed for {len(all_episode_stats)} episodes")
-    return dataset
-
-
 def convert_image_to_video_dataset(
     dataset: LeRobotDataset,
     output_dir: Path,

src/lerobot/datasets/transforms.py

@@ -216,17 +216,16 @@ class ImageTransformsConfig:
 
 
 def make_transform_from_config(cfg: ImageTransformConfig):
-    if cfg.type == "SharpnessJitter":
+    if cfg.type == "Identity":
+        return v2.Identity(**cfg.kwargs)
+    elif cfg.type == "ColorJitter":
+        return v2.ColorJitter(**cfg.kwargs)
+    elif cfg.type == "SharpnessJitter":
         return SharpnessJitter(**cfg.kwargs)
-
-    transform_cls = getattr(v2, cfg.type, None)
-    if isinstance(transform_cls, type) and issubclass(transform_cls, Transform):
-        return transform_cls(**cfg.kwargs)
-
-    raise ValueError(
-        f"Transform '{cfg.type}' is not valid. It must be a class in "
-        f"torchvision.transforms.v2 or 'SharpnessJitter'."
-    )
+    elif cfg.type == "RandomAffine":
+        return v2.RandomAffine(**cfg.kwargs)
+    else:
+        raise ValueError(f"Transform '{cfg.type}' is not valid.")
 
 
 class ImageTransforms(Transform):

src/lerobot/envs/libero.py

@@ -112,7 +112,6 @@ class LiberoEnv(gym.Env):
         visualization_height: int = 480,
         init_states: bool = True,
         episode_index: int = 0,
-        n_envs: int = 1,
         camera_name_mapping: dict[str, str] | None = None,
         num_steps_wait: int = 10,
         control_mode: str = "relative",
@@ -146,9 +145,7 @@ class LiberoEnv(gym.Env):
         self.episode_length = episode_length
         # Load once and keep
         self._init_states = get_task_init_states(task_suite, self.task_id) if self.init_states else None
-        self._reset_stride = n_envs  # when performing a reset, append `_reset_stride` to `init_state_id`.
-
-        self.init_state_id = self.episode_index  # tie each sub-env to a fixed init state
+        self._init_state_id = self.episode_index  # tie each sub-env to a fixed init state
 
         self._env = self._make_envs_task(task_suite, self.task_id)
         default_steps = 500
@@ -298,8 +295,7 @@ class LiberoEnv(gym.Env):
         self._env.seed(seed)
         raw_obs = self._env.reset()
         if self.init_states and self._init_states is not None:
-            raw_obs = self._env.set_init_state(self._init_states[self.init_state_id % len(self._init_states)])
-            self.init_state_id += self._reset_stride  # Change init_state_id when reset
+            raw_obs = self._env.set_init_state(self._init_states[self._init_state_id])
 
         # After reset, objects may be unstable (slightly floating, intersecting, etc.).
         # Step the simulator with a no-op action for a few frames so everything settles.
@@ -377,7 +373,6 @@ def _make_env_fns(
             init_states=init_states,
             episode_length=episode_length,
             episode_index=episode_index,
-            n_envs=n_envs,
             control_mode=control_mode,
             **local_kwargs,
         )

src/lerobot/motors/calibration_gui.py

@@ -221,7 +221,7 @@ class RangeFinderGUI:
 
         self.bus = bus
         self.groups = groups if groups is not None else {"all": list(bus.motors)}
-        self.group_names = list(self.groups)
+        self.group_names = list(groups)
         self.current_group = self.group_names[0]
 
         if not bus.is_connected:
@@ -230,20 +230,18 @@ class RangeFinderGUI:
         self.calibration = bus.read_calibration()
         self.res_table = bus.model_resolution_table
         self.present_cache = {
-            m: bus.read("Present_Position", m, normalize=False)
-            for motors in self.groups.values()
-            for m in motors
+            m: bus.read("Present_Position", m, normalize=False) for motors in groups.values() for m in motors
         }
 
         pygame.init()
         self.font = pygame.font.Font(None, FONT_SIZE)
 
-        label_pad = max(self.font.size(m)[0] for ms in self.groups.values() for m in ms)
+        label_pad = max(self.font.size(m)[0] for ms in groups.values() for m in ms)
         self.label_pad = label_pad
         width = 40 + label_pad + BAR_LEN + 6 + BTN_W + 10 + SAVE_W + 10
         self.controls_bottom = 10 + SAVE_H
         self.base_y = self.controls_bottom + TOP_GAP
-        height = self.base_y + PADDING_Y * len(self.groups[self.current_group]) + 40
+        height = self.base_y + PADDING_Y * len(groups[self.current_group]) + 40
 
         self.screen = pygame.display.set_mode((width, height))
         pygame.display.set_caption("Motors range finder")

src/lerobot/motors/damiao/damiao.py

@@ -23,7 +23,6 @@ from copy import deepcopy
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, TypedDict
 
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
 from lerobot.utils.import_utils import _can_available
 
 if TYPE_CHECKING or _can_available:
@@ -37,6 +36,7 @@ else:
 
 import numpy as np
 
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import enter_pressed, move_cursor_up
 
@@ -155,7 +155,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         """Check if the CAN bus is connected."""
         return self._is_connected and self.canbus is not None
 
-    @check_if_already_connected
     def connect(self, handshake: bool = True) -> None:
         """
         Open the CAN bus and initialize communication.
@@ -163,6 +162,10 @@ class DamiaoMotorsBus(MotorsBusBase):
         Args:
             handshake: If True, ping all motors to verify they're present
         """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(
+                f"{self.__class__.__name__}('{self.port}') is already connected."
+            )
 
         try:
             # Auto-detect interface type based on port name
@@ -208,9 +211,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         logger.info("Starting handshake with motors...")
 
         # Drain any pending messages
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         while self.canbus.recv(timeout=0.01):
             pass
 
@@ -246,7 +246,6 @@ class DamiaoMotorsBus(MotorsBusBase):
             )
         logger.info("Handshake successful. All motors ready.")
 
-    @check_if_not_connected
     def disconnect(self, disable_torque: bool = True) -> None:
         """
         Close the CAN bus connection.
@@ -254,6 +253,8 @@ class DamiaoMotorsBus(MotorsBusBase):
         Args:
             disable_torque: If True, disable torque on all motors before disconnecting
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self.__class__.__name__}('{self.port}') is not connected.")
 
         if disable_torque:
             try:
@@ -282,10 +283,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         recv_id = self._get_motor_recv_id(motor)
         data = [0xFF] * 7 + [command_byte]
         msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False, is_fd=self.use_can_fd)
-
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         self.canbus.send(msg)
         if msg := self._recv_motor_response(expected_recv_id=recv_id):
             self._process_response(motor_name, msg)
@@ -344,10 +341,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         recv_id = self._get_motor_recv_id(motor)
         data = [motor_id & 0xFF, (motor_id >> 8) & 0xFF, CAN_CMD_REFRESH, 0, 0, 0, 0, 0]
         msg = can.Message(arbitration_id=CAN_PARAM_ID, data=data, is_extended_id=False, is_fd=self.use_can_fd)
-
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         self.canbus.send(msg)
         return self._recv_motor_response(expected_recv_id=recv_id)
 
@@ -363,10 +356,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         Returns:
             CAN message if received, None otherwise
         """
-
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         try:
             start_time = time.time()
             messages_seen = []
@@ -405,13 +394,10 @@ class DamiaoMotorsBus(MotorsBusBase):
         Returns:
             Dictionary mapping recv_id to CAN message
         """
-        responses: dict[int, can.Message] = {}
+        responses = {}
         expected_set = set(expected_recv_ids)
         start_time = time.time()
 
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         try:
             while len(responses) < len(expected_recv_ids) and (time.time() - start_time) < timeout:
                 # 100us poll timeout
@@ -475,9 +461,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         motor_name = self._get_motor_name(motor)
         motor_type = self._motor_types[motor_name]
 
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         data = self._encode_mit_packet(motor_type, kp, kd, position_degrees, velocity_deg_per_sec, torque)
         msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False, is_fd=self.use_can_fd)
         self.canbus.send(msg)
@@ -505,9 +488,6 @@ class DamiaoMotorsBus(MotorsBusBase):
 
         recv_id_to_motor: dict[int, str] = {}
 
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         # Step 1: Send all MIT control commands
         for motor, (kp, kd, position_degrees, velocity_deg_per_sec, torque) in commands.items():
             motor_id = self._get_motor_id(motor)
@@ -582,9 +562,10 @@ class DamiaoMotorsBus(MotorsBusBase):
         except Exception as e:
             logger.warning(f"Failed to decode response from {motor}: {e}")
 
-    @check_if_not_connected
     def read(self, data_name: str, motor: str) -> Value:
         """Read a value from a single motor. Positions are always in degrees."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         # Refresh motor to get latest state
         msg = self._refresh_motor(motor)
@@ -614,7 +595,6 @@ class DamiaoMotorsBus(MotorsBusBase):
             raise ValueError(f"Unknown data_name: {data_name}")
         return mapping[data_name]
 
-    @check_if_not_connected
     def write(
         self,
         data_name: str,
@@ -625,6 +605,8 @@ class DamiaoMotorsBus(MotorsBusBase):
         Write a value to a single motor. Positions are always in degrees.
         Can write 'Goal_Position', 'Kp', or 'Kd'.
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         if data_name in ("Kp", "Kd"):
             self._gains[motor][data_name.lower()] = float(value)
@@ -674,10 +656,6 @@ class DamiaoMotorsBus(MotorsBusBase):
 
     def _batch_refresh(self, motors: list[str]) -> None:
         """Internal helper to refresh a list of motors and update cache."""
-
-        if self.canbus is None:
-            raise RuntimeError("CAN bus is not initialized.")
-
         # Send refresh commands
         for motor in motors:
             motor_id = self._get_motor_id(motor)
@@ -700,12 +678,10 @@ class DamiaoMotorsBus(MotorsBusBase):
             else:
                 logger.warning(f"Packet drop: {motor} (ID: 0x{recv_id:02X}). Using last known state.")
 
-    @check_if_not_connected
-    def sync_write(self, data_name: str, values: dict[str, Value]) -> None:
+    def sync_write(self, data_name: str, values: Value | dict[str, Value]) -> None:
         """
         Write values to multiple motors simultaneously. Positions are always in degrees.
         """
-
         if data_name in ("Kp", "Kd"):
             key = data_name.lower()
             for motor, val in values.items():
@@ -714,8 +690,6 @@ class DamiaoMotorsBus(MotorsBusBase):
         elif data_name == "Goal_Position":
             # Step 1: Send all MIT control commands
             recv_id_to_motor: dict[int, str] = {}
-            if self.canbus is None:
-                raise RuntimeError("CAN bus is not initialized.")
             for motor, value_degrees in values.items():
                 motor_id = self._get_motor_id(motor)
                 motor_name = self._get_motor_name(motor)
@@ -758,9 +732,9 @@ class DamiaoMotorsBus(MotorsBusBase):
 
     def record_ranges_of_motion(
         self,
-        motors: str | list[str] | None = None,
+        motors: NameOrID | list[NameOrID] | None = None,
         display_values: bool = True,
-    ) -> tuple[dict[str, Value], dict[str, Value]]:
+    ) -> tuple[dict[NameOrID, Value], dict[NameOrID, Value]]:
         """
         Interactively record the min/max values of each motor in degrees.
 

src/lerobot/motors/dynamixel/dynamixel.py

@@ -181,10 +181,10 @@ class DynamixelMotorsBus(SerialMotorsBus):
         for motor, m in self.motors.items():
             calibration[motor] = MotorCalibration(
                 id=m.id,
-                drive_mode=int(drive_modes[motor]),
-                homing_offset=int(offsets[motor]),
-                range_min=int(mins[motor]),
-                range_max=int(maxes[motor]),
+                drive_mode=drive_modes[motor],
+                homing_offset=offsets[motor],
+                range_min=mins[motor],
+                range_max=maxes[motor],
             )
 
         return calibration
@@ -198,7 +198,7 @@ class DynamixelMotorsBus(SerialMotorsBus):
         if cache:
             self.calibration = calibration_dict
 
-    def disable_torque(self, motors: int | str | list[str] | None = None, num_retry: int = 0) -> None:
+    def disable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
         for motor in self._get_motors_list(motors):
             self.write("Torque_Enable", motor, TorqueMode.DISABLED.value, num_retry=num_retry)
 
@@ -206,7 +206,7 @@ class DynamixelMotorsBus(SerialMotorsBus):
         addr, length = get_address(self.model_ctrl_table, model, "Torque_Enable")
         self._write(addr, length, motor, TorqueMode.DISABLED.value, num_retry=num_retry)
 
-    def enable_torque(self, motors: int | str | list[str] | None = None, num_retry: int = 0) -> None:
+    def enable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
         for motor in self._get_motors_list(motors):
             self.write("Torque_Enable", motor, TorqueMode.ENABLED.value, num_retry=num_retry)
 
@@ -235,7 +235,7 @@ class DynamixelMotorsBus(SerialMotorsBus):
         On Dynamixel Motors:
         Present_Position = Actual_Position + Homing_Offset
         """
-        half_turn_homings: dict[NameOrID, Value] = {}
+        half_turn_homings = {}
         for motor, pos in positions.items():
             model = self._get_motor_model(motor)
             max_res = self.model_resolution_table[model] - 1
@@ -258,6 +258,6 @@ class DynamixelMotorsBus(SerialMotorsBus):
             if raise_on_error:
                 raise ConnectionError(self.packet_handler.getTxRxResult(comm))
 
-            return None
+            return
 
         return {id_: data[0] for id_, data in data_list.items()}

src/lerobot/motors/feetech/feetech.py

@@ -126,7 +126,7 @@ class FeetechMotorsBus(SerialMotorsBus):
 
         self.port_handler = scs.PortHandler(self.port)
         # HACK: monkeypatch
-        self.port_handler.setPacketTimeout = patch_setPacketTimeout.__get__(  # type: ignore[method-assign]
+        self.port_handler.setPacketTimeout = patch_setPacketTimeout.__get__(
             self.port_handler, scs.PortHandler
         )
         self.packet_handler = scs.PacketHandler(protocol_version)
@@ -262,9 +262,9 @@ class FeetechMotorsBus(SerialMotorsBus):
             calibration[motor] = MotorCalibration(
                 id=m.id,
                 drive_mode=0,
-                homing_offset=int(offsets[motor]),
-                range_min=int(mins[motor]),
-                range_max=int(maxes[motor]),
+                homing_offset=offsets[motor],
+                range_min=mins[motor],
+                range_max=maxes[motor],
             )
 
         return calibration
@@ -284,7 +284,7 @@ class FeetechMotorsBus(SerialMotorsBus):
         On Feetech Motors:
         Present_Position = Actual_Position - Homing_Offset
         """
-        half_turn_homings: dict[NameOrID, Value] = {}
+        half_turn_homings = {}
         for motor, pos in positions.items():
             model = self._get_motor_model(motor)
             max_res = self.model_resolution_table[model] - 1
@@ -292,7 +292,7 @@ class FeetechMotorsBus(SerialMotorsBus):
 
         return half_turn_homings
 
-    def disable_torque(self, motors: int | str | list[str] | None = None, num_retry: int = 0) -> None:
+    def disable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
         for motor in self._get_motors_list(motors):
             self.write("Torque_Enable", motor, TorqueMode.DISABLED.value, num_retry=num_retry)
             self.write("Lock", motor, 0, num_retry=num_retry)
@@ -303,7 +303,7 @@ class FeetechMotorsBus(SerialMotorsBus):
         addr, length = get_address(self.model_ctrl_table, model, "Lock")
         self._write(addr, length, motor, 0, num_retry=num_retry)
 
-    def enable_torque(self, motors: int | str | list[str] | None = None, num_retry: int = 0) -> None:
+    def enable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
         for motor in self._get_motors_list(motors):
             self.write("Torque_Enable", motor, TorqueMode.ENABLED.value, num_retry=num_retry)
             self.write("Lock", motor, 1, num_retry=num_retry)
@@ -334,7 +334,7 @@ class FeetechMotorsBus(SerialMotorsBus):
     def _broadcast_ping(self) -> tuple[dict[int, int], int]:
         import scservo_sdk as scs
 
-        data_list: dict[int, int] = {}
+        data_list = {}
 
         status_length = 6
 
@@ -414,7 +414,7 @@ class FeetechMotorsBus(SerialMotorsBus):
         if not self._is_comm_success(comm):
             if raise_on_error:
                 raise ConnectionError(self.packet_handler.getTxRxResult(comm))
-            return None
+            return
 
         ids_errors = {id_: status for id_, status in ids_status.items() if self._is_error(status)}
         if ids_errors:

src/lerobot/motors/motors_bus.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 
 import abc
 import logging
-from collections.abc import Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
 from enum import Enum
@@ -94,7 +93,7 @@ class MotorsBusBase(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def sync_write(self, data_name: str, values: dict[str, Value]) -> None:
+    def sync_write(self, data_name: str, values: Value | dict[str, Value]) -> None:
         """Write values to multiple motors."""
         pass
 
@@ -180,16 +179,15 @@ class Motor:
 
 
 class PortHandler(Protocol):
-    is_open: bool
-    baudrate: int
-    packet_start_time: float
-    packet_timeout: float
-    tx_time_per_byte: float
-    is_using: bool
-    port_name: str
-    ser: serial.Serial
-
-    def __init__(self, port_name: str) -> None: ...
+    def __init__(self, port_name):
+        self.is_open: bool
+        self.baudrate: int
+        self.packet_start_time: float
+        self.packet_timeout: float
+        self.tx_time_per_byte: float
+        self.is_using: bool
+        self.port_name: str
+        self.ser: serial.Serial
 
     def openPort(self): ...
     def closePort(self): ...
@@ -242,22 +240,19 @@ class PacketHandler(Protocol):
     def regWriteTxRx(self, port, id, address, length, data): ...
     def syncReadTx(self, port, start_address, data_length, param, param_length): ...
     def syncWriteTxOnly(self, port, start_address, data_length, param, param_length): ...
-    def broadcastPing(self, port): ...
 
 
 class GroupSyncRead(Protocol):
-    port: str
-    ph: PortHandler
-    start_address: int
-    data_length: int
-    last_result: bool
-    is_param_changed: bool
-    param: list
-    data_dict: dict
+    def __init__(self, port, ph, start_address, data_length):
+        self.port: str
+        self.ph: PortHandler
+        self.start_address: int
+        self.data_length: int
+        self.last_result: bool
+        self.is_param_changed: bool
+        self.param: list
+        self.data_dict: dict
 
-    def __init__(
-        self, port: PortHandler, ph: PacketHandler, start_address: int, data_length: int
-    ) -> None: ...
     def makeParam(self): ...
     def addParam(self, id): ...
     def removeParam(self, id): ...
@@ -270,17 +265,15 @@ class GroupSyncRead(Protocol):
 
 
 class GroupSyncWrite(Protocol):
-    port: str
-    ph: PortHandler
-    start_address: int
-    data_length: int
-    is_param_changed: bool
-    param: list
-    data_dict: dict
+    def __init__(self, port, ph, start_address, data_length):
+        self.port: str
+        self.ph: PortHandler
+        self.start_address: int
+        self.data_length: int
+        self.is_param_changed: bool
+        self.param: list
+        self.data_dict: dict
 
-    def __init__(
-        self, port: PortHandler, ph: PacketHandler, start_address: int, data_length: int
-    ) -> None: ...
     def makeParam(self): ...
     def addParam(self, id, data): ...
     def removeParam(self, id): ...
@@ -407,7 +400,7 @@ class SerialMotorsBus(MotorsBusBase):
         else:
             raise TypeError(f"'{motor}' should be int, str.")
 
-    def _get_motor_model(self, motor: NameOrID) -> str:
+    def _get_motor_model(self, motor: NameOrID) -> int:
         if isinstance(motor, str):
             return self.motors[motor].model
         elif isinstance(motor, int):
@@ -415,19 +408,17 @@ class SerialMotorsBus(MotorsBusBase):
         else:
             raise TypeError(f"'{motor}' should be int, str.")
 
-    def _get_motors_list(self, motors: NameOrID | Sequence[NameOrID] | None) -> list[str]:
+    def _get_motors_list(self, motors: str | list[str] | None) -> list[str]:
         if motors is None:
             return list(self.motors)
         elif isinstance(motors, str):
             return [motors]
-        elif isinstance(motors, int):
-            return [self._id_to_name(motors)]
-        elif isinstance(motors, Sequence):
-            return [m if isinstance(m, str) else self._id_to_name(m) for m in motors]
+        elif isinstance(motors, list):
+            return motors.copy()
         else:
             raise TypeError(motors)
 
-    def _get_ids_values_dict(self, values: Value | dict[str, Value] | None) -> dict[int, Value]:
+    def _get_ids_values_dict(self, values: Value | dict[str, Value] | None) -> list[str]:
         if isinstance(values, (int | float)):
             return dict.fromkeys(self.ids, values)
         elif isinstance(values, dict):
@@ -649,19 +640,18 @@ class SerialMotorsBus(MotorsBusBase):
         pass
 
     @abc.abstractmethod
-    def enable_torque(self, motors: int | str | list[str] | None = None, num_retry: int = 0) -> None:
+    def enable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
         """Enable torque on selected motors.
 
         Args:
-            motors (int | str | list[str] | None, optional): Same semantics as :pymeth:`disable_torque`.
-                Defaults to `None`.
+            motor (int): Same semantics as :pymeth:`disable_torque`. Defaults to `None`.
             num_retry (int, optional): Number of additional retry attempts on communication failure.
                 Defaults to 0.
         """
         pass
 
     @contextmanager
-    def torque_disabled(self, motors: str | list[str] | None = None):
+    def torque_disabled(self, motors: int | str | list[str] | None = None):
         """Context-manager that guarantees torque is re-enabled.
 
         This helper is useful to temporarily disable torque when configuring motors.
@@ -738,19 +728,24 @@ class SerialMotorsBus(MotorsBusBase):
         """
         pass
 
-    def reset_calibration(self, motors: NameOrID | Sequence[NameOrID] | None = None) -> None:
+    def reset_calibration(self, motors: NameOrID | list[NameOrID] | None = None) -> None:
         """Restore factory calibration for the selected motors.
 
         Homing offset is set to ``0`` and min/max position limits are set to the full usable range.
         The in-memory :pyattr:`calibration` is cleared.
 
         Args:
-            motors (NameOrID | Sequence[NameOrID] | None, optional): Selection of motors. `None` (default)
+            motors (NameOrID | list[NameOrID] | None, optional): Selection of motors. `None` (default)
                 resets every motor.
         """
-        motor_names = self._get_motors_list(motors)
+        if motors is None:
+            motors = list(self.motors)
+        elif isinstance(motors, (str | int)):
+            motors = [motors]
+        elif not isinstance(motors, list):
+            raise TypeError(motors)
 
-        for motor in motor_names:
+        for motor in motors:
             model = self._get_motor_model(motor)
             max_res = self.model_resolution_table[model] - 1
             self.write("Homing_Offset", motor, 0, normalize=False)
@@ -759,9 +754,7 @@ class SerialMotorsBus(MotorsBusBase):
 
         self.calibration = {}
 
-    def set_half_turn_homings(
-        self, motors: NameOrID | Sequence[NameOrID] | None = None
-    ) -> dict[NameOrID, Value]:
+    def set_half_turn_homings(self, motors: NameOrID | list[NameOrID] | None = None) -> dict[NameOrID, Value]:
         """Centre each motor range around its current position.
 
         The function computes and writes a homing offset such that the present position becomes exactly one
@@ -771,12 +764,17 @@ class SerialMotorsBus(MotorsBusBase):
             motors (NameOrID | list[NameOrID] | None, optional): Motors to adjust. Defaults to all motors (`None`).
 
         Returns:
-            dict[str, Value]: Mapping *motor name → written homing offset*.
+            dict[NameOrID, Value]: Mapping *motor → written homing offset*.
         """
-        motor_names = self._get_motors_list(motors)
+        if motors is None:
+            motors = list(self.motors)
+        elif isinstance(motors, (str | int)):
+            motors = [motors]
+        elif not isinstance(motors, list):
+            raise TypeError(motors)
 
-        self.reset_calibration(motor_names)
-        actual_positions = self.sync_read("Present_Position", motor_names, normalize=False)
+        self.reset_calibration(motors)
+        actual_positions = self.sync_read("Present_Position", motors, normalize=False)
         homing_offsets = self._get_half_turn_homings(actual_positions)
         for motor, offset in homing_offsets.items():
             self.write("Homing_Offset", motor, offset)
@@ -788,8 +786,8 @@ class SerialMotorsBus(MotorsBusBase):
         pass
 
     def record_ranges_of_motion(
-        self, motors: NameOrID | Sequence[NameOrID] | None = None, display_values: bool = True
-    ) -> tuple[dict[str, Value], dict[str, Value]]:
+        self, motors: NameOrID | list[NameOrID] | None = None, display_values: bool = True
+    ) -> tuple[dict[NameOrID, Value], dict[NameOrID, Value]]:
         """Interactively record the min/max encoder values of each motor.
 
         Move the joints by hand (with torque disabled) while the method streams live positions. Press
@@ -801,25 +799,30 @@ class SerialMotorsBus(MotorsBusBase):
             display_values (bool, optional): When `True` (default) a live table is printed to the console.
 
         Returns:
-            tuple[dict[str, Value], dict[str, Value]]: Two dictionaries *mins* and *maxes* with the
+            tuple[dict[NameOrID, Value], dict[NameOrID, Value]]: Two dictionaries *mins* and *maxes* with the
                 extreme values observed for each motor.
         """
-        motor_names = self._get_motors_list(motors)
+        if motors is None:
+            motors = list(self.motors)
+        elif isinstance(motors, (str | int)):
+            motors = [motors]
+        elif not isinstance(motors, list):
+            raise TypeError(motors)
 
-        start_positions = self.sync_read("Present_Position", motor_names, normalize=False)
+        start_positions = self.sync_read("Present_Position", motors, normalize=False)
         mins = start_positions.copy()
         maxes = start_positions.copy()
 
         user_pressed_enter = False
         while not user_pressed_enter:
-            positions = self.sync_read("Present_Position", motor_names, normalize=False)
+            positions = self.sync_read("Present_Position", motors, normalize=False)
             mins = {motor: min(positions[motor], min_) for motor, min_ in mins.items()}
             maxes = {motor: max(positions[motor], max_) for motor, max_ in maxes.items()}
 
             if display_values:
                 print("\n-------------------------------------------")
                 print(f"{'NAME':<15} | {'MIN':>6} | {'POS':>6} | {'MAX':>6}")
-                for motor in motor_names:
+                for motor in motors:
                     print(f"{motor:<15} | {mins[motor]:>6} | {positions[motor]:>6} | {maxes[motor]:>6}")
 
             if enter_pressed():
@@ -827,9 +830,9 @@ class SerialMotorsBus(MotorsBusBase):
 
             if display_values and not user_pressed_enter:
                 # Move cursor up to overwrite the previous output
-                move_cursor_up(len(motor_names) + 3)
+                move_cursor_up(len(motors) + 3)
 
-        same_min_max = [motor for motor in motor_names if mins[motor] == maxes[motor]]
+        same_min_max = [motor for motor in motors if mins[motor] == maxes[motor]]
         if same_min_max:
             raise ValueError(f"Some motors have the same min and max values:\n{pformat(same_min_max)}")
 
@@ -952,12 +955,12 @@ class SerialMotorsBus(MotorsBusBase):
             if raise_on_error:
                 raise ConnectionError(self.packet_handler.getTxRxResult(comm))
             else:
-                return None
+                return
         if self._is_error(error):
             if raise_on_error:
                 raise RuntimeError(self.packet_handler.getRxPacketError(error))
             else:
-                return None
+                return
 
         return model_number
 
@@ -1004,13 +1007,12 @@ class SerialMotorsBus(MotorsBusBase):
         err_msg = f"Failed to read '{data_name}' on {id_=} after {num_retry + 1} tries."
         value, _, _ = self._read(addr, length, id_, num_retry=num_retry, raise_on_error=True, err_msg=err_msg)
 
-        decoded = self._decode_sign(data_name, {id_: value})
+        id_value = self._decode_sign(data_name, {id_: value})
 
         if normalize and data_name in self.normalized_data:
-            normalized = self._normalize(decoded)
-            return normalized[id_]
+            id_value = self._normalize(id_value)
 
-        return decoded[id_]
+        return id_value[id_]
 
     def _read(
         self,
@@ -1021,7 +1023,7 @@ class SerialMotorsBus(MotorsBusBase):
         num_retry: int = 0,
         raise_on_error: bool = True,
         err_msg: str = "",
-    ) -> tuple[int, int, int]:
+    ) -> tuple[int, int]:
         if length == 1:
             read_fn = self.packet_handler.read1ByteTxRx
         elif length == 2:
@@ -1071,14 +1073,13 @@ class SerialMotorsBus(MotorsBusBase):
         model = self.motors[motor].model
         addr, length = get_address(self.model_ctrl_table, model, data_name)
 
-        int_value = int(value)
         if normalize and data_name in self.normalized_data:
-            int_value = self._unnormalize({id_: value})[id_]
+            value = self._unnormalize({id_: value})[id_]
 
-        int_value = self._encode_sign(data_name, {id_: int_value})[id_]
+        value = self._encode_sign(data_name, {id_: value})[id_]
 
-        err_msg = f"Failed to write '{data_name}' on {id_=} with '{int_value}' after {num_retry + 1} tries."
-        self._write(addr, length, id_, int_value, num_retry=num_retry, raise_on_error=True, err_msg=err_msg)
+        err_msg = f"Failed to write '{data_name}' on {id_=} with '{value}' after {num_retry + 1} tries."
+        self._write(addr, length, id_, value, num_retry=num_retry, raise_on_error=True, err_msg=err_msg)
 
     def _write(
         self,
@@ -1112,7 +1113,7 @@ class SerialMotorsBus(MotorsBusBase):
     def sync_read(
         self,
         data_name: str,
-        motors: NameOrID | Sequence[NameOrID] | None = None,
+        motors: str | list[str] | None = None,
         *,
         normalize: bool = True,
         num_retry: int = 0,
@@ -1121,7 +1122,7 @@ class SerialMotorsBus(MotorsBusBase):
 
         Args:
             data_name (str): Register name.
-            motors (NameOrID | Sequence[NameOrID] | None, optional): Motors to query. `None` (default) reads every motor.
+            motors (str | list[str] | None, optional): Motors to query. `None` (default) reads every motor.
             normalize (bool, optional): Normalisation flag.  Defaults to `True`.
             num_retry (int, optional): Retry attempts.  Defaults to `0`.
 
@@ -1142,17 +1143,16 @@ class SerialMotorsBus(MotorsBusBase):
         addr, length = get_address(self.model_ctrl_table, model, data_name)
 
         err_msg = f"Failed to sync read '{data_name}' on {ids=} after {num_retry + 1} tries."
-        raw_ids_values, _ = self._sync_read(
+        ids_values, _ = self._sync_read(
             addr, length, ids, num_retry=num_retry, raise_on_error=True, err_msg=err_msg
         )
 
-        decoded = self._decode_sign(data_name, raw_ids_values)
+        ids_values = self._decode_sign(data_name, ids_values)
 
         if normalize and data_name in self.normalized_data:
-            normalized = self._normalize(decoded)
-            return {self._id_to_name(id_): value for id_, value in normalized.items()}
+            ids_values = self._normalize(ids_values)
 
-        return {self._id_to_name(id_): value for id_, value in decoded.items()}
+        return {self._id_to_name(id_): value for id_, value in ids_values.items()}
 
     def _sync_read(
         self,
@@ -1224,24 +1224,21 @@ class SerialMotorsBus(MotorsBusBase):
             num_retry (int, optional): Retry attempts.  Defaults to `0`.
         """
 
-        raw_ids_values = self._get_ids_values_dict(values)
-        models = [self._id_to_model(id_) for id_ in raw_ids_values]
+        ids_values = self._get_ids_values_dict(values)
+        models = [self._id_to_model(id_) for id_ in ids_values]
         if self._has_different_ctrl_tables:
             assert_same_address(self.model_ctrl_table, models, data_name)
 
         model = next(iter(models))
         addr, length = get_address(self.model_ctrl_table, model, data_name)
 
-        int_ids_values = {id_: int(val) for id_, val in raw_ids_values.items()}
         if normalize and data_name in self.normalized_data:
-            int_ids_values = self._unnormalize(raw_ids_values)
+            ids_values = self._unnormalize(ids_values)
 
-        int_ids_values = self._encode_sign(data_name, int_ids_values)
+        ids_values = self._encode_sign(data_name, ids_values)
 
-        err_msg = f"Failed to sync write '{data_name}' with ids_values={int_ids_values} after {num_retry + 1} tries."
-        self._sync_write(
-            addr, length, int_ids_values, num_retry=num_retry, raise_on_error=True, err_msg=err_msg
-        )
+        err_msg = f"Failed to sync write '{data_name}' with {ids_values=} after {num_retry + 1} tries."
+        self._sync_write(addr, length, ids_values, num_retry=num_retry, raise_on_error=True, err_msg=err_msg)
 
     def _sync_write(
         self,

src/lerobot/policies/factory.py

@@ -470,13 +470,6 @@ def make_policy(
     cfg.output_features = {key: ft for key, ft in features.items() if ft.type is FeatureType.ACTION}
     if not cfg.input_features:
         cfg.input_features = {key: ft for key, ft in features.items() if key not in cfg.output_features}
-
-    # Store action feature names for delta_exclude_joints support
-    if ds_meta is not None and hasattr(cfg, "action_feature_names"):
-        action_names = ds_meta.features.get(ACTION, {}).get("names")
-        if action_names is not None:
-            cfg.action_feature_names = list(action_names)
-
     kwargs["config"] = cfg
 
     # Pass dataset_stats to the policy if available (needed for some policies like SARM)

src/lerobot/policies/pi0/configuration_pi0.py

@@ -50,13 +50,6 @@ class PI0Config(PreTrainedConfig):
     min_period: float = 4e-3
     max_period: float = 4.0
 
-    # Delta actions: converts absolute actions to delta (relative to state).
-    use_delta_actions: bool = False
-    # Joint names to exclude from delta (kept absolute). Empty list = all dims delta.
-    delta_exclude_joints: list[str] = field(default_factory=lambda: ["gripper"])
-    # Populated at runtime from dataset metadata by make_policy.
-    action_feature_names: list[str] | None = None
-
     # Real-Time Chunking (RTC) configuration
     rtc_config: RTCConfig | None = None
 

src/lerobot/policies/pi0/processor_pi0.py

@@ -21,10 +21,8 @@ import torch
 from lerobot.configs.types import PipelineFeatureType, PolicyFeature
 from lerobot.policies.pi0.configuration_pi0 import PI0Config
 from lerobot.processor import (
-    AbsoluteActionsProcessorStep,
     AddBatchDimensionProcessorStep,
     ComplementaryDataProcessorStep,
-    DeltaActionsProcessorStep,
     DeviceProcessorStep,
     NormalizerProcessorStep,
     PolicyAction,
@@ -128,13 +126,7 @@ def make_pi0_pre_post_processors(
         A tuple containing the configured pre-processor and post-processor pipelines.
     """
 
-    delta_step = DeltaActionsProcessorStep(
-        enabled=config.use_delta_actions,
-        exclude_joints=getattr(config, "delta_exclude_joints", []),
-        action_names=getattr(config, "action_feature_names", None),
-    )
-
-    # OpenPI order: raw → delta → normalize → model → unnormalize → absolute
+    # Add remaining processors
     input_steps: list[ProcessorStep] = [
         RenameObservationsProcessorStep(rename_map={}),  # To mimic the same processor as pretrained one
         AddBatchDimensionProcessorStep(),
@@ -146,7 +138,6 @@ def make_pi0_pre_post_processors(
             padding="max_length",
         ),
         DeviceProcessorStep(device=config.device),
-        delta_step,
         NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
@@ -158,7 +149,6 @@ def make_pi0_pre_post_processors(
         UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
-        AbsoluteActionsProcessorStep(enabled=config.use_delta_actions, delta_step=delta_step),
         DeviceProcessorStep(device="cpu"),
     ]
 

src/lerobot/policies/pi05/configuration_pi05.py

@@ -50,13 +50,6 @@ class PI05Config(PreTrainedConfig):
     min_period: float = 4e-3
     max_period: float = 4.0
 
-    # Delta actions: converts absolute actions to delta (relative to state).
-    use_delta_actions: bool = False
-    # Joint names to exclude from delta (kept absolute). Empty list = all dims delta.
-    delta_exclude_joints: list[str] = field(default_factory=lambda: ["gripper"])
-    # Populated at runtime from dataset metadata by make_policy.
-    action_feature_names: list[str] | None = None
-
     # Real-Time Chunking (RTC) configuration
     rtc_config: RTCConfig | None = None
 

src/lerobot/policies/pi05/processor_pi05.py

@@ -25,9 +25,7 @@ from lerobot.configs.types import PipelineFeatureType, PolicyFeature
 from lerobot.policies.pi05.configuration_pi05 import PI05Config
 from lerobot.policies.pi05.modeling_pi05 import pad_vector
 from lerobot.processor import (
-    AbsoluteActionsProcessorStep,
     AddBatchDimensionProcessorStep,
-    DeltaActionsProcessorStep,
     DeviceProcessorStep,
     NormalizerProcessorStep,
     PolicyAction,
@@ -131,19 +129,10 @@ def make_pi05_pre_post_processors(
         A tuple containing the configured pre-processor and post-processor pipelines.
     """
 
-    delta_step = DeltaActionsProcessorStep(
-        enabled=config.use_delta_actions,
-        exclude_joints=getattr(config, "delta_exclude_joints", []),
-        action_names=getattr(config, "action_feature_names", None),
-    )
-
-    # OpenPI order: raw → delta → normalize → model → unnormalize → absolute
-    # NOTE: NormalizerProcessorStep MUST come before Pi05PrepareStateTokenizerProcessorStep
-    # because the tokenizer step expects normalized state in [-1, 1] range for discretization
+    # Add remaining processors
     input_steps: list[ProcessorStep] = [
         RenameObservationsProcessorStep(rename_map={}),  # To mimic the same processor as pretrained one
         AddBatchDimensionProcessorStep(),
-        delta_step,
         # NOTE: NormalizerProcessorStep MUST come before Pi05PrepareStateTokenizerProcessorStep
         # because the tokenizer step expects normalized state in [-1, 1] range for discretization
         NormalizerProcessorStep(
@@ -165,7 +154,6 @@ def make_pi05_pre_post_processors(
         UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
-        AbsoluteActionsProcessorStep(enabled=config.use_delta_actions, delta_step=delta_step),
         DeviceProcessorStep(device="cpu"),
     ]
 

src/lerobot/policies/pi0_fast/configuration_pi0_fast.py

@@ -41,9 +41,6 @@ class PI0FastConfig(PreTrainedConfig):
     max_action_dim: int = 32
     max_action_tokens: int = 256
 
-    # Delta actions: converts absolute actions to delta (relative to state).
-    use_delta_actions: bool = False
-
     # Real-Time Chunking (RTC) configuration
     rtc_config: RTCConfig | None = None
 

src/lerobot/policies/pi0_fast/modeling_pi0_fast.py

@@ -48,14 +48,12 @@ from lerobot.configs.policies import PreTrainedConfig
 from lerobot.policies.pi0_fast.configuration_pi0_fast import PI0FastConfig
 from lerobot.policies.pretrained import PreTrainedPolicy, T
 from lerobot.policies.rtc.modeling_rtc import RTCProcessor
-from lerobot.processor.delta_action_processor import to_absolute_actions
 from lerobot.utils.constants import (
     ACTION,
     ACTION_TOKEN_MASK,
     ACTION_TOKENS,
     OBS_LANGUAGE_ATTENTION_MASK,
     OBS_LANGUAGE_TOKENS,
-    OBS_STATE,
     OPENPI_ATTENTION_MASK_VALUE,
 )
 
@@ -1317,12 +1315,6 @@ class PI0FastPolicy(PreTrainedPolicy):
             action_tokens, action_horizon=action_horizon, action_dim=action_dim
         )
 
-        if self.config.use_delta_actions and OBS_STATE in batch:
-            state = pad_vector(batch[OBS_STATE], self.config.max_state_dim)
-            continuous_actions = to_absolute_actions(
-                continuous_actions, state, [True] * continuous_actions.shape[-1]
-        )
-
         return continuous_actions
 
     def forward(self, batch: dict[str, Tensor]) -> tuple[Tensor, dict]:

src/lerobot/policies/pi0_fast/processor_pi0_fast.py

@@ -27,7 +27,6 @@ from lerobot.policies.pi0_fast.modeling_pi0_fast import pad_vector
 from lerobot.processor import (
     ActionTokenizerProcessorStep,
     AddBatchDimensionProcessorStep,
-    DeltaActionsProcessorStep,
     DeviceProcessorStep,
     NormalizerProcessorStep,
     PolicyAction,
@@ -148,7 +147,6 @@ def make_pi0_fast_pre_post_processors(
             padding_side="right",
             padding="max_length",
         ),
-        DeltaActionsProcessorStep(enabled=config.use_delta_actions),
         ActionTokenizerProcessorStep(
             action_tokenizer_name=config.action_tokenizer_name,
             max_action_tokens=config.max_action_tokens,

src/lerobot/policies/smolvla/modeling_smolvla.py

@@ -378,16 +378,16 @@ class SmolVLAPolicy(PreTrainedPolicy):
         actions_is_pad = batch.get("actions_id_pad")
         loss_dict = {}
         losses = self.model.forward(images, img_masks, lang_tokens, lang_masks, state, actions, noise, time)
-        loss_dict["losses_after_forward"] = losses.clone().mean().item()
+        loss_dict["losses_after_forward"] = losses.clone()
 
         if actions_is_pad is not None:
             in_episode_bound = ~actions_is_pad
             losses = losses * in_episode_bound.unsqueeze(-1)
-            loss_dict["losses_after_in_ep_bound"] = losses.clone().mean().item()
+            loss_dict["losses_after_in_ep_bound"] = losses.clone()
 
         # Remove padding
         losses = losses[:, :, : self.config.max_action_dim]
-        loss_dict["losses_after_rm_padding"] = losses.clone().mean().item()
+        loss_dict["losses_after_rm_padding"] = losses.clone()
 
         if reduction == "none":
             # Return per-sample losses (B,) by averaging over time and action dims

src/lerobot/processor/__init__.py

@@ -28,14 +28,7 @@ from .core import (
     RobotObservation,
     TransitionKey,
 )
-from .delta_action_processor import (
-    AbsoluteActionsProcessorStep,
-    DeltaActionsProcessorStep,
-    MapDeltaActionToRobotActionStep,
-    MapTensorToDeltaActionDictStep,
-    to_absolute_actions,
-    to_delta_actions,
-)
+from .delta_action_processor import MapDeltaActionToRobotActionStep, MapTensorToDeltaActionDictStep
 from .device_processor import DeviceProcessorStep
 from .factory import (
     make_default_processors,
@@ -104,8 +97,6 @@ __all__ = [
     "make_default_teleop_action_processor",
     "make_default_robot_action_processor",
     "make_default_robot_observation_processor",
-    "AbsoluteActionsProcessorStep",
-    "DeltaActionsProcessorStep",
     "MapDeltaActionToRobotActionStep",
     "MapTensorToDeltaActionDictStep",
     "NormalizerProcessorStep",
@@ -135,8 +126,6 @@ __all__ = [
     "transition_to_batch",
     "TransitionKey",
     "TruncatedProcessorStep",
-    "to_absolute_actions",
-    "to_delta_actions",
     "UnnormalizerProcessorStep",
     "VanillaObservationProcessorStep",
 ]

src/lerobot/processor/delta_action_processor.py

@@ -14,54 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections.abc import Sequence
-from dataclasses import dataclass, field
-from typing import Any
-
-import torch
-from torch import Tensor
+from dataclasses import dataclass
 
 from lerobot.configs.types import FeatureType, PipelineFeatureType, PolicyFeature
-from lerobot.utils.constants import OBS_STATE
 
-from .core import EnvTransition, PolicyAction, RobotAction, TransitionKey
-from .pipeline import ActionProcessorStep, ProcessorStep, ProcessorStepRegistry, RobotActionProcessorStep
-
-
-def to_delta_actions(actions: Tensor, state: Tensor, mask: Sequence[bool]) -> Tensor:
-    """Convert absolute actions to delta: delta = action - state (for masked dims).
-
-    Args:
-        actions: (B, T, action_dim) or (B, action_dim).
-        state: (B, state_dim). Broadcast across time dimension.
-        mask: Which dims to convert. Can be shorter than action_dim.
-    """
-    mask_t = torch.tensor(mask, dtype=actions.dtype, device=actions.device)
-    dims = mask_t.shape[0]
-    state_offset = state[..., :dims] * mask_t
-    if actions.ndim == 3:
-        state_offset = state_offset.unsqueeze(-2)
-    actions = actions.clone()
-    actions[..., :dims] -= state_offset
-    return actions
-
-
-def to_absolute_actions(actions: Tensor, state: Tensor, mask: Sequence[bool]) -> Tensor:
-    """Convert delta actions back to absolute: absolute = delta + state (for masked dims).
-
-    Args:
-        actions: (B, T, action_dim) or (B, action_dim).
-        state: (B, state_dim). Broadcast across time dimension.
-        mask: Which dims to convert. Can be shorter than action_dim.
-    """
-    mask_t = torch.tensor(mask, dtype=actions.dtype, device=actions.device)
-    dims = mask_t.shape[0]
-    state_offset = state[..., :dims] * mask_t
-    if actions.ndim == 3:
-        state_offset = state_offset.unsqueeze(-2)
-    actions = actions.clone()
-    actions[..., :dims] += state_offset
-    return actions
+from .core import PolicyAction, RobotAction
+from .pipeline import ActionProcessorStep, ProcessorStepRegistry, RobotActionProcessorStep
 
 
 @ProcessorStepRegistry.register("map_tensor_to_delta_action_dict")
@@ -183,126 +141,3 @@ class MapDeltaActionToRobotActionStep(RobotActionProcessorStep):
             )
 
         return features
-
-
-@ProcessorStepRegistry.register("delta_actions_processor")
-@dataclass
-class DeltaActionsProcessorStep(ProcessorStep):
-    """Converts absolute actions to delta actions (action -= state) for masked dimensions.
-
-    Mirrors OpenPI's DeltaActions transform. Applied during preprocessing so the model
-    trains on relative offsets instead of absolute positions.
-    Caches the last seen state so a paired AbsoluteActionsProcessorStep can reverse
-    the conversion during postprocessing.
-
-    Attributes:
-        enabled: Whether to apply the delta conversion.
-        exclude_joints: Joint names to keep absolute (not converted to delta).
-        action_names: Action dimension names from dataset metadata, used to build
-            the mask from exclude_joints. If None, all dims are converted.
-    """
-
-    enabled: bool = False
-    exclude_joints: list[str] = field(default_factory=list)
-    action_names: list[str] | None = None
-    _last_state: torch.Tensor | None = field(default=None, init=False, repr=False)
-
-    def _build_mask(self, action_dim: int) -> list[bool]:
-        if not self.exclude_joints or self.action_names is None:
-            return [True] * action_dim
-
-        exclude_tokens = [str(name).lower() for name in self.exclude_joints if name]
-        if not exclude_tokens:
-            return [True] * action_dim
-
-        mask = []
-        for name in self.action_names[:action_dim]:
-            action_name = str(name).lower()
-            is_excluded = any(token == action_name or token in action_name for token in exclude_tokens)
-            mask.append(not is_excluded)
-
-        if len(mask) < action_dim:
-            mask.extend([True] * (action_dim - len(mask)))
-
-        return mask
-
-    def __call__(self, transition: EnvTransition) -> EnvTransition:
-        observation = transition.get(TransitionKey.OBSERVATION, {})
-        state = observation.get(OBS_STATE) if observation else None
-
-        # Always cache state for the paired AbsoluteActionsProcessorStep
-        if state is not None:
-            self._last_state = state
-
-        if not self.enabled:
-            return transition
-
-        new_transition = transition.copy()
-        action = new_transition.get(TransitionKey.ACTION)
-        if action is None or state is None:
-            return new_transition
-
-        mask = self._build_mask(action.shape[-1])
-        new_transition[TransitionKey.ACTION] = to_delta_actions(action, state, mask)
-        return new_transition
-
-    def get_config(self) -> dict[str, Any]:
-        return {"enabled": self.enabled, "exclude_joints": self.exclude_joints}
-
-    def transform_features(
-        self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-    ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-        return features
-
-
-@ProcessorStepRegistry.register("absolute_actions_processor")
-@dataclass
-class AbsoluteActionsProcessorStep(ProcessorStep):
-    """Converts delta actions back to absolute actions (action += state) for all dimensions.
-
-    Mirrors OpenPI's AbsoluteActions transform. Applied during postprocessing so
-    predicted deltas are converted back to absolute positions for execution.
-    Reads the cached state from its paired DeltaActionsProcessorStep.
-
-    Attributes:
-        enabled: Whether to apply the absolute conversion.
-        delta_step: Reference to the paired DeltaActionsProcessorStep that caches state.
-    """
-
-    enabled: bool = False
-    delta_step: DeltaActionsProcessorStep | None = field(default=None, repr=False)
-
-    def __call__(self, transition: EnvTransition) -> EnvTransition:
-        if not self.enabled:
-            return transition
-
-        if self.delta_step is None:
-            raise RuntimeError(
-                "AbsoluteActionsProcessorStep requires a paired DeltaActionsProcessorStep "
-                "but delta_step is None. Ensure delta_step is set when constructing the postprocessor."
-            )
-
-        if self.delta_step._last_state is None:
-            raise RuntimeError(
-                "AbsoluteActionsProcessorStep requires state from DeltaActionsProcessorStep "
-                "but no state has been cached. Ensure the preprocessor runs before the postprocessor."
-            )
-
-        new_transition = transition.copy()
-        action = new_transition.get(TransitionKey.ACTION)
-        if action is None:
-            return new_transition
-
-        mask = self.delta_step._build_mask(action.shape[-1])
-        new_transition[TransitionKey.ACTION] = to_absolute_actions(
-            action, self.delta_step._last_state, mask
-        )
-        return new_transition
-
-    def get_config(self) -> dict[str, Any]:
-        return {"enabled": self.enabled}
-
-    def transform_features(
-        self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-    ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-        return features

src/lerobot/processor/env_processor.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass
 
 import torch
 
-from lerobot.configs.types import FeatureType, PipelineFeatureType, PolicyFeature
+from lerobot.configs.types import PipelineFeatureType, PolicyFeature
 from lerobot.utils.constants import OBS_IMAGES, OBS_PREFIX, OBS_STATE, OBS_STR
 
 from .pipeline import ObservationProcessorStep, ProcessorStepRegistry
@@ -92,7 +92,7 @@ class LiberoProcessorStep(ObservationProcessorStep):
 
         # copy over non-STATE features
         for ft, feats in features.items():
-            if ft != FeatureType.STATE:
+            if ft != PipelineFeatureType.STATE:
                 new_features[ft] = feats.copy()
 
         # rebuild STATE features
@@ -100,11 +100,13 @@ class LiberoProcessorStep(ObservationProcessorStep):
 
         # add our new flattened state
         state_feats[OBS_STATE] = PolicyFeature(
-            type=FeatureType.STATE,
+            key=OBS_STATE,
             shape=(8,),  # [eef_pos(3), axis_angle(3), gripper(2)]
+            dtype="float32",
+            description=("Concatenated end-effector position (3), axis-angle (3), and gripper qpos (2)."),
         )
 
-        new_features[FeatureType.STATE] = state_feats
+        new_features[PipelineFeatureType.STATE] = state_feats
 
         return new_features
 

src/lerobot/processor/normalize_processor.py

@@ -331,9 +331,11 @@ class _NormalizationMixin:
                 )
 
             mean, std = stats["mean"], stats["std"]
+            # Avoid division by zero by adding a small epsilon.
+            denom = std + self.eps
             if inverse:
-                return tensor * (std + 1e-6) + mean
-            return (tensor - mean) / (std + 1e-6)
+                return tensor * std + mean
+            return (tensor - mean) / denom
 
         if norm_mode == NormalizationMode.MIN_MAX:
             min_val = stats.get("min", None)
@@ -365,7 +367,11 @@ class _NormalizationMixin:
                     "QUANTILES normalization mode requires q01 and q99 stats, please update the dataset with the correct stats using the `augment_dataset_quantile_stats.py` script"
                 )
 
-            denom = q99 - q01 + 1e-6
+            denom = q99 - q01
+            # Avoid division by zero by adding epsilon when quantiles are identical
+            denom = torch.where(
+                denom == 0, torch.tensor(self.eps, device=tensor.device, dtype=tensor.dtype), denom
+            )
             if inverse:
                 return (tensor + 1.0) * denom / 2.0 + q01
             return 2.0 * (tensor - q01) / denom - 1.0

src/lerobot/processor/pipeline.py

@@ -413,7 +413,7 @@ class DataProcessorPipeline(HubMixin, Generic[TInput, TOutput]):
         Args:
             save_directory: The directory where the pipeline will be saved. If None, saves to
                 HF_LEROBOT_HOME/processors/{sanitized_pipeline_name}.
-            repo_id: ID of your repository on the Hub. Used only if `push_to_hub=true`.
+            repo_id: ID of your repository on the Hub. Used only if `push_to_hub=True`.
             push_to_hub: Whether or not to push your object to the Hugging Face Hub after saving it.
             card_kwargs: Additional arguments passed to the card template to customize the card.
             config_filename: The name of the JSON configuration file. If None, a name is

src/lerobot/robots/bi_openarm_follower/bi_openarm_follower.py

@@ -19,7 +19,6 @@ from functools import cached_property
 
 from lerobot.processor import RobotAction, RobotObservation
 from lerobot.robots.openarm_follower import OpenArmFollower, OpenArmFollowerConfig
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
 
 from ..robot import Robot
 from .config_bi_openarm_follower import BiOpenArmFollowerConfig
@@ -113,7 +112,6 @@ class BiOpenArmFollower(Robot):
     def is_connected(self) -> bool:
         return self.left_arm.is_connected and self.right_arm.is_connected
 
-    @check_if_already_connected
     def connect(self, calibrate: bool = True) -> None:
         self.left_arm.connect(calibrate)
         self.right_arm.connect(calibrate)
@@ -135,7 +133,6 @@ class BiOpenArmFollower(Robot):
             "Motor ID configuration is typically done via manufacturer tools for CAN motors."
         )
 
-    @check_if_not_connected
     def get_observation(self) -> RobotObservation:
         obs_dict = {}
 
@@ -149,7 +146,6 @@ class BiOpenArmFollower(Robot):
 
         return obs_dict
 
-    @check_if_not_connected
     def send_action(
         self,
         action: RobotAction,
@@ -174,7 +170,6 @@ class BiOpenArmFollower(Robot):
 
         return {**prefixed_sent_action_left, **prefixed_sent_action_right}
 
-    @check_if_not_connected
     def disconnect(self):
         self.left_arm.disconnect()
         self.right_arm.disconnect()

src/lerobot/robots/bi_so_follower/bi_so_follower.py

@@ -19,7 +19,6 @@ from functools import cached_property
 
 from lerobot.processor import RobotAction, RobotObservation
 from lerobot.robots.so_follower import SOFollower, SOFollowerRobotConfig
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
 
 from ..robot import Robot
 from .config_bi_so_follower import BiSOFollowerConfig
@@ -97,7 +96,6 @@ class BiSOFollower(Robot):
     def is_connected(self) -> bool:
         return self.left_arm.is_connected and self.right_arm.is_connected
 
-    @check_if_already_connected
     def connect(self, calibrate: bool = True) -> None:
         self.left_arm.connect(calibrate)
         self.right_arm.connect(calibrate)
@@ -118,7 +116,6 @@ class BiSOFollower(Robot):
         self.left_arm.setup_motors()
         self.right_arm.setup_motors()
 
-    @check_if_not_connected
     def get_observation(self) -> RobotObservation:
         obs_dict = {}
 
@@ -132,7 +129,6 @@ class BiSOFollower(Robot):
 
         return obs_dict
 
-    @check_if_not_connected
     def send_action(self, action: RobotAction) -> RobotAction:
         # Remove "left_" prefix
         left_action = {
@@ -152,7 +148,6 @@ class BiSOFollower(Robot):
 
         return {**prefixed_sent_action_left, **prefixed_sent_action_right}
 
-    @check_if_not_connected
     def disconnect(self):
         self.left_arm.disconnect()
         self.right_arm.disconnect()

src/lerobot/robots/openarm_follower/openarm_follower.py

@@ -23,7 +23,7 @@ from lerobot.cameras.utils import make_cameras_from_configs
 from lerobot.motors import Motor, MotorCalibration, MotorNormMode
 from lerobot.motors.damiao import DamiaoMotorsBus
 from lerobot.processor import RobotAction, RobotObservation
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 from ..robot import Robot
 from ..utils import ensure_safe_goal_position
@@ -119,7 +119,6 @@ class OpenArmFollower(Robot):
         """Check if robot is connected."""
         return self.bus.is_connected and all(cam.is_connected for cam in self.cameras.values())
 
-    @check_if_already_connected
     def connect(self, calibrate: bool = True) -> None:
         """
         Connect to the robot and optionally calibrate.
@@ -127,6 +126,8 @@ class OpenArmFollower(Robot):
         We assume that at connection time, the arms are in a safe rest position,
         and torque can be safely disabled to run calibration if needed.
         """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} already connected")
 
         # Connect to CAN bus
         logger.info(f"Connecting arm on {self.config.port}...")
@@ -218,7 +219,6 @@ class OpenArmFollower(Robot):
             "Motor ID configuration is typically done via manufacturer tools for CAN motors."
         )
 
-    @check_if_not_connected
     def get_observation(self) -> RobotObservation:
         """
         Get current observation from robot including position, velocity, and torque.
@@ -228,6 +228,9 @@ class OpenArmFollower(Robot):
         """
         start = time.perf_counter()
 
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
         obs_dict: dict[str, Any] = {}
 
         states = self.bus.sync_read_all_states()
@@ -250,7 +253,6 @@ class OpenArmFollower(Robot):
 
         return obs_dict
 
-    @check_if_not_connected
     def send_action(
         self,
         action: RobotAction,
@@ -270,6 +272,8 @@ class OpenArmFollower(Robot):
         Returns:
             The action actually sent (potentially clipped)
         """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         goal_pos = {key.removesuffix(".pos"): val for key, val in action.items() if key.endswith(".pos")}
 
@@ -329,9 +333,10 @@ class OpenArmFollower(Robot):
 
         return {f"{motor}.pos": val for motor, val in goal_pos.items()}
 
-    @check_if_not_connected
     def disconnect(self):
         """Disconnect from robot."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         # Disconnect CAN bus
         self.bus.disconnect(self.config.disable_torque_on_disconnect)

src/lerobot/robots/so_follower/config_so_follower.py

@@ -40,7 +40,7 @@ class SOFollowerConfig:
     cameras: dict[str, CameraConfig] = field(default_factory=dict)
 
     # Set to `True` for backward compatibility with previous policies/dataset
-    use_degrees: bool = True
+    use_degrees: bool = False
 
 
 @RobotConfig.register_subclass("so101_follower")

src/lerobot/scripts/lerobot_edit_dataset.py

@@ -109,14 +109,11 @@ Using JSON config file:
         --config_path path/to/edit_config.json
 """
 
-import abc
 import logging
 import shutil
 from dataclasses import dataclass
 from pathlib import Path
 
-import draccus
-
 from lerobot.configs import parser
 from lerobot.datasets.dataset_tools import (
     convert_image_to_video_dataset,
@@ -132,46 +129,39 @@ from lerobot.utils.utils import init_logging
 
 
 @dataclass
-class OperationConfig(draccus.ChoiceRegistry, abc.ABC):
-    @property
-    def type(self) -> str:
-        return self.get_choice_name(self.__class__)
-
-
-@OperationConfig.register_subclass("delete_episodes")
-@dataclass
-class DeleteEpisodesConfig(OperationConfig):
+class DeleteEpisodesConfig:
+    type: str = "delete_episodes"
     episode_indices: list[int] | None = None
 
 
-@OperationConfig.register_subclass("split")
 @dataclass
-class SplitConfig(OperationConfig):
+class SplitConfig:
+    type: str = "split"
     splits: dict[str, float | list[int]] | None = None
 
 
-@OperationConfig.register_subclass("merge")
 @dataclass
-class MergeConfig(OperationConfig):
+class MergeConfig:
+    type: str = "merge"
     repo_ids: list[str] | None = None
 
 
-@OperationConfig.register_subclass("remove_feature")
 @dataclass
-class RemoveFeatureConfig(OperationConfig):
+class RemoveFeatureConfig:
+    type: str = "remove_feature"
     feature_names: list[str] | None = None
 
 
-@OperationConfig.register_subclass("modify_tasks")
 @dataclass
-class ModifyTasksConfig(OperationConfig):
+class ModifyTasksConfig:
+    type: str = "modify_tasks"
     new_task: str | None = None
     episode_tasks: dict[str, str] | None = None
 
 
-@OperationConfig.register_subclass("convert_image_to_video")
 @dataclass
-class ConvertImageToVideoConfig(OperationConfig):
+class ConvertImageToVideoConfig:
+    type: str = "convert_image_to_video"
     output_dir: str | None = None
     vcodec: str = "libsvtav1"
     pix_fmt: str = "yuv420p"
@@ -187,7 +177,14 @@ class ConvertImageToVideoConfig(OperationConfig):
 @dataclass
 class EditDatasetConfig:
     repo_id: str
-    operation: OperationConfig
+    operation: (
+        DeleteEpisodesConfig
+        | SplitConfig
+        | MergeConfig
+        | RemoveFeatureConfig
+        | ModifyTasksConfig
+        | ConvertImageToVideoConfig
+    )
     root: str | None = None
     new_repo_id: str | None = None
     push_to_hub: bool = False
@@ -453,8 +450,10 @@ def edit_dataset(cfg: EditDatasetConfig) -> None:
     elif operation_type == "convert_image_to_video":
         handle_convert_image_to_video(cfg)
     else:
-        available = ", ".join(OperationConfig.get_known_choices())
-        raise ValueError(f"Unknown operation: {operation_type}\nAvailable operations: {available}")
+        raise ValueError(
+            f"Unknown operation type: {operation_type}\n"
+            f"Available operations: delete_episodes, split, merge, remove_feature, modify_tasks, convert_image_to_video"
+        )
 
 
 def main() -> None:

src/lerobot/scripts/lerobot_mirror_dataset.py

@@ -1,366 +0,0 @@
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Mirror a bimanual robot dataset by swapping left/right arms and inverting joint values.
-
-This script creates a mirrored version of a dataset where:
-1. Left and right arm observations/actions are swapped
-2. Joint values are inverted according to a mirroring mask
-3. Video frames are horizontally flipped
-
-Example usage:
-```shell
-python -m lerobot.scripts.lerobot_mirror_dataset \
-    --repo_id=pepijn/openarm_bimanual \
-    --output_repo_id=pepijn/openarm_bimanual_mirrored
-```
-"""
-
-import argparse
-import logging
-import os
-import subprocess
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-
-from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata
-from lerobot.datasets.utils import (
-    DATA_DIR,
-    DEFAULT_DATA_PATH,
-    write_info,
-    write_stats,
-    write_tasks,
-)
-from lerobot.utils.constants import HF_LEROBOT_HOME
-
-logger = logging.getLogger(__name__)
-
-OPENARM_MIRRORING_MASK = {
-    "joint_1": -1,  # Pan - invert
-    "joint_2": -1,  # Lift - invert
-    "joint_3": -1,  # Roll - invert
-    "joint_4": 1,   # Elbow - no invert
-    "joint_5": -1,  # W-Roll - invert
-    "joint_6": -1,  # W-Pitch - invert
-    "joint_7": -1,  # W-Yaw - invert
-    "gripper": 1,   # Gripper - no invert
-}
-
-
-def get_mirroring_mask(robot_type: str) -> dict[str, int]:
-    """Get the mirroring mask for a given robot type."""
-    if robot_type in ["bi_openarm_follower", "openarm_follower", "bi_openarms_follower", "openarms_follower"]:
-        return OPENARM_MIRRORING_MASK
-    raise ValueError(f"Unknown robot type: {robot_type}. Add a mirroring mask for this robot.")
-
-
-def swap_left_right_name(name: str) -> str:
-    """Swap 'left' and 'right' in a feature name."""
-    # Use placeholder to avoid double-swap
-    result = name.replace("left_", "LEFT_PLACEHOLDER_")
-    result = result.replace("right_", "left_")
-    result = result.replace("LEFT_PLACEHOLDER_", "right_")
-    return result
-
-
-def mirror_feature_names(names: list[str]) -> tuple[list[str], dict[int, int]]:
-    """Mirror feature names by swapping left/right and return the new names and index mapping."""
-    mirrored_names = [swap_left_right_name(n) for n in names]
-    old_to_new_idx = {}
-    for old_idx, old_name in enumerate(names):
-        new_name = swap_left_right_name(old_name)
-        new_idx = mirrored_names.index(new_name)
-        old_to_new_idx[old_idx] = new_idx
-    return mirrored_names, old_to_new_idx
-
-
-def apply_mirroring_mask(
-    value: float,
-    feature_name: str,
-    mirroring_mask: dict[str, int],
-) -> float:
-    """Apply mirroring mask to a joint value."""
-    name_without_prefix = feature_name.split("_", 1)[1] if "_" in feature_name else feature_name
-    joint_name = name_without_prefix.split(".")[0]
-    if joint_name in mirroring_mask:
-        return value * mirroring_mask[joint_name]
-    return value
-
-
-def mirror_array(
-    array: np.ndarray,
-    names: list[str],
-    mirroring_mask: dict[str, int],
-) -> np.ndarray:
-    """Mirror an array of values (action or state) by swapping left/right and applying mask."""
-    mirrored_names, idx_mapping = mirror_feature_names(names)
-    result = np.zeros_like(array)
-    for old_idx, new_idx in idx_mapping.items():
-        old_name = names[old_idx]
-        new_name = mirrored_names[new_idx]
-        value = array[old_idx]
-        mirrored_value = apply_mirroring_mask(value, new_name, mirroring_mask)
-        result[new_idx] = mirrored_value
-    return result
-
-
-def flip_video_frames(
-    input_path: Path,
-    output_path: Path,
-    fps: float,
-    vcodec: str = "libsvtav1",
-):
-    """Flip video frames horizontally using FFmpeg with same settings as encode_video_frames."""
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    cmd = [
-        "ffmpeg", "-y", "-i", str(input_path),
-        "-vf", "hflip",
-        "-c:v", vcodec,
-        "-g", "2",
-        "-crf", "30",
-        "-r", str(int(fps)),
-        "-pix_fmt", "yuv420p",
-        "-loglevel", "error",
-    ]
-    if vcodec == "libsvtav1":
-        cmd.extend(["-preset", "12"])
-    cmd.append(str(output_path))
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"FFmpeg failed: {result.stderr}")
-
-
-def mirror_dataset(
-    repo_id: str,
-    output_repo_id: str,
-    root: str | Path | None = None,
-    output_root: str | Path | None = None,
-    mirroring_mask: dict[str, int] | None = None,
-    vcodec: str = "libsvtav1",
-    num_workers: int | None = None,
-) -> LeRobotDataset:
-    """Mirror a bimanual robot dataset."""
-    logger.info(f"Loading dataset: {repo_id}")
-    dataset = LeRobotDataset(repo_id, root=root)
-
-    if mirroring_mask is None:
-        robot_type = dataset.meta.robot_type or "bi_openarms_follower"
-        mirroring_mask = get_mirroring_mask(robot_type)
-        logger.info(f"Using mirroring mask for robot type: {robot_type}")
-
-    output_root = Path(output_root) if output_root else HF_LEROBOT_HOME / output_repo_id
-
-    mirrored_features = {}
-    for key, feat in dataset.meta.features.items():
-        new_key = swap_left_right_name(key)
-        new_feat = feat.copy()
-        if "names" in new_feat and new_feat["names"]:
-            new_feat["names"] = [swap_left_right_name(n) for n in new_feat["names"]]
-        mirrored_features[new_key] = new_feat
-
-    logger.info("Creating mirrored dataset metadata...")
-    new_meta = LeRobotDatasetMetadata.create(
-        repo_id=output_repo_id,
-        fps=dataset.meta.fps,
-        features=mirrored_features,
-        robot_type=dataset.meta.robot_type,
-        root=output_root,
-        use_videos=len(dataset.meta.video_keys) > 0,
-    )
-
-    if dataset.meta.tasks is not None:
-        write_tasks(dataset.meta.tasks, new_meta.root)
-        new_meta.tasks = dataset.meta.tasks.copy()
-
-    _mirror_data(dataset, new_meta, mirroring_mask)
-    _mirror_videos(dataset, new_meta, vcodec, num_workers)
-    _copy_episodes_metadata(dataset, new_meta)
-
-    logger.info(f"Mirrored dataset saved to: {output_root}")
-    return LeRobotDataset(output_repo_id, root=output_root)
-
-
-def _mirror_data(
-    src_dataset: LeRobotDataset,
-    dst_meta: LeRobotDatasetMetadata,
-    mirroring_mask: dict[str, int],
-) -> None:
-    """Mirror parquet data files."""
-    data_dir = src_dataset.root / DATA_DIR
-    parquet_files = sorted(data_dir.glob("*/*.parquet"))
-
-    if not parquet_files:
-        raise ValueError(f"No parquet files found in {data_dir}")
-
-    action_names = src_dataset.meta.features.get("action", {}).get("names", [])
-    state_names = src_dataset.meta.features.get("observation.state", {}).get("names", [])
-
-    for src_path in tqdm(parquet_files, desc="Mirroring data files"):
-        df = pd.read_parquet(src_path).reset_index(drop=True)
-        relative_path = src_path.relative_to(src_dataset.root)
-        chunk_dir = relative_path.parts[1]
-        file_name = relative_path.parts[2]
-        chunk_idx = int(chunk_dir.split("-")[1])
-        file_idx = int(file_name.split("-")[1].split(".")[0])
-
-        if "action" in df.columns and action_names:
-            actions = np.stack(df["action"].values)
-            mirrored_actions = np.array([
-                mirror_array(row, action_names, mirroring_mask) for row in actions
-            ])
-            df["action"] = list(mirrored_actions)
-
-        if "observation.state" in df.columns and state_names:
-            states = np.stack(df["observation.state"].values)
-            mirrored_states = np.array([
-                mirror_array(row, state_names, mirroring_mask) for row in states
-            ])
-            df["observation.state"] = list(mirrored_states)
-
-        dst_path = dst_meta.root / DEFAULT_DATA_PATH.format(chunk_index=chunk_idx, file_index=file_idx)
-        dst_path.parent.mkdir(parents=True, exist_ok=True)
-        df.to_parquet(dst_path, index=False)
-
-
-def _mirror_videos(
-    src_dataset: LeRobotDataset,
-    dst_meta: LeRobotDatasetMetadata,
-    vcodec: str,
-    num_workers: int | None = None,
-) -> None:
-    """Mirror video files by flipping horizontally and swapping left/right names."""
-    if not src_dataset.meta.video_keys:
-        return
-
-    video_tasks = []
-    for old_video_key in src_dataset.meta.video_keys:
-        new_video_key = swap_left_right_name(old_video_key)
-        for ep_idx in range(src_dataset.meta.total_episodes):
-            try:
-                src_path = src_dataset.root / src_dataset.meta.get_video_file_path(ep_idx, old_video_key)
-                dst_relative = src_dataset.meta.get_video_file_path(ep_idx, old_video_key)
-                dst_relative_str = str(dst_relative).replace(old_video_key, new_video_key)
-                dst_path = dst_meta.root / dst_relative_str
-                if src_path.exists():
-                    video_tasks.append((src_path, dst_path))
-            except KeyError:
-                continue
-
-    def process_video(task, pbar):
-        src_path, dst_path = task
-        pbar.set_postfix_str(src_path.name)
-        flip_video_frames(src_path, dst_path, src_dataset.meta.fps, vcodec)
-        return src_path
-
-    if num_workers is None:
-        num_workers = os.cpu_count() or 16
-    num_workers = min(len(video_tasks), num_workers)
-    logger.info(f"Processing {len(video_tasks)} videos with {num_workers} workers")
-    with tqdm(total=len(video_tasks), desc="Mirroring videos") as pbar:
-        with ThreadPoolExecutor(max_workers=num_workers) as executor:
-            futures = {executor.submit(process_video, t, pbar): t for t in video_tasks}
-            for future in as_completed(futures):
-                task = futures[future]
-                future.result()
-                pbar.set_postfix_str(f"done: {task[0].name}")
-                pbar.update(1)
-
-
-def _copy_episodes_metadata(
-    src_dataset: LeRobotDataset,
-    dst_meta: LeRobotDatasetMetadata,
-) -> None:
-    """Copy episodes metadata with swapped video keys."""
-    episodes_dir = src_dataset.root / "meta/episodes"
-    dst_episodes_dir = dst_meta.root / "meta/episodes"
-
-    if episodes_dir.exists():
-        dst_episodes_dir.mkdir(parents=True, exist_ok=True)
-        for src_parquet in episodes_dir.glob("*/*.parquet"):
-            df = pd.read_parquet(src_parquet)
-            columns_to_rename = {}
-            for col in df.columns:
-                if col.startswith("videos/"):
-                    parts = col.split("/")
-                    if len(parts) >= 2:
-                        video_key = parts[1]
-                        new_video_key = swap_left_right_name(video_key)
-                        new_col = col.replace(f"videos/{video_key}/", f"videos/{new_video_key}/")
-                        columns_to_rename[col] = new_col
-            if columns_to_rename:
-                df = df.rename(columns=columns_to_rename)
-            dst_parquet = dst_episodes_dir / src_parquet.relative_to(episodes_dir)
-            dst_parquet.parent.mkdir(parents=True, exist_ok=True)
-            df.to_parquet(dst_parquet, index=False)
-
-    dst_meta.info.update({
-        "total_episodes": src_dataset.meta.total_episodes,
-        "total_frames": src_dataset.meta.total_frames,
-        "total_tasks": src_dataset.meta.total_tasks,
-        "total_videos": src_dataset.meta.total_videos,
-        "total_chunks": src_dataset.meta.total_chunks,
-    })
-    write_info(dst_meta.info, dst_meta.root)
-
-    if src_dataset.meta.stats is not None:
-        mirrored_stats = _mirror_stats(src_dataset.meta.stats)
-        write_stats(mirrored_stats, dst_meta.root)
-
-
-def _mirror_stats(stats: dict) -> dict:
-    """Mirror stats by swapping left/right in feature names."""
-    mirrored = {}
-    for key, value in stats.items():
-        new_key = swap_left_right_name(key)
-        if isinstance(value, dict):
-            mirrored[new_key] = _mirror_stats(value)
-        else:
-            mirrored[new_key] = value
-    return mirrored
-
-
-def main():
-    logging.basicConfig(level=logging.INFO)
-    parser = argparse.ArgumentParser(description="Mirror a bimanual robot dataset")
-    parser.add_argument("--repo_id", type=str, required=True, help="Source dataset repo_id")
-    parser.add_argument("--output_repo_id", type=str, required=True, help="Output dataset repo_id")
-    parser.add_argument("--root", type=str, default=None, help="Source dataset root directory")
-    parser.add_argument("--output_root", type=str, default=None, help="Output dataset root directory")
-    parser.add_argument("--vcodec", type=str, default="libsvtav1", help="Video codec (libsvtav1, h264, hevc)")
-    parser.add_argument("--num_workers", type=int, default=None, help="Number of parallel workers for video processing")
-    parser.add_argument("--push-to-hub", action="store_true", help="Push mirrored dataset to HuggingFace Hub")
-    args = parser.parse_args()
-
-    dataset = mirror_dataset(
-        repo_id=args.repo_id,
-        output_repo_id=args.output_repo_id,
-        root=args.root,
-        output_root=args.output_root,
-        vcodec=args.vcodec,
-        num_workers=args.num_workers,
-    )
-
-    if getattr(args, "push_to_hub", False):
-        logger.info(f"Pushing dataset to HuggingFace Hub: {args.output_repo_id}")
-        dataset.push_to_hub()
-
-
-if __name__ == "__main__":
-    main()
-

src/lerobot/scripts/lerobot_record.py

@@ -184,6 +184,9 @@ class DatasetRecordConfig:
     vcodec: str = "libsvtav1"
     # Rename map for the observation to override the image and state keys
     rename_map: dict[str, str] = field(default_factory=dict)
+    # Expert noise injection scale. Noise is added to robot actions but not recorded in dataset.
+    # This forces recovery behavior for more robust learned policies. 0.0 means no noise. #https://arxiv.org/pdf/1703.09327, https://arxiv.org/abs/2507.09061
+    noise_scale: float = 0.0
 
     def __post_init__(self):
         if self.single_task is None:
@@ -283,6 +286,7 @@ def record_loop(
     single_task: str | None = None,
     display_data: bool = False,
     display_compressed_images: bool = False,
+    noise_scale: float = 0.0,
 ):
     if dataset is not None and dataset.fps != fps:
         raise ValueError(f"The dataset fps should be equal to requested fps ({dataset.fps} != {fps}).")
@@ -380,18 +384,27 @@ def record_loop(
             action_values = act_processed_teleop
             robot_action_to_send = robot_action_processor((act_processed_teleop, obs))
 
+        # Write clean action to dataset (before noise injection)
+        if dataset is not None:
+            action_frame = build_dataset_frame(dataset.features, action_values, prefix=ACTION)
+            frame = {**observation_frame, **action_frame, "task": single_task}
+            dataset.add_frame(frame)
+
+        # Expert noise injection: add noise to motor commands but not to recorded labels
+        if noise_scale > 0:
+            import torch
+
+            for key in robot_action_to_send:
+                if isinstance(robot_action_to_send[key], torch.Tensor):
+                    noise = torch.randn_like(robot_action_to_send[key]) * noise_scale
+                    robot_action_to_send[key] = robot_action_to_send[key] + noise
+
         # Send action to robot
         # Action can eventually be clipped using `max_relative_target`,
         # so action actually sent is saved in the dataset. action = postprocessor.process(action)
         # TODO(steven, pepijn, adil): we should use a pipeline step to clip the action, so the sent action is the action that we input to the robot.
         _sent_action = robot.send_action(robot_action_to_send)
 
-        # Write to dataset
-        if dataset is not None:
-            action_frame = build_dataset_frame(dataset.features, action_values, prefix=ACTION)
-            frame = {**observation_frame, **action_frame, "task": single_task}
-            dataset.add_frame(frame)
-
         if display_data:
             log_rerun_data(
                 observation=obs_processed, action=action_values, compress_images=display_compressed_images
@@ -510,6 +523,7 @@ def record(cfg: RecordConfig) -> LeRobotDataset:
                     single_task=cfg.dataset.single_task,
                     display_data=cfg.display_data,
                     display_compressed_images=display_compressed_images,
+                    noise_scale=cfg.dataset.noise_scale,
                 )
 
                 # Execute a few seconds without recording to give time to manually reset the environment

src/lerobot/scripts/lerobot_setup_can.py

@@ -45,7 +45,7 @@ from dataclasses import dataclass, field
 
 import draccus
 
-from lerobot.utils.import_utils import _can_available
+from lerobot.utils.import_utils import is_package_available
 
 MOTOR_NAMES = {
     0x01: "joint_1",
@@ -336,7 +336,7 @@ def run_speed(cfg: CANSetupConfig):
 
 @draccus.wrap()
 def setup_can(cfg: CANSetupConfig):
-    if not _can_available:
+    if not is_package_available("can"):
         print("Error: python-can not installed. Install with: pip install python-can")
         sys.exit(1)
 

src/lerobot/scripts/lerobot_train.py

@@ -175,6 +175,8 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
         from accelerate.utils import DistributedDataParallelKwargs
 
         ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+        # Accelerate auto-detects the device based on the available hardware and ignores the policy.device setting.
+        # Force the device to be CPU when policy.device is set to CPU.
         force_cpu = cfg.policy.device == "cpu"
         accelerator = Accelerator(
             step_scheduler_with_optimizer=False,
@@ -209,98 +211,16 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
     torch.backends.cuda.matmul.allow_tf32 = True
 
     # Dataset loading synchronization: main process downloads first to avoid race conditions
-    delta_action_stats = None
     if is_main_process:
         logging.info("Creating dataset")
         dataset = make_dataset(cfg)
 
-        # Compute delta action stats BEFORE distributed sync to avoid NCCL timeout
-        if getattr(cfg.policy, "use_delta_actions", False):
-            import numpy as np
-
-            from lerobot.datasets.compute_stats import get_feature_stats
-            from lerobot.processor.delta_action_processor import DeltaActionsProcessorStep, to_delta_actions
-
-            chunk_size = cfg.policy.chunk_size
-            hf = dataset.hf_dataset
-            total_frames = len(hf)
-            sample_upper_bound = total_frames - chunk_size
-            if sample_upper_bound <= 0:
-                raise ValueError(
-                    f"Cannot compute delta action stats: total_frames={total_frames}, chunk_size={chunk_size}"
-                )
-
-            max_samples = min(100_000, sample_upper_bound)
-            indices = np.random.choice(sample_upper_bound, max_samples, replace=False)
-
-            action_names = dataset.meta.features.get("action", {}).get("names")
-            delta_mask_step = DeltaActionsProcessorStep(
-                enabled=True,
-                exclude_joints=getattr(cfg.policy, "delta_exclude_joints", []),
-                action_names=action_names,
-            )
-            delta_mask = delta_mask_step._build_mask(dataset.meta.features["action"]["shape"][0])
-            logging.info(
-                f"use_delta_actions is enabled — computing delta action stats "
-                f"from {max_samples} chunk samples (chunk_size={chunk_size})"
-            )
-
-            all_delta_actions = []
-            episode_indices = np.array(hf["episode_index"])
-            for idx in indices:
-                idx = int(idx)
-                ep_idx = episode_indices[idx]
-                end_idx = min(idx + chunk_size, total_frames)
-                if end_idx > idx and episode_indices[end_idx - 1] != ep_idx:
-                    continue
-
-                chunk_data = hf[idx:end_idx]
-                actions = torch.tensor(np.stack([np.asarray(a) for a in chunk_data["action"]])).float()
-                state = torch.tensor(np.asarray(chunk_data["observation.state"][0])).float()
-
-                delta = to_delta_actions(actions.unsqueeze(0), state.unsqueeze(0), delta_mask).squeeze(0)
-                all_delta_actions.append(delta.numpy())
-
-            if not all_delta_actions:
-                raise RuntimeError("Failed to compute delta action stats: no valid chunks found.")
-
-            all_delta = np.concatenate(all_delta_actions, axis=0)
-            delta_stats = get_feature_stats(all_delta, axis=0, keepdims=all_delta.ndim == 1)
-            delta_action_stats = delta_stats
-            dataset.meta.stats["action"] = delta_action_stats
-
-            norm_type = "UNKNOWN"
-            if hasattr(cfg.policy, "normalization_mapping"):
-                from lerobot.configs.types import NormalizationMode
-                action_norm = cfg.policy.normalization_mapping.get("ACTION", None)
-                norm_type = action_norm.value if action_norm else "UNKNOWN"
-
-            excluded_dims = len(delta_mask) - sum(delta_mask)
-            logging.info(
-                f"Delta action stats ({len(all_delta_actions)} chunks, {len(all_delta)} values, norm={norm_type}): "
-                f"delta_dims={sum(delta_mask)}/{len(delta_mask)} (excluded={excluded_dims}), "
-                f"mean={np.abs(delta_stats['mean']).mean():.4f}, std={delta_stats['std'].mean():.4f}, "
-                f"q01={delta_stats['q01'].mean():.4f}, q99={delta_stats['q99'].mean():.4f}"
-            )
-            if norm_type == "QUANTILES":
-                q_range = (delta_stats['q99'] - delta_stats['q01']).mean()
-                logging.info(f"  Quantile range (q99-q01): {q_range:.4f}")
-
     accelerator.wait_for_everyone()
 
     # Now all other processes can safely load the dataset
     if not is_main_process:
         dataset = make_dataset(cfg)
 
-    # Ensure all ranks use the exact same delta action stats.
-    if getattr(cfg.policy, "use_delta_actions", False):
-        if accelerator.num_processes > 1 and torch.distributed.is_initialized():
-            stats_list = [delta_action_stats]
-            torch.distributed.broadcast_object_list(stats_list, src=0)
-            delta_action_stats = stats_list[0]
-        if delta_action_stats is not None:
-            dataset.meta.stats["action"] = delta_action_stats
-
     # Create environment used for evaluating checkpoints during training on simulation data.
     # On real-world data, no need to create an environment as evaluations are done outside train.py,
     # using the eval.py instead, with gym_dora environment and dora-rs.
@@ -326,22 +246,10 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
     # Wait for all processes to finish policy creation before continuing
     accelerator.wait_for_everyone()
 
-    processor_pretrained_path = cfg.policy.pretrained_path
-    if (
-        getattr(cfg.policy, "use_delta_actions", False)
-        and processor_pretrained_path is not None
-        and not cfg.resume
-    ):
-        logging.warning(
-            "use_delta_actions=true with pretrained processors can skip delta transforms if "
-            "the checkpoint processors do not define them. Building processors from current policy config."
-        )
-        processor_pretrained_path = None
-
     # Create processors - only provide dataset_stats if not resuming from saved processors
     processor_kwargs = {}
     postprocessor_kwargs = {}
-    if (processor_pretrained_path and not cfg.resume) or not processor_pretrained_path:
+    if (cfg.policy.pretrained_path and not cfg.resume) or not cfg.policy.pretrained_path:
         # Only provide dataset_stats when not resuming from saved processor state
         processor_kwargs["dataset_stats"] = dataset.meta.stats
 
@@ -349,7 +257,7 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
     if cfg.policy.type == "sarm":
         processor_kwargs["dataset_meta"] = dataset.meta
 
-    if processor_pretrained_path is not None:
+    if cfg.policy.pretrained_path is not None:
         processor_kwargs["preprocessor_overrides"] = {
             "device_processor": {"device": device.type},
             "normalizer_processor": {
@@ -371,7 +279,7 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
 
     preprocessor, postprocessor = make_pre_post_processors(
         policy_cfg=cfg.policy,
-        pretrained_path=processor_pretrained_path,
+        pretrained_path=cfg.policy.pretrained_path,
         **processor_kwargs,
         **postprocessor_kwargs,
     )
@@ -489,36 +397,7 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
     for _ in range(step, cfg.steps):
         start_time = time.perf_counter()
         batch = next(dl_iter)
-
-        # Debug logging for first few steps and periodically
-        if is_main_process and (step < 3 or (cfg.log_freq > 0 and step % (cfg.log_freq * 10) == 0)):
-            action = batch.get("action")
-            state = batch.get("observation.state")
-            if action is not None and state is not None:
-                logging.info(
-                    f"[DEBUG step={step}] PRE-PROCESSOR — "
-                    f"action: shape={tuple(action.shape)}, mean={action.mean():.4f}, std={action.std():.4f}, "
-                    f"min={action.min():.4f}, max={action.max():.4f} | "
-                    f"state: shape={tuple(state.shape)}, mean={state.mean():.4f}"
-                )
-
         batch = preprocessor(batch)
-
-        if is_main_process and (step < 3 or (cfg.log_freq > 0 and step % (cfg.log_freq * 10) == 0)):
-            action = batch.get("action")
-            state = batch.get("observation.state")
-            if action is not None:
-                logging.info(
-                    f"[DEBUG step={step}] POST-PROCESSOR — "
-                    f"action: shape={tuple(action.shape)}, mean={action.mean():.4f}, std={action.std():.4f}, "
-                    f"min={action.min():.4f}, max={action.max():.4f}"
-                )
-                if state is not None:
-                    logging.info(
-                        f"[DEBUG step={step}] POST-PROCESSOR — "
-                        f"state: shape={tuple(state.shape)}, mean={state.mean():.4f}, std={state.std():.4f}"
-                    )
-
         train_tracker.dataloading_s = time.perf_counter() - start_time
 
         train_tracker, output_dict = update_policy(

src/lerobot/teleoperators/bi_openarm_leader/bi_openarm_leader.py

@@ -19,7 +19,6 @@ from functools import cached_property
 
 from lerobot.processor import RobotAction
 from lerobot.teleoperators.openarm_leader import OpenArmLeaderConfig
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
 
 from ..openarm_leader import OpenArmLeader
 from ..teleoperator import Teleoperator
@@ -89,7 +88,6 @@ class BiOpenArmLeader(Teleoperator):
     def is_connected(self) -> bool:
         return self.left_arm.is_connected and self.right_arm.is_connected
 
-    @check_if_already_connected
     def connect(self, calibrate: bool = True) -> None:
         self.left_arm.connect(calibrate)
         self.right_arm.connect(calibrate)
@@ -111,7 +109,6 @@ class BiOpenArmLeader(Teleoperator):
             "Motor ID configuration is typically done via manufacturer tools for CAN motors."
         )
 
-    @check_if_not_connected
     def get_action(self) -> RobotAction:
         action_dict = {}
 
@@ -129,7 +126,6 @@ class BiOpenArmLeader(Teleoperator):
         # TODO: Implement force feedback
         raise NotImplementedError
 
-    @check_if_not_connected
     def disconnect(self) -> None:
         self.left_arm.disconnect()
         self.right_arm.disconnect()

src/lerobot/teleoperators/bi_so_leader/bi_so_leader.py

@@ -18,7 +18,7 @@ import logging
 from functools import cached_property
 
 from lerobot.teleoperators.so_leader import SOLeaderTeleopConfig
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
+from lerobot.utils.decorators import check_if_not_connected
 
 from ..so_leader import SOLeader
 from ..teleoperator import Teleoperator
@@ -72,7 +72,6 @@ class BiSOLeader(Teleoperator):
     def is_connected(self) -> bool:
         return self.left_arm.is_connected and self.right_arm.is_connected
 
-    @check_if_already_connected
     def connect(self, calibrate: bool = True) -> None:
         self.left_arm.connect(calibrate)
         self.right_arm.connect(calibrate)
@@ -111,7 +110,6 @@ class BiSOLeader(Teleoperator):
         # TODO: Implement force feedback
         raise NotImplementedError
 
-    @check_if_not_connected
     def disconnect(self) -> None:
         self.left_arm.disconnect()
         self.right_arm.disconnect()

src/lerobot/teleoperators/openarm_leader/openarm_leader.py

@@ -21,7 +21,7 @@ from typing import Any
 from lerobot.motors import Motor, MotorCalibration, MotorNormMode
 from lerobot.motors.damiao import DamiaoMotorsBus
 from lerobot.processor import RobotAction
-from lerobot.utils.decorators import check_if_already_connected, check_if_not_connected
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 from ..teleoperator import Teleoperator
 from .config_openarm_leader import OpenArmLeaderConfig
@@ -84,7 +84,6 @@ class OpenArmLeader(Teleoperator):
         """Check if teleoperator is connected."""
         return self.bus.is_connected
 
-    @check_if_already_connected
     def connect(self, calibrate: bool = True) -> None:
         """
         Connect to the teleoperator.
@@ -92,6 +91,8 @@ class OpenArmLeader(Teleoperator):
         For manual control, we disable torque after connecting so the
         arm can be moved by hand.
         """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} already connected")
 
         # Connect to CAN bus
         logger.info(f"Connecting arm on {self.config.port}...")
@@ -182,7 +183,6 @@ class OpenArmLeader(Teleoperator):
             "Motor ID configuration is typically done via manufacturer tools for CAN motors."
         )
 
-    @check_if_not_connected
     def get_action(self) -> RobotAction:
         """
         Get current action from the leader arm.
@@ -193,6 +193,8 @@ class OpenArmLeader(Teleoperator):
         Reads all motor states (pos/vel/torque) in one CAN refresh cycle.
         """
         start = time.perf_counter()
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         action_dict: dict[str, Any] = {}
 
@@ -212,9 +214,10 @@ class OpenArmLeader(Teleoperator):
     def send_feedback(self, feedback: dict[str, float]) -> None:
         raise NotImplementedError("Feedback is not yet implemented for OpenArm leader.")
 
-    @check_if_not_connected
     def disconnect(self) -> None:
         """Disconnect from teleoperator."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         # Disconnect CAN bus
         # For manual control, ensure torque is disabled before disconnecting

src/lerobot/teleoperators/so_leader/config_so_leader.py

@@ -28,7 +28,7 @@ class SOLeaderConfig:
     port: str
 
     # Whether to use degrees for angles
-    use_degrees: bool = True
+    use_degrees: bool = False
 
 
 @TeleoperatorConfig.register_subclass("so101_leader")

tests/datasets/test_image_transforms.py

@@ -390,30 +390,6 @@ def test_sharpness_jitter_invalid_range_max_smaller():
         SharpnessJitter((2.0, 0.1))
 
 
-def test_make_transform_from_config_with_v2_resize(img_tensor_factory):
-    img_tensor = img_tensor_factory()
-    tf_cfg = ImageTransformConfig(type="Resize", kwargs={"size": (32, 32)})
-    tf = make_transform_from_config(tf_cfg)
-    assert isinstance(tf, v2.Resize)
-    output = tf(img_tensor)
-    assert output.shape[-2:] == (32, 32)
-
-
-def test_make_transform_from_config_with_v2_identity(img_tensor_factory):
-    img_tensor = img_tensor_factory()
-    tf_cfg = ImageTransformConfig(type="Identity", kwargs={})
-    tf = make_transform_from_config(tf_cfg)
-    assert isinstance(tf, v2.Identity)
-    output = tf(img_tensor)
-    assert output.shape == img_tensor.shape
-
-
-def test_make_transform_from_config_invalid_type():
-    tf_cfg = ImageTransformConfig(type="NotARealTransform", kwargs={})
-    with pytest.raises(ValueError, match="not valid"):
-        make_transform_from_config(tf_cfg)
-
-
 def test_save_all_transforms(img_tensor_factory, tmp_path):
     img_tensor = img_tensor_factory()
     tf_cfg = ImageTransformsConfig(enable=True)

tests/policies/test_delta_actions.py

@@ -1,344 +0,0 @@
-"""Tests for delta action transforms — full pipeline validation.
-
-Tests the complete flow matching OpenPI:
-  raw actions → DeltaActions → Normalize(delta_stats) → model → Unnormalize → AbsoluteActions
-
-Uses real dataset: lerobot-data-collection/dagger_final_1_21
-"""
-
-import numpy as np
-import pytest
-import torch
-
-from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
-from lerobot.datasets.compute_stats import get_feature_stats
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.processor import TransitionKey, batch_to_transition
-from lerobot.processor.delta_action_processor import (
-    AbsoluteActionsProcessorStep,
-    DeltaActionsProcessorStep,
-    to_absolute_actions,
-    to_delta_actions,
-)
-from lerobot.processor.normalize_processor import NormalizerProcessorStep, UnnormalizerProcessorStep
-from lerobot.utils.constants import ACTION, OBS_STATE
-
-CHUNK_SIZE = 10
-REPO_ID = "lerobot-data-collection/dagger_final_1_21"
-
-
-@pytest.fixture(scope="module")
-def dataset():
-    return LeRobotDataset(REPO_ID, episodes=[0])
-
-
-@pytest.fixture(scope="module")
-def action_dim(dataset):
-    return dataset.meta.features["action"]["shape"][0]
-
-
-def _build_action_chunks(dataset, chunk_size, max_chunks=50):
-    """Build action chunks from hf_dataset, like the training script does."""
-    hf = dataset.hf_dataset
-    total = len(hf)
-    all_ep = torch.tensor([int(hf[i]["episode_index"]) for i in range(total)])
-    chunks, states = [], []
-    for i in range(total - chunk_size + 1):
-        if all_ep[i] != all_ep[i + chunk_size - 1]:
-            continue
-        chunk_actions = torch.stack([hf[i + k]["action"] for k in range(chunk_size)]).float()
-        state = hf[i]["observation.state"].float()
-        chunks.append(chunk_actions)
-        states.append(state)
-        if len(chunks) >= max_chunks:
-            break
-    assert len(chunks) > 0, f"No valid chunks found. total={total}, ep_indices={all_ep.tolist()}"
-    return torch.stack(chunks), torch.stack(states)
-
-
-def _compute_delta_chunk_stats(action_chunks, states, mask):
-    all_deltas = []
-    for actions, state in zip(action_chunks, states):
-        delta = to_delta_actions(actions.unsqueeze(0), state.unsqueeze(0), mask).squeeze(0)
-        all_deltas.append(delta.numpy())
-    all_delta = np.concatenate(all_deltas, axis=0)
-    return get_feature_stats(all_delta, axis=0, keepdims=all_delta.ndim == 1)
-
-
-# --- Basic roundtrip tests ---
-
-def test_roundtrip_3d(action_dim):
-    actions = torch.randn(4, CHUNK_SIZE, action_dim)
-    state = torch.randn(4, action_dim)
-    mask = [True] * action_dim
-    recovered = to_absolute_actions(to_delta_actions(actions, state, mask), state, mask)
-    torch.testing.assert_close(recovered, actions)
-
-
-def test_roundtrip_2d(action_dim):
-    actions = torch.randn(4, action_dim)
-    state = torch.randn(4, action_dim)
-    mask = [True] * action_dim
-    recovered = to_absolute_actions(to_delta_actions(actions, state, mask), state, mask)
-    torch.testing.assert_close(recovered, actions)
-
-
-def test_no_mutation(action_dim):
-    actions = torch.randn(2, CHUNK_SIZE, action_dim)
-    original = actions.clone()
-    state = torch.randn(2, action_dim)
-    to_delta_actions(actions, state, [True] * action_dim)
-    torch.testing.assert_close(actions, original)
-
-
-def test_exclude_joints_supports_partial_name_matching():
-    names = [
-        "right_joint_1.pos",
-        "right_gripper.pos",
-        "left_joint_1.pos",
-        "left_gripper.pos",
-    ]
-    step = DeltaActionsProcessorStep(enabled=True, exclude_joints=["gripper"], action_names=names)
-    assert step._build_mask(len(names)) == [True, False, True, False]
-
-
-# --- Chunk-level delta stats test ---
-
-def test_chunk_stats_have_larger_std_than_frame_stats(dataset, action_dim):
-    """Chunk-level delta stats should have larger std than per-frame delta stats."""
-    action_chunks, states = _build_action_chunks(dataset, CHUNK_SIZE)
-    mask = [True] * action_dim
-
-    chunk_stats = _compute_delta_chunk_stats(action_chunks, states, mask)
-
-    # Per-frame stats
-    hf = dataset.hf_dataset
-    n = min(500, len(hf))
-    frame_actions = torch.stack([hf[i]["action"] for i in range(n)]).float()
-    frame_states = torch.stack([hf[i]["observation.state"] for i in range(n)]).float()
-    frame_deltas = to_delta_actions(frame_actions, frame_states, mask).numpy()
-    frame_stats = get_feature_stats(frame_deltas, axis=0, keepdims=frame_deltas.ndim == 1)
-
-    assert chunk_stats["std"].mean() >= frame_stats["std"].mean(), (
-        f"Chunk std ({chunk_stats['std'].mean():.4f}) should be >= "
-        f"frame std ({frame_stats['std'].mean():.4f})"
-    )
-
-
-# --- Full pipeline roundtrip: delta → normalize → unnormalize → absolute ---
-
-def test_full_pipeline_roundtrip(dataset, action_dim):
-    """Test the complete OpenPI pipeline: delta → normalize → unnormalize → absolute."""
-    action_chunks, states = _build_action_chunks(dataset, CHUNK_SIZE)
-    mask = [True] * action_dim
-
-    delta_stats = _compute_delta_chunk_stats(action_chunks, states, mask)
-    stats = {ACTION: {k: v for k, v in delta_stats.items()}}
-
-    features = {ACTION: PolicyFeature(type=FeatureType.ACTION, shape=(action_dim,))}
-    norm_map = {FeatureType.ACTION: NormalizationMode.MEAN_STD}
-
-    delta_step = DeltaActionsProcessorStep(enabled=True)
-    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
-    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
-    absolute_step = AbsoluteActionsProcessorStep(enabled=True, delta_step=delta_step)
-
-    original_actions = action_chunks[0].unsqueeze(0)
-    state = states[0].unsqueeze(0)
-
-    batch = {ACTION: original_actions, OBS_STATE: state}
-    transition = batch_to_transition(batch)
-
-    # Forward: delta → normalize
-    t1 = delta_step(transition)
-    t2 = normalizer(t1)
-
-    normalized_action = t2[TransitionKey.ACTION]
-    assert normalized_action.abs().mean() < 10, (
-        f"Normalized actions should be in reasonable range, got mean abs {normalized_action.abs().mean():.2f}"
-    )
-
-    # Reverse: unnormalize → absolute
-    t3 = unnormalizer(t2)
-    t4 = absolute_step(t3)
-
-    recovered_actions = t4[TransitionKey.ACTION]
-    torch.testing.assert_close(recovered_actions, original_actions, atol=1e-4, rtol=1e-4)
-
-
-def test_normalized_delta_values_are_reasonable(dataset, action_dim):
-    """With correct chunk stats, normalized delta actions should be in a reasonable range."""
-    action_chunks, states = _build_action_chunks(dataset, CHUNK_SIZE)
-    mask = [True] * action_dim
-
-    delta_stats = _compute_delta_chunk_stats(action_chunks, states, mask)
-    mean = torch.tensor(delta_stats["mean"]).float()
-    std = torch.tensor(delta_stats["std"]).float()
-
-    all_normalized = []
-    for actions, state in zip(action_chunks, states):
-        delta = to_delta_actions(actions.unsqueeze(0), state.unsqueeze(0), mask).squeeze(0)
-        normalized = (delta - mean) / (std + 1e-6)
-        all_normalized.append(normalized)
-
-    all_normalized = torch.cat(all_normalized, dim=0)
-
-    pct_in_range = (all_normalized.abs() < 5).float().mean()
-    assert pct_in_range > 0.9, (
-        f"Only {pct_in_range*100:.1f}% of normalized values in [-5, 5], expected >90%"
-    )
-
-    assert all_normalized.mean().abs() < 1.0, (
-        f"Mean of normalized deltas is {all_normalized.mean():.2f}, expected near 0"
-    )
-
-
-def test_processor_step_roundtrip(dataset, action_dim):
-    """DeltaActionsProcessorStep applies delta; to_absolute_actions recovers original."""
-    hf = dataset.hf_dataset
-    batch = {
-        ACTION: torch.stack([hf[i]["action"] for i in range(4)]),
-        OBS_STATE: torch.stack([hf[i]["observation.state"] for i in range(4)]),
-    }
-    original_actions = batch[ACTION].clone()
-    transition = batch_to_transition(batch)
-
-    step = DeltaActionsProcessorStep(enabled=True)
-    delta_transition = step(transition)
-    assert not torch.allclose(delta_transition[TransitionKey.ACTION], original_actions)
-
-    state = transition[TransitionKey.OBSERVATION][OBS_STATE]
-    mask = [True] * action_dim
-    recovered = to_absolute_actions(delta_transition[TransitionKey.ACTION], state, mask)
-    torch.testing.assert_close(recovered, original_actions)
-
-
-def test_processor_step_disabled_is_noop(dataset, action_dim):
-    """enabled=False should be a no-op."""
-    hf = dataset.hf_dataset
-    batch = {
-        ACTION: torch.stack([hf[i]["action"] for i in range(2)]),
-        OBS_STATE: torch.stack([hf[i]["observation.state"] for i in range(2)]),
-    }
-    original = batch[ACTION].clone()
-    transition = batch_to_transition(batch)
-    result = DeltaActionsProcessorStep(enabled=False)(transition)
-    torch.testing.assert_close(result[TransitionKey.ACTION], original)
-
-
-# --- Training batch shape validation ---
-
-def test_delta_with_action_chunks(dataset, action_dim):
-    """Verify delta works correctly with (B, chunk_size, action_dim) shaped actions."""
-    action_chunks, states = _build_action_chunks(dataset, CHUNK_SIZE)
-
-    # Simulate a training batch: actions=(B, chunk_size, action_dim), state=(B, state_dim)
-    batch_actions = action_chunks[:4]  # (4, chunk_size, action_dim)
-    batch_states = states[:4]  # (4, state_dim)
-
-    mask = [True] * action_dim
-    delta = to_delta_actions(batch_actions, batch_states, mask)
-
-    # First action in each chunk should be close to zero (action[t] - state[t] ≈ small)
-    first_deltas = delta[:, 0, :]  # (B, action_dim)
-    assert first_deltas.abs().mean() < delta.abs().mean(), (
-        f"First action in chunk should have smaller delta than average. "
-        f"First: {first_deltas.abs().mean():.4f}, Average: {delta.abs().mean():.4f}"
-    )
-
-    # Later actions should have larger deltas
-    last_deltas = delta[:, -1, :]  # (B, action_dim)
-    assert last_deltas.abs().mean() >= first_deltas.abs().mean(), (
-        f"Last action in chunk should have >= delta than first. "
-        f"Last: {last_deltas.abs().mean():.4f}, First: {first_deltas.abs().mean():.4f}"
-    )
-
-    # Roundtrip
-    recovered = to_absolute_actions(delta, batch_states, mask)
-    torch.testing.assert_close(recovered, batch_actions)
-
-
-def test_delta_stats_match_actual_data_distribution(dataset, action_dim):
-    """Verify computed stats match the actual delta distribution."""
-    action_chunks, states = _build_action_chunks(dataset, CHUNK_SIZE)
-    mask = [True] * action_dim
-
-    # Compute stats like the training script does
-    delta_stats = _compute_delta_chunk_stats(action_chunks, states, mask)
-
-    # Also compute directly
-    all_deltas = []
-    for actions, state in zip(action_chunks, states):
-        delta = to_delta_actions(actions.unsqueeze(0), state.unsqueeze(0), mask).squeeze(0)
-        all_deltas.append(delta)
-    all_deltas_tensor = torch.cat(all_deltas, dim=0)
-
-    # Compare mean
-    actual_mean = all_deltas_tensor.mean(dim=0).numpy()
-    np.testing.assert_allclose(delta_stats["mean"], actual_mean, atol=0.01)
-
-    # Compare std
-    actual_std = all_deltas_tensor.std(dim=0).numpy()
-    np.testing.assert_allclose(delta_stats["std"], actual_std, atol=0.1)
-
-    # Verify q01 < mean < q99
-    assert (delta_stats["q01"] < delta_stats["mean"]).all(), "q01 should be < mean"
-    assert (delta_stats["mean"] < delta_stats["q99"]).all(), "mean should be < q99"
-
-
-def test_quantile_normalization_roundtrip(dataset, action_dim):
-    """Full roundtrip with QUANTILES normalization (what OpenPI uses for pi05)."""
-    action_chunks, states = _build_action_chunks(dataset, CHUNK_SIZE)
-    mask = [True] * action_dim
-
-    delta_stats = _compute_delta_chunk_stats(action_chunks, states, mask)
-    stats = {ACTION: {k: v for k, v in delta_stats.items()}}
-
-    features = {ACTION: PolicyFeature(type=FeatureType.ACTION, shape=(action_dim,))}
-    norm_map = {FeatureType.ACTION: NormalizationMode.QUANTILES}
-
-    delta_step = DeltaActionsProcessorStep(enabled=True)
-    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
-    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
-    absolute_step = AbsoluteActionsProcessorStep(enabled=True, delta_step=delta_step)
-
-    original_actions = action_chunks[0].unsqueeze(0)
-    state = states[0].unsqueeze(0)
-
-    batch = {ACTION: original_actions, OBS_STATE: state}
-    transition = batch_to_transition(batch)
-
-    # Forward: delta → quantile normalize
-    t1 = delta_step(transition)
-    t2 = normalizer(t1)
-
-    normalized = t2[TransitionKey.ACTION]
-    # Most values should be in [-1, 1] with quantile normalization
-    pct_in_range = (normalized.abs() < 2).float().mean()
-    assert pct_in_range > 0.5, (
-        f"Only {pct_in_range*100:.1f}% in [-2, 2] after quantile norm, expected >50%"
-    )
-
-    # Reverse: unnormalize → absolute
-    t3 = unnormalizer(t2)
-    t4 = absolute_step(t3)
-
-    recovered = t4[TransitionKey.ACTION]
-    torch.testing.assert_close(recovered, original_actions, atol=1e-3, rtol=1e-3)
-
-
-def test_state_not_modified_by_delta(dataset, action_dim):
-    """State should never be modified by the delta processor."""
-    hf = dataset.hf_dataset
-    batch = {
-        ACTION: torch.stack([hf[i]["action"] for i in range(4)]),
-        OBS_STATE: torch.stack([hf[i]["observation.state"] for i in range(4)]),
-    }
-    original_state = batch[OBS_STATE].clone()
-    transition = batch_to_transition(batch)
-
-    step = DeltaActionsProcessorStep(enabled=True)
-    result = step(transition)
-
-    result_state = result[TransitionKey.OBSERVATION][OBS_STATE]
-    torch.testing.assert_close(result_state, original_state)

tests/scripts/test_edit_dataset_parsing.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2026 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import draccus
-import pytest
-
-from lerobot.scripts.lerobot_edit_dataset import (
-    ConvertImageToVideoConfig,
-    DeleteEpisodesConfig,
-    EditDatasetConfig,
-    MergeConfig,
-    ModifyTasksConfig,
-    OperationConfig,
-    RemoveFeatureConfig,
-    SplitConfig,
-)
-
-
-def parse_cfg(cli_args: list[str]) -> EditDatasetConfig:
-    """Helper to parse CLI args into an EditDatasetConfig via draccus."""
-    return draccus.parse(EditDatasetConfig, args=cli_args)
-
-
-class TestOperationTypeParsing:
-    """Test that --operation.type correctly selects the right config subclass."""
-
-    @pytest.mark.parametrize(
-        "type_name, expected_cls",
-        [
-            ("delete_episodes", DeleteEpisodesConfig),
-            ("split", SplitConfig),
-            ("merge", MergeConfig),
-            ("remove_feature", RemoveFeatureConfig),
-            ("modify_tasks", ModifyTasksConfig),
-            ("convert_image_to_video", ConvertImageToVideoConfig),
-        ],
-    )
-    def test_operation_type_resolves_correct_class(self, type_name, expected_cls):
-        cfg = parse_cfg(["--repo_id", "test/repo", "--operation.type", type_name])
-        assert isinstance(cfg.operation, expected_cls), (
-            f"Expected {expected_cls.__name__}, got {type(cfg.operation).__name__}"
-        )
-
-    @pytest.mark.parametrize(
-        "type_name, expected_cls",
-        [
-            ("delete_episodes", DeleteEpisodesConfig),
-            ("split", SplitConfig),
-            ("merge", MergeConfig),
-            ("remove_feature", RemoveFeatureConfig),
-            ("modify_tasks", ModifyTasksConfig),
-            ("convert_image_to_video", ConvertImageToVideoConfig),
-        ],
-    )
-    def test_get_choice_name_roundtrips(self, type_name, expected_cls):
-        cfg = parse_cfg(["--repo_id", "test/repo", "--operation.type", type_name])
-        resolved_name = OperationConfig.get_choice_name(type(cfg.operation))
-        assert resolved_name == type_name