cleaning up to keep changes minimal

.github/dependabot.yml

@@ -1,11 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    cooldown:
-      default-days: 7
-    groups:
-      actions:
-        patterns: ["*"]

AGENTS.md

@@ -51,7 +51,6 @@ pre-commit run --all-files                           # Lint + format (ruff, typo
 ## Notes
 
 - **Mypy is gradual**: strict only for `lerobot.envs`, `lerobot.configs`, `lerobot.optim`, `lerobot.model`, `lerobot.cameras`, `lerobot.motors`, `lerobot.transport`. Add type annotations when modifying these modules.
-- **Imports**: prefer top-level imports; relative (`from .sibling import X`) across sibling files within a module, absolute (`from lerobot.module import X`) across modules.
-- **Optional dependencies**: many policies, envs, and robots are behind extras (e.g., `lerobot[aloha]`, see `pyproject.toml`). Guard optional imports with `TYPE_CHECKING or _foo_available` at module top + a `require_package(...)` check at use time. Reuse the `_foo_available` flags in `utils/import_utils.py`; don't call `is_package_available`.
+- **Optional dependencies**: many policies, envs, and robots are behind extras (e.g., `lerobot[aloha]`). New imports for optional packages must be guarded or lazy. See `pyproject.toml [project.optional-dependencies]`.
 - **Video decoding**: datasets can store observations as video files. `LeRobotDataset` handles frame extraction, but tests need ffmpeg installed.
 - **Prioritize use of `uv run`** to execute Python commands (not raw `python` or `pip`).

README.md

@@ -83,7 +83,7 @@ episode_index=0
 print(f"{dataset[episode_index]['action'].shape=}\n")
 ```
 
-Learn more about it in the [LeRobotDataset Documentation](https://huggingface.co/docs/lerobot/lerobot-dataset-v3).
+Learn more about it in the [LeRobotDataset Documentation](https://huggingface.co/docs/lerobot/lerobot-dataset-v3)
 
 ## SoTA Models
 
@@ -109,7 +109,7 @@ lerobot-train \
 | **World Models**           | [VLA-JEPA](./docs/source/vla_jepa.mdx), [LingBot-VA](./docs/source/lingbot_va.mdx), [FastWAM](./docs/source/fastwam.mdx)                                                                                                                                                                                                                                                                   |
 | **Reward Models**          | [SARM](./docs/source/sarm.mdx), [TOPReward](./docs/source/topreward.mdx), [Robometer](./docs/source/robometer.mdx)                                                                                                                                                                                                                                                                         |
 
-Similarly to the hardware, you can easily implement your own policy & leverage LeRobot's data collection, training, and visualization tools, and share your model to the HF Hub.
+Similarly to the hardware, you can easily implement your own policy & leverage LeRobot's data collection, training, and visualization tools, and share your model to the HF Hub
 
 For detailed policy setup guides, see the [Policy Documentation](https://huggingface.co/docs/lerobot/bring_your_own_policies). For GPU/RAM requirements and expected training time per policy, see the [Compute Hardware Guide](https://huggingface.co/docs/lerobot/hardware_guide).
 
@@ -126,7 +126,7 @@ lerobot-eval \
   --eval.n_episodes=10
 ```
 
-Learn how to implement your own simulation environment or benchmark and distribute it from the HF Hub by following the [EnvHub Documentation](https://huggingface.co/docs/lerobot/envhub).
+Learn how to implement your own simulation environment or benchmark and distribute it from the HF Hub by following the [EnvHub Documentation](https://huggingface.co/docs/lerobot/envhub)
 
 ## Resources
 

docs/source/annotation_pipeline.mdx

@@ -89,8 +89,8 @@ subtask.
 
 The resulting spans are then stitched into a gap-free, full-episode
 cover, so **every frame has exactly one active subtask**. See
-[Running on Hugging Face Jobs](#running-on-hugging-face-jobs) for the
-production settings (single camera, timestamped contact sheets,
+[`run_hf_job.py`](https://github.com/huggingface/lerobot/blob/main/examples/annotations/run_hf_job.py)
+for the production settings (single camera, timestamped contact sheets,
 auto-windowed subtask generation).
 
 ### Tools
@@ -110,67 +110,28 @@ not-yet-implemented.
 
 ## Running on Hugging Face Jobs
 
-Annotating a real dataset needs a GPU big enough to serve the VLM, so
-`lerobot-annotate` can dispatch itself to
-[Hugging Face Jobs](https://huggingface.co/docs/hub/en/jobs) — same as
-`lerobot-train`. Add `--job.target=<flavor>` to the exact command you'd
-run locally and it runs on that hardware instead:
+Annotation runs on [Hugging Face Jobs](https://huggingface.co/docs/hub/en/jobs).
+The repo ships a launcher script you copy and tweak for your dataset:
 
 ```bash
-hf auth login   # once
-
-uv run lerobot-annotate \
-    --repo_id=user/my_dataset \
-    --new_repo_id=user/my_dataset_annotated \
-    --push_to_hub=true \
-    --vlm.model_id=Qwen/Qwen3.6-27B \
-    --vlm.num_gpus=1 \
-    --vlm.serve_command="vllm serve Qwen/Qwen3.6-27B --tensor-parallel-size 1 \
-        --max-model-len 32768 --gpu-memory-utilization 0.8 \
-        --uvicorn-log-level warning --port {port}" \
-    --vlm.serve_ready_timeout_s=1800 \
-    --vlm.chat_template_kwargs='{"enable_thinking": false}' \
-    --job.target=h200
+HF_TOKEN=hf_... uv run python examples/annotations/run_hf_job.py
 ```
 
-That submits a single-GPU `h200` job that:
+[`run_hf_job.py`](https://github.com/huggingface/lerobot/blob/main/examples/annotations/run_hf_job.py)
+starts a single-GPU `h200` job (bump it to `h200x4` for big datasets)
+that:
 
-1. starts from the `vllm/vllm-openai` image and installs `lerobot` on top,
-2. boots one vLLM server per GPU and drives it over the OpenAI-compatible API,
-3. runs the `plan` / `interjections` / `vqa` modules across the dataset,
+1. installs `lerobot` (from `main`) plus the annotation extras,
+2. boots one vLLM server per GPU (using the `vllm/vllm-openai` image) and
+   drives it over the OpenAI-compatible API,
+3. runs the `plan` / `interjections` / `vqa` modules across the dataset
+   with `lerobot-annotate`,
 4. with `--push_to_hub=true`, uploads the result to `--new_repo_id` (or
    back to `--repo_id` in place if you leave that unset).
 
-The command streams the job's logs; `Ctrl-C` detaches without cancelling
-it. List the available flavors and their pricing with `hf jobs hardware`.
-
-<Tip warning={true}>
-
-Qwen3.6 ships with thinking enabled, which eats the token budget the
-annotator needs for its JSON answer — `--vlm.chat_template_kwargs='{"enable_thinking": false}'`
-turns it off. Without `--push_to_hub=true` the annotated dataset is
-discarded when the pod exits.
-
-</Tip>
-
-### Job options
-
-| Flag                | Default                   | What it does                                                                    |
-| ------------------- | ------------------------- | ------------------------------------------------------------------------------- |
-| `--job.target`      | `local`                   | HF Jobs flavor to run on (e.g. `h200`, `h200x4`). Omitted/`local` runs here.    |
-| `--job.image`       | `vllm/vllm-openai:latest` | Runtime image for the pod.                                                      |
-| `--job.timeout`     | `2h`                      | Wall-clock cap. Raise it for large datasets.                                    |
-| `--job.detach`      | `false`                   | Submit and exit instead of streaming logs.                                      |
-| `--job.lerobot_ref` | `main`                    | Git ref of lerobot installed on the pod — point it at a branch to test changes. |
-| `--job.tags`        | `[]`                      | Extra tags on the job and on any dataset it pushes (`lerobot` is always added). |
-
-For a bigger dataset, scale to `h200x4` and raise
-`--vlm.parallel_servers` / `--vlm.num_gpus` to match, and give the job
-more headroom with e.g. `--job.timeout=8h`.
-
-Remote runs need `--repo_id` (the pod pulls the dataset from the Hub;
-`--root` names a directory only your machine has). A dataset that exists
-only in your local cache is pushed to a **private** repo first.
+To use a different dataset, model, or hub repo, edit the `CMD` block in
+the script. Every flag there maps directly to a `lerobot-annotate` flag
+(run `lerobot-annotate --help` for the full list).
 
 ## Key options
 

docs/source/bring_your_own_policies.mdx

@@ -165,8 +165,6 @@ Batches are flat dictionaries keyed by the constants in [`lerobot.utils.constant
 
 LeRobot uses `PolicyProcessorPipeline`s to normalize inputs and de-normalize outputs around your policy. For a concrete reference, see [`processor_act.py`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/policies/act/processor_act.py) or [`processor_diffusion.py`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/policies/diffusion/processor_diffusion.py).
 
-Pay close attention here: processors are the most common reproducibility pain point. A mismatch in normalization mode (`IDENTITY` vs `MEAN_STD` vs `MIN_MAX` vs `QUANTILES`/`QUANTILE10`) or in which features get normalized will train and eval without erroring, yet silently wreck results. Make sure the modes match how the checkpoint was trained, that the required stats exist (e.g. `QUANTILES` needs `q01`/`q99`), and that the pre- and post-processors stay consistent.
-
 ```python
 # processor_my_policy.py
 from typing import Any
@@ -306,9 +304,7 @@ Mirror an existing policy that's structurally similar to yours; the diff is smal
 
 ### Heavy / optional dependencies
 
-Most policies need a heavy backbone (transformers, diffusers, a specific VLM SDK). Wherever one exists, prefer loading it e.g from `transformers` or `diffusers` rather than re-implementing the architecture in-tree.
-
-The convention is **two-step gating**: a `TYPE_CHECKING`-guarded import at module top, and a `require_package` runtime check in the constructor. [`modeling_diffusion.py`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/policies/diffusion/modeling_diffusion.py) is the canonical reference:
+Most policies need a heavy backbone (transformers, diffusers, a specific VLM SDK). The convention is **two-step gating**: a `TYPE_CHECKING`-guarded import at module top, and a `require_package` runtime check in the constructor. [`modeling_diffusion.py`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/policies/diffusion/modeling_diffusion.py) is the canonical reference:
 
 ```python
 from typing import TYPE_CHECKING
@@ -378,7 +374,6 @@ The general expectations are in [`CONTRIBUTING.md`](https://github.com/huggingfa
 - [ ] Optional deps live behind a `[project.optional-dependencies]` extra and the `TYPE_CHECKING + require_package` guard.
 - [ ] `tests/policies/` updated; backward-compat artifact committed & policy-specific tests.
 - [ ] `src/lerobot/policies/<name>/README.md` symlinked into `docs/source/policy_<name>_README.md`; user-facing `docs/source/<name>.mdx` written and added to `_toctree.yml`.
-- [ ] `lerobot-train --policy.type my_policy ...` runs end-to-end for at least a few steps + save a checkpoint that can be loaded and run by `lerobot-eval` or `lerobot-rollout`.
 - [ ] `templates/lerobot_modelcard_template.md` has a description entry and a `policy_docs` link for your policy.
 - [ ] The models table in the root `README.md` lists your policy in the right category, linking to your doc page.
 - [ ] At least one reproducible benchmark eval in the policy MDX with a published checkpoint (sim benchmark, or real-robot dataset + checkpoint).

docs/source/cameras.mdx

@@ -136,10 +136,6 @@ config = RealSenseCameraConfig(
     height=480,
     color_mode=ColorMode.RGB,
     use_depth=True,
-    # Optional fixed color controls. Omit them to leave the current sensor settings unchanged.
-    exposure=120,
-    gain=64,
-    white_balance=4600,
     rotation=Cv2Rotation.NO_ROTATION
 )
 
@@ -158,15 +154,6 @@ finally:
 ```
 <!-- prettier-ignore-end -->
 
-Manual color controls disable the corresponding automatic exposure or white-balance mode. Their
-supported ranges vary by camera model; an invalid value raises an error at connection time that
-includes the range reported by the sensor. Requesting an unsupported control also raises an error.
-Omitted controls leave the sensor's existing automatic or manual setting unchanged. These options
-require `use_rgb=True`.
-
-On the RealSense D405, the color stream is provided by the Stereo Module, so changing manual
-exposure or gain also affects the depth stream.
-
 </hfoption>
 </hfoptions>
 

docs/source/omx.mdx

@@ -1,11 +1,3 @@
-# OMX
-
-<img
-  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/omx_mainimage.png"
-  alt="OMX"
-  width=600
-/>
-
 ## Order and Assemble the parts
 
 First, assemble the OMX hardware following the official assembly guide.

docs/source/using_dataset_tools.mdx

@@ -252,10 +252,6 @@ lerobot-dataset-viz \
     --episode-index 0
 ```
 
-For a private or gated dataset, authenticate first with `hf auth login`, or set the
-`HF_TOKEN` environment variable. The Hub client then discovers the credential
-automatically; no token argument is needed.
-
 **From a local folder:**
 Add the `--root` option and set `--mode local`. For example, to search in `./my_local_data_dir/lerobot/pusht`:
 

examples/annotations/run_hf_job.py

@@ -0,0 +1,80 @@
+#!/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.
+"""Launch ``lerobot-annotate`` on a Hugging Face job (vllm + Qwen3.6-27B VLM).
+
+Spawns one single-GPU ``h200`` job that:
+
+  1. installs ``lerobot`` from ``main`` plus the annotation extras,
+  2. boots one vllm server with Qwen3.6-27B (dense VLM),
+  3. runs the plan / interjections / vqa modules across the dataset
+     in free-form mode (each episode generates its own subtasks +
+     memory),
+  4. uploads the annotated dataset to ``--new_repo_id`` (when set)
+     or back to ``--repo_id``.
+
+Usage:
+
+    HF_TOKEN=hf_... uv run python examples/annotations/run_hf_job.py
+
+Adjust ``CMD`` (dataset, model, hub repo) and ``flavor`` below for your
+run. For larger datasets, scale to ``h200x4`` and raise
+``--vlm.parallel_servers`` / ``--vlm.num_gpus`` to match.
+"""
+
+import os
+
+from huggingface_hub import get_token, run_job
+
+token = os.environ.get("HF_TOKEN") or get_token()
+if not token:
+    raise RuntimeError("No HF token. Run `huggingface-cli login` or `export HF_TOKEN=hf_...`")
+
+CMD = (
+    "apt-get update -qq && apt-get install -y -qq git ffmpeg && "
+    "pip install --no-deps "
+    "'lerobot @ git+https://github.com/huggingface/lerobot.git@main' && "
+    # Pins mirror pyproject.toml — unpinned installs pull av 18 / datasets 5 /
+    # draccus 0.11, which break lerobot at import time.
+    "pip install --upgrade-strategy only-if-needed "
+    "'datasets>=4.7.0,<5.0.0' 'pyarrow>=21.0.0,<30.0.0' 'av>=15.0.0,<16.0.0' 'draccus==0.10.0' "
+    "'pandas>=2.0.0,<3.0.0' jsonlines gymnasium torchcodec mergedeep pyyaml-include toml typing-inspect "
+    "openai && "
+    "export VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS=0 && "
+    "export VLLM_VIDEO_BACKEND=pyav && "
+    "lerobot-annotate "
+    "--repo_id=pepijn223/robocasa_pretrain_human300_v4 "
+    "--new_repo_id=pepijn223/robocasa_pretrain_human300_v4_annotated "
+    "--push_to_hub=true "
+    "--vlm.backend=openai "
+    "--vlm.model_id=Qwen/Qwen3.6-27B "
+    "--vlm.num_gpus=1 "
+    '--vlm.serve_command="vllm serve Qwen/Qwen3.6-27B '
+    "--tensor-parallel-size 1 --max-model-len 32768 "
+    '--gpu-memory-utilization 0.8 --uvicorn-log-level warning --port {port}" '
+    "--vlm.serve_ready_timeout_s=1800 "
+    # Qwen3.6 ships with thinking on; annotation wants plain JSON answers.
+    "--vlm.chat_template_kwargs='{\"enable_thinking\": false}'"
+)
+
+job = run_job(
+    image="vllm/vllm-openai:latest",
+    command=["bash", "-c", CMD],
+    flavor="h200",
+    secrets={"HF_TOKEN": token},
+    timeout="2h",
+)
+print(f"Job URL: {job.url}")
+print(f"Job ID:  {job.id}")

pyproject.toml

@@ -14,7 +14,7 @@
 
 [build-system]
 requires = ["setuptools"]
-build-backend = "setuptools*"
+build-backend = "setuptools.build_meta"
 
 [project.urls]
 homepage = "https://huggingface.co/lerobot"
@@ -87,7 +87,7 @@ dependencies = [
 
     # Build tools (required by opencv-python-headless on some platforms)
     "cmake>=3.29.0.1,<4.2.0",
-    "setuptools>=71.0.0,<84.0.0",
+    "setuptools>=71.0.0,<81.0.0",
 ]
 
 # Optional dependencies
@@ -155,7 +155,7 @@ accelerate-dep = ["accelerate>=1.14.0,<2.0.0"]
 can-dep = ["python-can>=4.2.0,<5.0.0"]
 peft-dep = ["peft>=0.18.0,<1.0.0"]
 scipy-dep = ["scipy>=1.14.0,<2.0.0"]
-diffusers-dep = ["diffusers>=0.38.0,<0.40.0"]
+diffusers-dep = ["diffusers>=0.27.2,<0.36.0"]
 qwen-vl-utils-dep = ["qwen-vl-utils>=0.0.11,<0.1.0"]
 matplotlib-dep = ["matplotlib>=3.10.3,<4.0.0", "contourpy>=1.3.0,<2.0.0"] # NOTE: Explicitly listing contourpy helps the resolver converge faster.
 pyserial-dep = ["pyserial>=3.5,<4.0"]
@@ -261,7 +261,7 @@ annotations = [
 # Development
 dev = ["pre-commit>=3.7.0,<5.0.0", "debugpy>=1.8.1,<1.9.0", "lerobot[grpcio-dep]", "grpcio-tools>=1.73.1,<2.0.0", "mypy>=1.19.1", "ruff>=0.14.1", "lerobot[notebook]"]
 notebook = ["jupyter>=1.0.0,<2.0.0", "ipykernel>=6.0.0,<7.0.0"]
-test = ["pytest>=8.1.0,<10.0.0", "pytest-timeout>=2.4.0,<3.0.0", "pytest-cov>=5.0.0,<8.0.0", "mock-serial>=0.0.1,<0.1.0 ; sys_platform != 'win32'"]
+test = ["pytest>=8.1.0,<9.0.0", "pytest-timeout>=2.4.0,<3.0.0", "pytest-cov>=5.0.0,<8.0.0", "mock-serial>=0.0.1,<0.1.0 ; sys_platform != 'win32'"]
 video_benchmark = ["scikit-image>=0.23.2,<0.26.0", "pandas>=2.2.2,<2.4.0"]
 
 # Simulation
@@ -494,19 +494,6 @@ ignore_errors = true
 module = "lerobot.envs.*"
 ignore_errors = false
 
-[[tool.mypy.overrides]]
-module = "lerobot.annotations.*"
-ignore_errors = false
-disallow_untyped_defs = true
-disallow_incomplete_defs = true
-check_untyped_defs = true
-
-[[tool.mypy.overrides]]
-module = "lerobot.transforms.*"
-ignore_errors = false
-disallow_untyped_defs = true
-disallow_incomplete_defs = true
-check_untyped_defs = true
 
 # [[tool.mypy.overrides]]
 # module = "lerobot.utils.*"

src/lerobot/annotations/steerable_pipeline/config.py

@@ -20,29 +20,6 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from lerobot.configs.default import JobConfig
-
-# The annotation pipeline boots its own vLLM server, so the pod starts from the
-# official vLLM runtime rather than the prebuilt `lerobot-gpu` training image;
-# `lerobot` is pip-installed on top (see `lerobot.jobs.annotate`).
-DEFAULT_ANNOTATE_JOB_IMAGE = "vllm/vllm-openai:latest"
-
-
-@dataclass
-class AnnotationJobConfig(JobConfig):
-    """`JobConfig` with the annotation runtime's defaults.
-
-    Adds `lerobot_ref` because the vLLM image ships no lerobot: the pod installs
-    it from git, and the ref decides which code actually annotates. Point it at a
-    branch/tag/SHA to try unmerged changes remotely.
-    """
-
-    image: str = DEFAULT_ANNOTATE_JOB_IMAGE
-    # Annotation is a bounded pass over a dataset; a tighter cap than training's
-    # "2d" keeps a wedged vLLM server from burning a day of GPU time.
-    timeout: str | None = "2h"
-    lerobot_ref: str = "main"
-
 
 @dataclass
 class PlanConfig:
@@ -230,11 +207,6 @@ class AnnotationPipelineConfig:
     vlm: VlmConfig = field(default_factory=VlmConfig)
     executor: ExecutorConfig = field(default_factory=ExecutorConfig)
 
-    # Where the annotation runs: omitted / "local" annotates on this machine, any
-    # other value is an HF Jobs flavor (e.g. "h200") and submits the run there.
-    # List flavors + pricing with `hf jobs hardware`.
-    job: AnnotationJobConfig = field(default_factory=AnnotationJobConfig)
-
     skip_validation: bool = False
     only_episodes: tuple[int, ...] | None = None
 

src/lerobot/annotations/steerable_pipeline/executor.py

@@ -30,8 +30,8 @@ Phase 3 is why the ``plan`` module must be re-entered after the
 timestamps.
 
 Distributed execution is provided by Hugging Face Jobs (see
-``lerobot.jobs.annotate``, reached via ``--job.target=<flavor>``); the pod
-inside the job invokes ``lerobot-annotate`` which uses this in-process executor.
+``examples/annotations/run_hf_job.py``); the runner inside the job
+invokes ``lerobot-annotate`` which uses this in-process executor.
 Episode-level concurrency is controlled by
 ``ExecutorConfig.episode_parallelism``.
 """

src/lerobot/annotations/steerable_pipeline/vlm_client.py

@@ -194,13 +194,12 @@ def make_vlm_client(config: VlmConfig) -> VlmClient:
     """Build the shared VLM client.
 
     Only the ``openai`` backend is supported for now. The shipped workflow
-    is Hugging Face Jobs (``lerobot-annotate --job.target=<flavor>``): it
-    boots a vLLM server inside the ``vllm/vllm-openai`` image and the
-    pipeline talks to it over the OpenAI-compatible API
-    (``--vlm.backend=openai``, optionally auto-spawning the server via
-    ``auto_serve`` / ``serve_command``). The former in-process ``vllm`` /
-    ``transformers`` backends were removed to keep the support surface to
-    the HF Jobs path.
+    is Hugging Face Jobs (``examples/annotations/run_hf_job.py``): it boots
+    a vLLM server inside the ``vllm/vllm-openai`` image and the pipeline
+    talks to it over the OpenAI-compatible API (``--vlm.backend=openai``,
+    optionally auto-spawning the server via ``auto_serve`` /
+    ``serve_command``). The former in-process ``vllm`` / ``transformers``
+    backends were removed to keep the support surface to the HF Jobs path.
 
     For ``stub``, construct :class:`StubVlmClient` directly with a responder
     callable; it is rejected here to make accidental misuse obvious.
@@ -214,8 +213,8 @@ def make_vlm_client(config: VlmConfig) -> VlmClient:
     if config.backend in {"vllm", "transformers"}:
         raise ValueError(
             f"backend={config.backend!r} (in-process local model) is not supported for now — "
-            "only backend='openai' (the Hugging Face Jobs flow) is. Run the pipeline with "
-            "`lerobot-annotate --job.target=<flavor>`, which serves the model with vLLM in the "
+            "only backend='openai' (the Hugging Face Jobs flow) is. Run the pipeline via "
+            "examples/annotations/run_hf_job.py, which serves the model with vLLM in the "
             "vllm/vllm-openai image and talks to it over the OpenAI-compatible API."
         )
     raise ValueError(f"Unknown VLM backend: {config.backend!r}")

src/lerobot/cameras/opencv/camera_opencv.py

@@ -120,22 +120,14 @@ class OpenCVCamera(Camera):
         self.rotation: int | None = get_cv2_rotation(config.rotation)
         self.backend: int = config.backend
 
-        self.capture_width: int | None = None
-        self.capture_height: int | None = None
-        self._reset_connection_settings()
+        if self.height and self.width:
+            self.capture_width, self.capture_height = self.width, self.height
+            if self.rotation in [cv2.ROTATE_90_CLOCKWISE, cv2.ROTATE_90_COUNTERCLOCKWISE]:
+                self.capture_width, self.capture_height = self.height, self.width
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.index_or_path})"
 
-    def _reset_connection_settings(self) -> None:
-        """Restore settings that may have been auto-detected during a failed connection."""
-        self.fps = self.config.fps
-        self.width = self.config.width
-        self.height = self.config.height
-        self.capture_width, self.capture_height = self.width, self.height
-        if self.rotation in [cv2.ROTATE_90_CLOCKWISE, cv2.ROTATE_90_COUNTERCLOCKWISE]:
-            self.capture_width, self.capture_height = self.height, self.width
-
     @property
     def is_connected(self) -> bool:
         """Checks if the camera is currently connected and opened."""
@@ -172,25 +164,17 @@ class OpenCVCamera(Camera):
                 f"Failed to open {self}.Run `lerobot-find-cameras opencv` to find available cameras."
             )
 
-        try:
-            self._configure_capture_settings()
-            self._start_read_thread()
+        self._configure_capture_settings()
+        self._start_read_thread()
 
-            if warmup and self.warmup_s > 0:
-                start_time = time.time()
-                while time.time() - start_time < self.warmup_s:
-                    self.async_read(timeout_ms=self.warmup_s * 1000)
-                    time.sleep(0.1)
-                with self.frame_lock:
-                    if self.latest_frame is None:
-                        raise ConnectionError(f"{self} failed to capture frames during warmup.")
-        except BaseException:
-            try:
-                self._cleanup_resources()
-            except Exception:
-                logger.exception(f"Failed to fully clean up {self} after connect() failed.")
-            self._reset_connection_settings()
-            raise
+        if warmup and self.warmup_s > 0:
+            start_time = time.time()
+            while time.time() - start_time < self.warmup_s:
+                self.async_read(timeout_ms=self.warmup_s * 1000)
+                time.sleep(0.1)
+            with self.frame_lock:
+                if self.latest_frame is None:
+                    raise ConnectionError(f"{self} failed to capture frames during warmup.")
 
         logger.info(f"{self} connected.")
 
@@ -328,36 +312,32 @@ class OpenCVCamera(Camera):
 
         for target in targets_to_scan:
             camera = cv2.VideoCapture(target)
-            try:
-                if camera.isOpened():
-                    default_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
-                    default_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
-                    default_fps = camera.get(cv2.CAP_PROP_FPS)
-                    default_format = camera.get(cv2.CAP_PROP_FORMAT)
+            if camera.isOpened():
+                default_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
+                default_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                default_fps = camera.get(cv2.CAP_PROP_FPS)
+                default_format = camera.get(cv2.CAP_PROP_FORMAT)
 
-                    # Get FOURCC code and convert to string
-                    default_fourcc_code = camera.get(cv2.CAP_PROP_FOURCC)
-                    default_fourcc_code_int = int(default_fourcc_code)
-                    default_fourcc = "".join(
-                        [chr((default_fourcc_code_int >> 8 * i) & 0xFF) for i in range(4)]
-                    )
+                # Get FOURCC code and convert to string
+                default_fourcc_code = camera.get(cv2.CAP_PROP_FOURCC)
+                default_fourcc_code_int = int(default_fourcc_code)
+                default_fourcc = "".join([chr((default_fourcc_code_int >> 8 * i) & 0xFF) for i in range(4)])
 
-                    camera_info = {
-                        "name": f"OpenCV Camera @ {target}",
-                        "type": "OpenCV",
-                        "id": target,
-                        "backend_api": camera.getBackendName(),
-                        "default_stream_profile": {
-                            "format": default_format,
-                            "fourcc": default_fourcc,
-                            "width": default_width,
-                            "height": default_height,
-                            "fps": default_fps,
-                        },
-                    }
+                camera_info = {
+                    "name": f"OpenCV Camera @ {target}",
+                    "type": "OpenCV",
+                    "id": target,
+                    "backend_api": camera.getBackendName(),
+                    "default_stream_profile": {
+                        "format": default_format,
+                        "fourcc": default_fourcc,
+                        "width": default_width,
+                        "height": default_height,
+                        "fps": default_fps,
+                    },
+                }
 
-                    found_cameras_info.append(camera_info)
-            finally:
+                found_cameras_info.append(camera_info)
                 camera.release()
 
         return found_cameras_info
@@ -516,26 +496,6 @@ class OpenCVCamera(Camera):
             self.latest_timestamp = None
             self.new_frame_event.clear()
 
-    def _cleanup_resources(self) -> None:
-        """Stop background reads and release the capture, including after partial setup."""
-        read_thread = self.thread
-        videocapture = self.videocapture
-
-        try:
-            self._stop_read_thread()
-        finally:
-            self.videocapture = None
-            try:
-                if videocapture is not None:
-                    videocapture.release()
-            finally:
-                # Releasing the device may unblock a hardware read that outlived
-                # the first bounded join in _stop_read_thread().
-                if read_thread is not None and read_thread.is_alive():
-                    read_thread.join(timeout=2.0)
-                    if read_thread.is_alive():  # pragma: no cover
-                        logger.warning(f"{self} read thread remained alive after releasing the capture.")
-
     @check_if_not_connected
     def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
         """
@@ -626,6 +586,16 @@ class OpenCVCamera(Camera):
         if not self.is_connected and self.thread is None:
             raise DeviceNotConnectedError(f"{self} not connected.")
 
-        self._cleanup_resources()
+        if self.thread is not None:
+            self._stop_read_thread()
+
+        if self.videocapture is not None:
+            self.videocapture.release()
+            self.videocapture = None
+
+        with self.frame_lock:
+            self.latest_frame = None
+            self.latest_timestamp = None
+            self.new_frame_event.clear()
 
         logger.info(f"{self} disconnected.")

src/lerobot/cameras/reachy2_camera/reachy2_camera.py

@@ -173,8 +173,7 @@ class Reachy2Camera(Camera):
             raise ValueError(
                 f"Invalid color mode '{self.color_mode}'. Expected {ColorMode.RGB} or {ColorMode.BGR}."
             )
-        is_depth_frame = self.config.name == "depth" and self.config.image_type == "depth"
-        if not is_depth_frame and self.color_mode == ColorMode.RGB:
+        if self.color_mode == ColorMode.RGB:
             frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
         self.latest_frame = frame

src/lerobot/cameras/realsense/camera_realsense.py

@@ -121,9 +121,6 @@ class RealSenseCamera(Camera):
 
         self.config = config
 
-        self.width: int | None = config.width
-        self.height: int | None = config.height
-
         if config.serial_number_or_name.isdigit():
             self.serial_number = config.serial_number_or_name
         else:
@@ -134,9 +131,6 @@ class RealSenseCamera(Camera):
         self.use_rgb = config.use_rgb
         self.use_depth = config.use_depth
         self.warmup_s = config.warmup_s
-        self.exposure: int | None = config.exposure
-        self.gain: int | None = config.gain
-        self.white_balance: int | None = config.white_balance
 
         self.rs_pipeline: rs.pipeline | None = None
         self.rs_profile: rs.pipeline_profile | None = None
@@ -151,23 +145,14 @@ class RealSenseCamera(Camera):
 
         self.rotation: int | None = get_cv2_rotation(config.rotation)
 
-        self.capture_width: int | None = None
-        self.capture_height: int | None = None
-        self._reset_connection_settings()
+        if self.height and self.width:
+            self.capture_width, self.capture_height = self.width, self.height
+            if self.rotation in [cv2.ROTATE_90_CLOCKWISE, cv2.ROTATE_90_COUNTERCLOCKWISE]:
+                self.capture_width, self.capture_height = self.height, self.width
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.serial_number})"
 
-    def _reset_connection_settings(self) -> None:
-        """Restore settings that may have been auto-detected during a failed connection."""
-        self.fps = self.config.fps
-        self.width = self.config.width
-        self.height = self.config.height
-        self.warmup_s = self.config.warmup_s
-        self.capture_width, self.capture_height = self.width, self.height
-        if self.rotation in [cv2.ROTATE_90_CLOCKWISE, cv2.ROTATE_90_COUNTERCLOCKWISE]:
-            self.capture_width, self.capture_height = self.height, self.width
-
     @property
     def is_connected(self) -> bool:
         """Checks if the camera pipeline is started and streams are active."""
@@ -187,8 +172,7 @@ class RealSenseCamera(Camera):
 
         Raises:
             DeviceAlreadyConnectedError: If the camera is already connected.
-            ValueError: If the configuration is invalid, a requested sensor option is unsupported,
-                or a requested sensor value is invalid.
+            ValueError: If the configuration is invalid (e.g., missing serial/name, name not unique).
             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.
         """
@@ -206,31 +190,22 @@ class RealSenseCamera(Camera):
                 f"Failed to open {self}.Run `lerobot-find-cameras realsense` to find available cameras."
             ) from e
 
-        try:
-            self._configure_capture_settings()
-            self._configure_sensor_options()
-            self._start_read_thread()
+        self._configure_capture_settings()
+        self._start_read_thread()
 
-            # NOTE(Steven/Caroline): Enforcing at least one second of warmup as RS cameras need a bit of time before the first read. If we don't wait, the first read from the warmup will raise.
-            self.warmup_s = max(self.warmup_s, 1)
+        # NOTE(Steven/Caroline): Enforcing at least one second of warmup as RS cameras need a bit of time before the first read. If we don't wait, the first read from the warmup will raise.
+        self.warmup_s = max(self.warmup_s, 1)
 
-            warmup_read = self.async_read if self.use_rgb else self.async_read_depth
-            start_time = time.time()
-            while time.time() - start_time < self.warmup_s:
-                warmup_read(timeout_ms=self.warmup_s * 1000)
-                time.sleep(0.1)
-            with self.frame_lock:
-                if (self.use_rgb and self.latest_color_frame is None) or (
-                    self.use_depth and self.latest_depth_frame is None
-                ):
-                    raise ConnectionError(f"{self} failed to capture frames during warmup.")
-        except BaseException:
-            try:
-                self._cleanup_resources()
-            except Exception:
-                logger.exception(f"Failed to fully clean up {self} after connect() failed.")
-            self._reset_connection_settings()
-            raise
+        warmup_read = self.async_read if self.use_rgb else self.async_read_depth
+        start_time = time.time()
+        while time.time() - start_time < self.warmup_s:
+            warmup_read(timeout_ms=self.warmup_s * 1000)
+            time.sleep(0.1)
+        with self.frame_lock:
+            if (self.use_rgb and self.latest_color_frame is None) or (
+                self.use_depth and self.latest_depth_frame is None
+            ):
+                raise ConnectionError(f"{self} failed to capture frames during warmup.")
 
         logger.info(f"{self} connected.")
 
@@ -364,111 +339,6 @@ class RealSenseCamera(Camera):
         self.new_frame_event.clear()
         return self._async_read(timeout_ms=10000, read_depth=read_depth)
 
-    def _get_color_sensor(self) -> "rs.sensor":
-        """Returns the sensor that controls the color stream.
-
-        Most RealSense cameras expose "RGB Camera" for color. The D405 has no
-        separate RGB module — its color stream comes from "Stereo Module".
-        We try RGB Camera first, then fall back to Stereo Module.
-        """
-        if self.rs_profile is None:
-            raise RuntimeError(f"{self}: rs_profile must be initialized before use.")
-
-        device = self.rs_profile.get_device()
-        sensors = {s.get_info(rs.camera_info.name): s for s in device.query_sensors()}
-
-        for name in ("RGB Camera", "Stereo Module"):
-            if name in sensors:
-                return sensors[name]
-
-        available = list(sensors.keys())
-        raise RuntimeError(f"{self}: no color sensor found. Available sensors: {available}")
-
-    def _set_sensor_option(self, sensor: "rs.sensor", option: "rs.option", value: float, label: str) -> None:
-        """Sets a sensor option, re-raising range errors with actionable diagnostics."""
-        try:
-            sensor.set_option(option, value)
-        except Exception as e:
-            range_info = ""
-            try:
-                option_range = sensor.get_option_range(option)
-                range_info = (
-                    f" (supported range: min={option_range.min}, max={option_range.max}, "
-                    f"step={option_range.step}, default={option_range.default})"
-                )
-            except Exception:
-                range_info = " (option range unavailable)"
-            raise ValueError(
-                f"{self}: failed to set {label} to {value}{range_info}. Original error: {e}"
-            ) from e
-
-    def _configure_sensor_options(self) -> None:
-        """Applies manual sensor options (exposure, gain, white balance) to the color sensor.
-
-        When exposure or gain is set, auto-exposure is disabled first. When white_balance
-        is set, auto white balance is disabled first. An omitted option is left unchanged,
-        and configuration is skipped entirely if all options are omitted.
-
-        Raises:
-            ValueError: If the sensor does not support a requested option or a requested
-                value is invalid. Invalid-value errors include the option name, requested
-                value, and supported range when available.
-        """
-        if self.exposure is None and self.gain is None and self.white_balance is None:
-            return
-
-        color_sensor = self._get_color_sensor()
-
-        requested_options = (
-            (rs.option.exposure, self.exposure, "exposure"),
-            (rs.option.gain, self.gain, "gain"),
-            (rs.option.white_balance, self.white_balance, "white balance"),
-        )
-        unsupported_options = [
-            label
-            for option, value, label in requested_options
-            if value is not None and not color_sensor.supports(option)
-        ]
-        if unsupported_options:
-            raise ValueError(
-                f"{self}: color sensor does not support requested manual options: {unsupported_options}."
-            )
-
-        manual_exposure_requested = self.exposure is not None or self.gain is not None
-        if manual_exposure_requested:
-            if color_sensor.supports(rs.option.enable_auto_exposure):
-                self._set_sensor_option(color_sensor, rs.option.enable_auto_exposure, 0, "auto-exposure")
-                logger.info(f"{self} auto-exposure disabled.")
-            else:
-                logger.warning(
-                    f"{self} sensor does not support disabling auto-exposure; "
-                    "applying manual exposure/gain directly."
-                )
-
-        if self.exposure is not None:
-            self._set_sensor_option(color_sensor, rs.option.exposure, self.exposure, "exposure")
-            logger.info(f"{self} exposure set to {self.exposure}.")
-
-        if self.gain is not None:
-            self._set_sensor_option(color_sensor, rs.option.gain, self.gain, "gain")
-            logger.info(f"{self} gain set to {self.gain}.")
-
-        if self.white_balance is not None:
-            if color_sensor.supports(rs.option.enable_auto_white_balance):
-                self._set_sensor_option(
-                    color_sensor, rs.option.enable_auto_white_balance, 0, "auto white balance"
-                )
-                logger.info(f"{self} auto white balance disabled.")
-            else:
-                logger.warning(
-                    f"{self} sensor does not support disabling auto white balance; "
-                    "applying manual white balance directly."
-                )
-            self._set_sensor_option(
-                color_sensor, rs.option.white_balance, self.white_balance, "white balance"
-            )
-            logger.info(f"{self} white balance set to {self.white_balance}.")
-
     @check_if_not_connected
     def read_depth(self, timeout_ms: int = 200) -> NDArray[Any]:
         """
@@ -583,7 +453,7 @@ class RealSenseCamera(Camera):
             )
 
         processed_image = image
-        if not depth_frame and self.color_mode == ColorMode.BGR:
+        if self.color_mode == ColorMode.BGR:
             processed_image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
 
         if self.rotation in [cv2.ROTATE_90_CLOCKWISE, cv2.ROTATE_90_COUNTERCLOCKWISE, cv2.ROTATE_180]:
@@ -671,27 +541,6 @@ class RealSenseCamera(Camera):
             self.latest_timestamp = None
             self.new_frame_event.clear()
 
-    def _cleanup_resources(self) -> None:
-        """Stop background reads and stop the pipeline, including after partial setup."""
-        read_thread = self.thread
-        rs_pipeline = self.rs_pipeline
-
-        try:
-            self._stop_read_thread()
-        finally:
-            self.rs_pipeline = None
-            self.rs_profile = None
-            try:
-                if rs_pipeline is not None:
-                    rs_pipeline.stop()
-            finally:
-                # Stopping the pipeline may unblock a hardware read that outlived
-                # the first bounded join in _stop_read_thread().
-                if read_thread is not None and read_thread.is_alive():
-                    read_thread.join(timeout=2.0)
-                    if read_thread.is_alive():  # pragma: no cover
-                        logger.warning(f"{self} read thread remained alive after stopping the pipeline.")
-
     def _async_read(self, timeout_ms: float, read_depth: bool = False) -> NDArray[Any]:
         """Shared helper for :meth:`async_read`/:meth:`async_read_depth`: return the latest buffered frame."""
         if self.thread is None or not self.thread.is_alive():
@@ -835,5 +684,18 @@ class RealSenseCamera(Camera):
                 f"Attempted to disconnect {self}, but it appears already disconnected."
             )
 
-        self._cleanup_resources()
+        if self.thread is not None:
+            self._stop_read_thread()
+
+        if self.rs_pipeline is not None:
+            self.rs_pipeline.stop()
+            self.rs_pipeline = None
+            self.rs_profile = None
+
+        with self.frame_lock:
+            self.latest_color_frame = None
+            self.latest_depth_frame = None
+            self.latest_timestamp = None
+            self.new_frame_event.clear()
+
         logger.info(f"{self} disconnected.")

src/lerobot/cameras/realsense/configuration_realsense.py

@@ -46,17 +46,6 @@ class RealSenseCameraConfig(CameraConfig):
         use_depth: Whether to enable depth stream. Defaults to False.
         rotation: Image rotation setting (0°, 90°, 180°, or 270°). Defaults to no rotation.
         warmup_s: Time reading frames before returning from connect (in seconds)
-        exposure: Manual exposure value for the color sensor. When set, auto-exposure is
-            disabled and this fixed value is used. Valid ranges are camera-model specific
-            and reported if the value is rejected. Defaults to None (leave unchanged).
-        gain: Manual gain value for the color sensor. When set, auto-exposure is disabled
-            and this fixed gain is used, which also freezes exposure at its current value
-            when no exposure is configured. Valid ranges are camera-model specific and
-            reported if the value is rejected. Defaults to None (leave unchanged).
-        white_balance: Manual white balance value for the color sensor. When set, auto
-            white balance is disabled and this fixed value is used. Valid ranges are
-            camera-model specific and reported if the value is rejected. Defaults to None
-            (leave unchanged).
 
     Note:
         - Either name or serial_number must be specified.
@@ -72,9 +61,6 @@ class RealSenseCameraConfig(CameraConfig):
     use_depth: bool = False
     rotation: Cv2Rotation = Cv2Rotation.NO_ROTATION
     warmup_s: int = 1
-    exposure: int | None = None
-    gain: int | None = None
-    white_balance: int | None = None
 
     def __post_init__(self) -> None:
         self.color_mode = ColorMode(self.color_mode)
@@ -83,18 +69,6 @@ class RealSenseCameraConfig(CameraConfig):
         if not self.use_rgb and not self.use_depth:
             raise ValueError("At least one of `use_rgb` or `use_depth` must be enabled.")
 
-        manual_color_options = {
-            "exposure": self.exposure,
-            "gain": self.gain,
-            "white_balance": self.white_balance,
-        }
-        configured_color_options = [name for name, value in manual_color_options.items() if value is not None]
-        if configured_color_options and not self.use_rgb:
-            raise ValueError(
-                "Manual color sensor options require `use_rgb=True`. "
-                f"Configured options: {configured_color_options}."
-            )
-
         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):
             raise ValueError(

src/lerobot/configs/dataset.py

@@ -71,19 +71,13 @@ class DatasetRecordConfig:
     # Number of threads per encoder instance. None = auto (codec default).
     # Lower values reduce CPU usage, maps to 'lp' (via svtav1-params) for libsvtav1 and 'threads' for h264/hevc..
     encoder_threads: int | None = None
-    # Skip appending the date-time tag to repo_id, keeping the user-provided name as-is
-    # (e.g. self-managed versioned names intended for a later `lerobot-edit-dataset merge`).
-    no_stamp: bool = False
 
     def stamp_repo_id(self) -> None:
         """Append a date-time tag to ``repo_id`` so each recording session gets a unique name.
 
         Must be called explicitly at dataset *creation* time — not on resume,
         where the existing ``repo_id`` (already stamped) must be preserved.
-        No-op when ``no_stamp`` is set, preserving a user-managed ``repo_id``.
         """
-        if self.no_stamp:
-            return
         if self.repo_id:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             self.repo_id = f"{self.repo_id}_{timestamp}"

src/lerobot/configs/train.py

@@ -14,7 +14,6 @@
 import builtins
 import datetime as dt
 import json
-import multiprocessing
 import os
 import tempfile
 from dataclasses import dataclass, field
@@ -102,12 +101,6 @@ class TrainPipelineConfig(HubMixin):
     batch_size: int = 8
     prefetch_factor: int = 4
     persistent_workers: bool = True
-    # DataLoader worker start method. "spawn" is safer than "fork" with
-    # non-fork-safe libs (PyAV / torchcodec / ffmpeg), but adds some
-    # worker-startup time per run since workers re-import modules instead
-    # of inheriting parent state. Override with `--dataloader_multiprocessing_context=fork`
-    # when appropriate, or set it to `null` to use Python's platform default.
-    dataloader_multiprocessing_context: str | None = "spawn"
     steps: int = 100_000
     # Run policy in the simulation environment every N steps to measure reward/success (0 = disabled).
     env_eval_freq: int = 20_000
@@ -219,17 +212,6 @@ class TrainPipelineConfig(HubMixin):
             self.reward_model.pretrained_path = str(policy_dir)
 
     def validate(self) -> None:
-        available_contexts = multiprocessing.get_all_start_methods()
-        if (
-            self.dataloader_multiprocessing_context is not None
-            and self.dataloader_multiprocessing_context not in available_contexts
-        ):
-            raise ValueError(
-                "`dataloader_multiprocessing_context` must be None or one of "
-                f"{available_contexts} on this platform, got "
-                f"{self.dataloader_multiprocessing_context!r}."
-            )
-
         self._resolve_pretrained_from_cli()
 
         if self.policy is None and self.reward_model is None:

src/lerobot/datasets/dataset_metadata.py

@@ -73,8 +73,6 @@ class LeRobotDatasetMetadata:
         revision: str | None = None,
         force_cache_sync: bool = False,
         metadata_buffer_size: int = 10,
-        *,
-        token: str | bool | None = None,
     ):
         """Load or download metadata for an existing LeRobot dataset.
 
@@ -96,10 +94,6 @@ class LeRobotDatasetMetadata:
                 even when local files exist.
             metadata_buffer_size: Number of episode metadata records to buffer
                 in memory before flushing to parquet.
-            token: Authentication token used for Hub requests. Pass a string
-                token, ``True`` to require the locally stored token, ``False``
-                to disable authentication, or ``None`` to use the Hugging Face
-                Hub default.
         """
         self.repo_id = repo_id
         self.revision = revision if revision else CODEBASE_VERSION
@@ -119,12 +113,9 @@ class LeRobotDatasetMetadata:
             self._load_metadata()
         except (FileNotFoundError, NotADirectoryError):
             if is_valid_version(self.revision):
-                if token is None:
-                    self.revision = get_safe_version(self.repo_id, self.revision)
-                else:
-                    self.revision = get_safe_version(self.repo_id, self.revision, token=token)
+                self.revision = get_safe_version(self.repo_id, self.revision)
 
-            self._pull_from_repo(allow_patterns="meta/", token=token)
+            self._pull_from_repo(allow_patterns="meta/")
             self._load_metadata()
 
     def _flush_metadata_buffer(self) -> None:
@@ -188,8 +179,8 @@ class LeRobotDatasetMetadata:
     def _load_metadata(self):
         self.info = load_info(self.root)
         check_version_compatibility(self.repo_id, self._version, CODEBASE_VERSION)
-        self.tasks = load_tasks(self.root) if self.total_tasks > 0 else None
-        self.episodes = load_episodes(self.root) if self.total_episodes > 0 else None
+        self.tasks = load_tasks(self.root)
+        self.episodes = load_episodes(self.root)
         self.stats = load_stats(self.root)
 
     def ensure_readable(self) -> None:
@@ -229,10 +220,7 @@ class LeRobotDatasetMetadata:
         self,
         allow_patterns: list[str] | str | None = None,
         ignore_patterns: list[str] | str | None = None,
-        *,
-        token: str | bool | None = None,
     ) -> None:
-        token_kwargs = {} if token is None else {"token": token}
         if self._requested_root is None:
             self.root = Path(
                 snapshot_download(
@@ -242,7 +230,6 @@ class LeRobotDatasetMetadata:
                     cache_dir=HF_LEROBOT_HUB_CACHE,
                     allow_patterns=allow_patterns,
                     ignore_patterns=ignore_patterns,
-                    **token_kwargs,
                 )
             )
             return
@@ -255,7 +242,6 @@ class LeRobotDatasetMetadata:
             local_dir=self._requested_root,
             allow_patterns=allow_patterns,
             ignore_patterns=ignore_patterns,
-            **token_kwargs,
         )
         self.root = self._requested_root
 

src/lerobot/datasets/dataset_writer.py

@@ -172,23 +172,6 @@ class DatasetWriter:
     def _get_image_file_dir(self, episode_index: int, image_key: str) -> Path:
         return self._get_image_file_path(episode_index, image_key, frame_index=0).parent
 
-    def _get_episode_buffer_index(self) -> int:
-        episode_index = self.episode_buffer["episode_index"]
-        # episode_index is `int` when freshly created, but becomes `np.ndarray` after
-        # save_episode() mutates the buffer. Handle both types here.
-        if isinstance(episode_index, np.ndarray):
-            episode_index = episode_index.item() if episode_index.size == 1 else episode_index[0]
-        return int(episode_index)
-
-    def _delete_camera_frame_dirs(self, camera_keys: list[str]) -> None:
-        if self.image_writer is not None:
-            self._wait_image_writer()
-        episode_index = self._get_episode_buffer_index()
-        for camera_key in camera_keys:
-            img_dir = self._get_image_file_dir(episode_index, camera_key)
-            if img_dir.is_dir():
-                shutil.rmtree(img_dir)
-
     def _save_image(
         self, image: torch.Tensor | np.ndarray | PIL.Image.Image, fpath: Path, compress_level: int = 1
     ) -> None:
@@ -386,9 +369,7 @@ class DatasetWriter:
                 self._episodes_since_last_encoding = 0
 
         if episode_data is None:
-            if len(self._meta.image_keys) > 0:
-                self._delete_camera_frame_dirs(self._meta.image_keys)
-            self.episode_buffer = self._create_episode_buffer()
+            self.clear_episode_buffer(delete_images=len(self._meta.image_keys) > 0)
 
     def _batch_save_episode_video(self, start_episode: int, end_episode: int | None = None) -> None:
         """Batch save videos for multiple episodes."""
@@ -580,10 +561,10 @@ class DatasetWriter:
         return metadata
 
     def clear_episode_buffer(self, delete_images: bool = True) -> None:
-        """Discard the current episode buffer and optionally delete temp camera frames.
+        """Discard the current episode buffer and optionally delete temp images.
 
         Args:
-            delete_images: If ``True``, remove temporary camera frame directories
+            delete_images: If ``True``, remove temporary image directories
                 written for the current episode.
         """
         # Cancel streaming encoder if active
@@ -591,7 +572,17 @@ class DatasetWriter:
             self._streaming_encoder.cancel_episode()
 
         if delete_images:
-            self._delete_camera_frame_dirs(self._meta.camera_keys)
+            if self.image_writer is not None:
+                self._wait_image_writer()
+            episode_index = self.episode_buffer["episode_index"]
+            # episode_index is `int` when freshly created, but becomes `np.ndarray` after
+            # save_episode() mutates the buffer. Handle both types here.
+            if isinstance(episode_index, np.ndarray):
+                episode_index = episode_index.item() if episode_index.size == 1 else episode_index[0]
+            for cam_key in self._meta.image_keys:
+                img_dir = self._get_image_file_dir(episode_index, cam_key)
+                if img_dir.is_dir():
+                    shutil.rmtree(img_dir)
 
         self.episode_buffer = self._create_episode_buffer()
 

src/lerobot/datasets/lerobot_dataset.py

@@ -65,8 +65,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
         encoder_threads: int | None = None,
         streaming_encoding: bool = False,
         encoder_queue_maxsize: int = 30,
-        *,
-        token: str | bool | None = None,
     ):
         """
         2 modes are available for instantiating this class, depending on 2 different use cases:
@@ -199,11 +197,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
                 instead of writing PNG images first. This makes save_episode() near-instant. Defaults to False.
             encoder_queue_maxsize (int, optional): Maximum number of frames to buffer per camera when using
                 streaming encoding. Defaults to 30 (~1s at 30fps).
-            token: Authentication token used while downloading this dataset
-                from the Hub. Pass a string token, ``True`` to require the
-                locally stored token, ``False`` to disable authentication, or
-                ``None`` to use the Hugging Face Hub default. The token is not
-                retained on the dataset instance after initialization.
 
         Note:
             Write-mode parameters (``streaming_encoding``, ``batch_encoding_size``) passed to
@@ -227,11 +220,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
 
         # Load metadata (sets self.root once from the resolved metadata root)
         self.meta = LeRobotDatasetMetadata(
-            self.repo_id,
-            self._requested_root,
-            self.revision,
-            force_cache_sync=force_cache_sync,
-            token=token,
+            self.repo_id, self._requested_root, self.revision, force_cache_sync=force_cache_sync
         )
         self.root = self.meta.root
         self.revision = self.meta.revision
@@ -271,11 +260,8 @@ class LeRobotDataset(torch.utils.data.Dataset):
         # Load actual data
         if force_cache_sync or not self.reader.try_load():
             if is_valid_version(self.revision):
-                if token is None:
-                    self.revision = get_safe_version(self.repo_id, self.revision)
-                else:
-                    self.revision = get_safe_version(self.repo_id, self.revision, token=token)
-            self._download(download_videos, token=token)
+                self.revision = get_safe_version(self.repo_id, self.revision)
+            self._download(download_videos)
             self.reader.load_and_activate()
 
         # Detect write-mode params for backward compatibility
@@ -492,19 +478,18 @@ class LeRobotDataset(torch.utils.data.Dataset):
         """Return the number of frames in the selected episodes."""
         return self.num_frames
 
-    def __getitem__(self, idx: int | slice) -> dict | list[dict]:
-        """Return one frame or a slice of frames, with all transforms applied.
+    def __getitem__(self, idx) -> dict:
+        """Return a single frame by index, with all transforms applied.
 
         Loads the frame from the underlying HF dataset, expands delta-timestamp
         windows, decodes video frames, and applies image transforms. Delegates
-        the core logic to :class:`DatasetReader`.
+        the core logic to :meth:`DatasetReader.get_item`.
 
         Args:
-            idx: Integer index or slice into the possibly episode-filtered dataset.
+            idx: Index into the (possibly episode-filtered) dataset.
 
         Returns:
-            A frame dictionary for an integer index, or a list of frame
-            dictionaries for a slice.
+            Dict mapping feature names to their tensor values for this frame.
 
         Raises:
             RuntimeError: If the dataset is currently being recorded and
@@ -514,9 +499,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
             raise RuntimeError(
                 "Cannot read from a dataset that is being recorded. Call finalize() first, then access items."
             )
-        if isinstance(idx, slice):
-            return [self[item_idx] for item_idx in range(*idx.indices(len(self)))]
-
         reader = self._ensure_reader()
         if reader.hf_dataset is None:
             # One-shot load after finalize()
@@ -640,11 +622,10 @@ class LeRobotDataset(torch.utils.data.Dataset):
                 hub_api.delete_tag(self.repo_id, tag=CODEBASE_VERSION, repo_type="dataset")
             hub_api.create_tag(self.repo_id, tag=CODEBASE_VERSION, revision=branch, repo_type="dataset")
 
-    def _download(self, download_videos: bool = True, *, token: str | bool | None = None) -> None:
+    def _download(self, download_videos: bool = True) -> None:
         """Downloads the dataset from the given 'repo_id' at the provided version."""
         ignore_patterns = None if download_videos else "videos/"
         files = None
-        token_kwargs = {} if token is None else {"token": token}
         if self.episodes is not None:
             # Reader is guaranteed to exist here (created in __init__ before _download)
             files = self.reader.get_episodes_file_paths()
@@ -658,7 +639,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
                     cache_dir=HF_LEROBOT_HUB_CACHE,
                     allow_patterns=files,
                     ignore_patterns=ignore_patterns,
-                    **token_kwargs,
                 )
             )
         else:
@@ -670,7 +650,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
                 local_dir=self._requested_root,
                 allow_patterns=files,
                 ignore_patterns=ignore_patterns,
-                **token_kwargs,
             )
             self.meta.root = self._requested_root
 
@@ -810,8 +789,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
         image_writer_threads: int = 0,
         streaming_encoding: bool = False,
         encoder_queue_maxsize: int = 30,
-        *,
-        token: str | bool | None = None,
     ) -> "LeRobotDataset":
         """Resume recording on an existing dataset.
 
@@ -845,8 +822,6 @@ class LeRobotDataset(torch.utils.data.Dataset):
             streaming_encoding: If ``True``, encode video in real-time during
                 capture.
             encoder_queue_maxsize: Max buffered frames per camera for streaming.
-            token: Authentication token used if metadata must be downloaded
-                from the Hub. The token is not retained on the dataset instance.
 
         Returns:
             A :class:`LeRobotDataset` in write mode, ready to append episodes.
@@ -875,11 +850,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
 
         # Load metadata (revision-safe when root is not provided)
         obj.meta = LeRobotDatasetMetadata(
-            obj.repo_id,
-            obj._requested_root,
-            obj.revision,
-            force_cache_sync=force_cache_sync,
-            token=token,
+            obj.repo_id, obj._requested_root, obj.revision, force_cache_sync=force_cache_sync
         )
 
         obj._encoder_threads = encoder_threads

src/lerobot/datasets/multi_dataset.py

@@ -48,8 +48,6 @@ class MultiLeRobotDataset(torch.utils.data.Dataset):
         tolerances_s: dict | None = None,
         download_videos: bool = True,
         video_backend: str | None = None,
-        *,
-        token: str | bool | None = None,
     ):
         super().__init__()
         self.repo_ids = repo_ids
@@ -67,7 +65,6 @@ class MultiLeRobotDataset(torch.utils.data.Dataset):
                 tolerance_s=self.tolerances_s[repo_id],
                 download_videos=download_videos,
                 video_backend=video_backend,
-                token=token,
             )
             for repo_id in repo_ids
         ]

src/lerobot/datasets/streaming_dataset.py

@@ -256,8 +256,6 @@ class StreamingLeRobotDataset(torch.utils.data.IterableDataset):
         shuffle: bool = True,
         return_uint8: bool = False,
         depth_output_unit: str = DEFAULT_DEPTH_UNIT,
-        *,
-        token: str | bool | None = None,
     ):
         """Initialize a StreamingLeRobotDataset.
 
@@ -280,11 +278,6 @@ class StreamingLeRobotDataset(torch.utils.data.IterableDataset):
             shuffle (bool, optional): Whether to shuffle the dataset across exhaustions. Defaults to True.
             depth_output_unit (str, optional): Physical unit depth maps are dequantized to ("m" or "mm").
                 Defaults to "mm".
-            token: Authentication token used while streaming this dataset from
-                the Hub. Pass a string token, ``True`` to require the locally
-                stored token, ``False`` to disable authentication, or ``None``
-                to use the Hugging Face Hub default. The token is not retained
-                on the dataset instance after initialization.
         """
         super().__init__()
         self.repo_id = repo_id
@@ -313,11 +306,7 @@ class StreamingLeRobotDataset(torch.utils.data.IterableDataset):
 
         # Load metadata
         self.meta = LeRobotDatasetMetadata(
-            self.repo_id,
-            self._requested_root,
-            self.revision,
-            force_cache_sync=force_cache_sync,
-            token=token,
+            self.repo_id, self._requested_root, self.revision, force_cache_sync=force_cache_sync
         )
         self.root = self.meta.root
         self.revision = self.meta.revision
@@ -345,14 +334,12 @@ class StreamingLeRobotDataset(torch.utils.data.IterableDataset):
             self.delta_timestamps = delta_timestamps
             self.delta_indices = get_delta_indices(self.delta_timestamps, self.fps)
 
-        token_kwargs = {} if token is None or self.streaming_from_local else {"token": token}
         self.hf_dataset: datasets.IterableDataset = load_dataset(
             self.repo_id if not self.streaming_from_local else str(self.root),
             split="train",
             streaming=self.streaming,
             data_files="data/*/*.parquet",
             revision=self.revision,
-            **token_kwargs,
         )
 
         self.num_shards = min(self.hf_dataset.num_shards, max_num_shards)

src/lerobot/datasets/utils.py

@@ -325,19 +325,16 @@ def check_version_compatibility(
         logging.warning(FUTURE_MESSAGE.format(repo_id=repo_id, version=v_check))
 
 
-def get_repo_versions(repo_id: str, *, token: str | bool | None = None) -> list[packaging.version.Version]:
+def get_repo_versions(repo_id: str) -> list[packaging.version.Version]:
     """Return available valid versions (branches and tags) on a given Hub repo.
 
     Args:
         repo_id (str): The repository ID on the Hugging Face Hub.
-        token: Authentication token used for Hub requests. Pass a string token,
-            ``True`` to require the locally stored token, ``False`` to disable
-            authentication, or ``None`` to use the Hugging Face Hub default.
 
     Returns:
         list[packaging.version.Version]: A list of valid versions found.
     """
-    api = HfApi() if token is None else HfApi(token=token)
+    api = HfApi()
     repo_refs = api.list_repo_refs(repo_id, repo_type="dataset")
     repo_refs = [b.name for b in repo_refs.branches + repo_refs.tags]
     repo_versions = []
@@ -348,12 +345,7 @@ def get_repo_versions(repo_id: str, *, token: str | bool | None = None) -> list[
     return repo_versions
 
 
-def get_safe_version(
-    repo_id: str,
-    version: str | packaging.version.Version,
-    *,
-    token: str | bool | None = None,
-) -> str:
+def get_safe_version(repo_id: str, version: str | packaging.version.Version) -> str:
     """Return the specified version if available on repo, or the latest compatible one.
 
     If the exact version is not found, it looks for the latest version with the
@@ -362,7 +354,6 @@ def get_safe_version(
     Args:
         repo_id (str): The repository ID on the Hugging Face Hub.
         version (str | packaging.version.Version): The target version.
-        token: Authentication token forwarded to the Hub version lookup.
 
     Returns:
         str: The safe version string (e.g., "v1.2.3") to use as a revision.
@@ -375,7 +366,7 @@ def get_safe_version(
     target_version = (
         packaging.version.parse(version) if not isinstance(version, packaging.version.Version) else version
     )
-    hub_versions = get_repo_versions(repo_id) if token is None else get_repo_versions(repo_id, token=token)
+    hub_versions = get_repo_versions(repo_id)
 
     if not hub_versions:
         raise RevisionNotFoundError(

src/lerobot/envs/configs.py

@@ -322,7 +322,7 @@ class HILSerlRobotEnvConfig(EnvConfig):
 class LiberoEnv(EnvConfig):
     task: str = "libero_10"  # can also choose libero_spatial, libero_object, etc.
     task_ids: list[int] | None = None
-    fps: int = 20  # Must match robosuite's default control_freq (20 Hz)
+    fps: int = 30
     episode_length: int | None = None
     obs_type: str = "pixels_agent_pos"
     render_mode: str = "rgb_array"
@@ -354,9 +354,6 @@ class LiberoEnv(EnvConfig):
     control_mode: str = "relative"  # or "absolute"
 
     def __post_init__(self):
-        if self.fps <= 0:
-            raise ValueError(f"fps must be positive, got {self.fps}")
-
         if self.obs_type == "pixels":
             self.features[LIBERO_KEY_PIXELS_AGENTVIEW] = PolicyFeature(
                 type=FeatureType.VISUAL, shape=(self.observation_height, self.observation_width, 3)
@@ -415,7 +412,6 @@ class LiberoEnv(EnvConfig):
             "render_mode": self.render_mode,
             "observation_height": self.observation_height,
             "observation_width": self.observation_width,
-            "control_freq": self.fps,
         }
         if self.task_ids is not None:
             kwargs["task_ids"] = self.task_ids

src/lerobot/envs/libero.py

@@ -125,13 +125,10 @@ class LiberoEnv(gym.Env):
         n_envs: int = 1,
         camera_name_mapping: dict[str, str] | None = None,
         num_steps_wait: int = 10,
-        control_freq: int = 20,
         control_mode: str = "relative",
         is_libero_plus: bool = False,
     ):
         super().__init__()
-        if control_freq <= 0:
-            raise ValueError(f"control_freq must be positive, got {control_freq}")
         self.task_id = task_id
         self.is_libero_plus = is_libero_plus
         self.obs_type = obs_type
@@ -157,7 +154,6 @@ class LiberoEnv(gym.Env):
             }
         self.camera_name_mapping = camera_name_mapping
         self.num_steps_wait = num_steps_wait
-        self.control_freq = control_freq
         self.episode_index = episode_index
         self.episode_length = episode_length
         # Load once and keep
@@ -264,7 +260,6 @@ class LiberoEnv(gym.Env):
             bddl_file_name=self._task_bddl_file,
             camera_heights=self.observation_height,
             camera_widths=self.observation_width,
-            control_freq=self.control_freq,
         )
         env.reset()
         self._env = env

src/lerobot/envs/metaworld.py

@@ -155,7 +155,6 @@ class MetaworldEnv(gym.Env):
             env.model.cam_pos[2] = [0.75, 0.075, 0.7]
         env.reset()
         env._freeze_rand_vec = False  # otherwise no randomization
-        env.seeded_rand_vec = True  # use seeded RNG so reset(seed=X) controls object positions
         self._env = env
 
     def render(self) -> np.ndarray:
@@ -221,8 +220,6 @@ class MetaworldEnv(gym.Env):
         self._ensure_env()
         super().reset(seed=seed)
 
-        if seed is not None:
-            self._env.seed(seed)
         raw_obs, info = self._env.reset(seed=seed)
 
         observation = self._format_raw_obs(raw_obs)

src/lerobot/envs/robotwin.py

@@ -384,9 +384,7 @@ class RoboTwinEnv(gym.Env):
 
         self._env: Any | None = None  # deferred — created on first reset() inside worker
         self._step_count: int = 0
-        self._black_frame: np.ndarray = np.zeros(
-            (self.observation_height, self.observation_width, 3), dtype=np.uint8
-        )
+        self._black_frame = np.zeros((self.observation_height, self.observation_width, 3), dtype=np.uint8)
 
         image_spaces = {
             cam: spaces.Box(

src/lerobot/envs/vlabench.py

@@ -373,7 +373,7 @@ class VLABenchEnv(gym.Env):
 
         if action.shape[0] != 7:
             # Unknown layout — fall back to zero-pad so the sim doesn't crash.
-            padded: np.ndarray = np.zeros(ctrl_dim, dtype=np.float64)
+            padded = np.zeros(ctrl_dim, dtype=np.float64)
             padded[: min(action.shape[0], ctrl_dim)] = action[:ctrl_dim]
             return padded
 

src/lerobot/jobs/__init__.py

@@ -18,7 +18,6 @@ from lerobot.utils.import_utils import require_package
 # guard the optional dependency here so importing this package fails loudly if it's missing.
 require_package("datasets", extra="dataset")
 
-from .annotate import submit_annotate_to_hf
 from .hf import submit_to_hf
 
-__all__ = ["submit_annotate_to_hf", "submit_to_hf"]
+__all__ = ["submit_to_hf"]

src/lerobot/jobs/annotate.py

@@ -1,176 +0,0 @@
-# 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.
-"""Run ``lerobot-annotate`` on HF Jobs (HuggingFace GPUs).
-
-Same shape as the training submitter in ``hf.py``, with one difference: the
-annotation pipeline serves its own VLM, so the pod starts from the official
-``vllm/vllm-openai`` image (which has no lerobot) instead of the prebuilt
-``lerobot-gpu`` image, and installs lerobot on top before running.
-
-Because there is no config repo to stage, the pod replays the user's own CLI
-flags — everything except the client-only ``--job.*`` and the host-local
-``--root``, which is replaced by ``--repo_id`` so the pod pulls the dataset
-from the Hub.
-"""
-
-from __future__ import annotations
-
-import shlex
-import sys
-from dataclasses import is_dataclass
-from typing import TYPE_CHECKING
-
-from huggingface_hub import HfApi, get_token, run_job
-
-from .dataset import ensure_dataset_available
-
-# Package-internal reuse of the training submitter's job plumbing: following a
-# submitted job and forwarding argv are identical for annotation runs.
-from .hf import _pod_forwarded_args, follow_job, resolve_job_tags
-
-if TYPE_CHECKING:
-    from lerobot.annotations.steerable_pipeline.config import AnnotationPipelineConfig
-
-LEROBOT_GIT_URL = "https://github.com/huggingface/lerobot.git"
-
-# Mirrors the pins in pyproject.toml. The vLLM image resolves dependencies on its
-# own otherwise, and pulls av 18 / datasets 5 / draccus 0.11 — each of which breaks
-# lerobot at import time. `--upgrade-strategy only-if-needed` keeps vLLM's own
-# (torch, transformers, ...) pins intact.
-_RUNTIME_REQUIREMENTS = (
-    "'datasets>=4.7.0,<5.0.0' 'pyarrow>=21.0.0,<30.0.0' 'av>=15.0.0,<16.0.0' 'draccus==0.10.0' "
-    "'pandas>=2.0.0,<3.0.0' jsonlines gymnasium torchcodec mergedeep pyyaml-include toml typing-inspect "
-    "openai"
-)
-
-# Flags the submitter resolves itself instead of forwarding verbatim: `--root`
-# names a directory only this machine has, `--repo_id` is re-emitted from the
-# config, and the config-file args name local files (rejected up front by
-# `submit_annotate_to_hf`). `--job.*` is dropped separately, by prefix; bare
-# `--job` is not, hence its entry here — it is the one arg that could smuggle a
-# remote `target` onto the pod and have the job recursively submit itself.
-_SUBMITTER_OWNED_ARGS = ("--root", "--repo_id", "--config_path", "--job")
-
-
-def _local_config_file_args(cfg: AnnotationPipelineConfig) -> list[str]:
-    """The CLI args that name a config file on the client's disk.
-
-    draccus exposes ``--config_path`` for the whole config plus a ``--<field>``
-    for every nested dataclass (``--vlm``, ``--plan``, ``--job``, ...). The pod has
-    none of those files, so a remote run has to reject them rather than silently
-    drop the settings they carry.
-    """
-    return ["--config_path", *(f"--{name}" for name in vars(cfg) if is_dataclass(getattr(cfg, name)))]
-
-
-def build_pod_setup(lerobot_ref: str) -> str:
-    """Shell prelude that turns the vLLM image into a ``lerobot-annotate`` runtime."""
-    spec = f"lerobot @ git+{LEROBOT_GIT_URL}@{lerobot_ref}"
-    return (
-        # git to install from the repo, ffmpeg to decode the dataset's videos.
-        "apt-get update -qq && apt-get install -y -qq git ffmpeg && "
-        f"pip install --no-deps {shlex.quote(spec)} && "
-        f"pip install --upgrade-strategy only-if-needed {_RUNTIME_REQUIREMENTS} && "
-        # vLLM's cudagraph memory estimate over-reserves and starves the KV cache;
-        # PyAV is the video backend the server can decode our frames with.
-        "export VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS=0 && "
-        "export VLLM_VIDEO_BACKEND=pyav"
-    )
-
-
-def build_pod_command(repo_id: str, lerobot_ref: str, argv: list[str]) -> list[str]:
-    """Build the ``bash -c`` command the pod runs: setup prelude, then annotation.
-
-    ``argv`` is the user's CLI (``sys.argv[1:]``) minus the flags in
-    ``_SUBMITTER_OWNED_ARGS``; ``--repo_id`` is re-added from the config so the pod
-    always annotates the dataset we just made sure is reachable on the Hub.
-    ``--job.target=local`` stops the pod from re-dispatching to itself.
-    """
-    forwarded = _pod_forwarded_args(argv, drop_names=_SUBMITTER_OWNED_ARGS, drop_prefixes=("--job.",))
-    annotate = shlex.join(["lerobot-annotate", f"--repo_id={repo_id}", *forwarded, "--job.target=local"])
-    return ["bash", "-c", f"{build_pod_setup(lerobot_ref)} && {annotate}"]
-
-
-def submit_annotate_to_hf(cfg: AnnotationPipelineConfig) -> None:
-    """Submit an annotation run to HF Jobs infrastructure.
-
-    Resolves credentials, makes sure the source dataset is reachable from the pod,
-    submits the job, then tails its logs until the job reaches a terminal stage —
-    or returns immediately with ``--job.detach``. Ctrl-C detaches without
-    cancelling the remote job.
-    """
-    token = get_token()
-    if not token:
-        raise RuntimeError("Not logged in to Hugging Face. Run `hf auth login` first.")
-
-    if cfg.repo_id is None:
-        raise ValueError(
-            "Remote annotation requires --repo_id: the pod downloads the dataset from the Hub, "
-            "and --root only names a directory on this machine."
-        )
-
-    argv = sys.argv[1:]
-    passed = {tok.split("=", 1)[0] for tok in argv}
-    used_config_files = sorted(passed.intersection(_local_config_file_args(cfg)))
-    if used_config_files:
-        raise ValueError(
-            f"{', '.join(used_config_files)} cannot be used with a remote --job.target: the pod "
-            "cannot read config files from this machine. Pass the settings as CLI flags instead."
-        )
-
-    if not cfg.push_to_hub:
-        # The pod's filesystem is discarded when the job ends, so without a push the
-        # run produces nothing. Warn rather than fail: a smoke test over
-        # --only_episodes that only inspects the logs is a legitimate use.
-        print(
-            "WARNING: --push_to_hub is off. The annotated dataset lives only on the pod and is "
-            "discarded when the job ends. Pass --push_to_hub=true to keep the result."
-        )
-
-    api = HfApi(token=token)
-    tags = resolve_job_tags(cfg.job.tags)
-    ensure_dataset_available(cfg.repo_id, api=api, tags=tags)
-
-    command = build_pod_command(cfg.repo_id, cfg.job.lerobot_ref, argv)
-
-    print(f"Submitting job to HF Jobs (flavor={cfg.job.target}, image={cfg.job.image}) ...")
-    job_info = run_job(
-        image=cfg.job.image,
-        command=command,
-        flavor=cfg.job.target,
-        secrets={"HF_TOKEN": token},
-        timeout=cfg.job.timeout,
-        # HF Jobs labels are key/value; expose each tag as a queryable label.
-        labels=dict.fromkeys(tags, "true"),
-    )
-    job_id = job_info.id
-    job_url = getattr(job_info, "url", None)
-    print(f"Job submitted: {job_id}")
-    if job_url:
-        print(f"  Job page:     {job_url}")
-    target_repo_id = cfg.new_repo_id or cfg.repo_id
-    if cfg.push_to_hub:
-        print(f"  Dataset repo: https://huggingface.co/datasets/{target_repo_id}")
-    print(f"  Monitor:      hf jobs logs {job_id}")
-    print(f"  Cancel:       hf jobs cancel {job_id}")
-
-    # No success marker: `lerobot-annotate` keeps working after the upload log line
-    # (dataset card, version tag), so completion has to be stage-based.
-    if not follow_job(job_id, detach=cfg.job.detach):
-        return
-
-    if cfg.push_to_hub:
-        print(f"\nAnnotation complete — dataset pushed to https://huggingface.co/datasets/{target_repo_id}")
-    else:
-        print("\nAnnotation complete. Note: --push_to_hub was off, so the result stayed on the pod.")

src/lerobot/jobs/hf.py

@@ -223,74 +223,6 @@ def _poll_until_done(
     return None
 
 
-def follow_job(job_id: str, *, detach: bool = False, success_marker: str | None = None) -> bool:
-    """Watch a submitted job to the end, streaming its logs to stdout.
-
-    Returns True when the job finished successfully and False when we stopped watching
-    without a verdict — `detach`, or the user pressing Ctrl-C, which detaches rather than
-    cancelling the remote job. Raises RuntimeError when the job reaches a terminal stage
-    other than COMPLETED.
-
-    `success_marker` finishes as soon as that string appears in the logs instead of waiting
-    out the platform's post-run finalization (~30s). Callers that have a log line meaning
-    "the artifact is on the Hub" should pass it; without one, completion is stage-based.
-    """
-    if detach:
-        return False
-
-    done = threading.Event()
-    detached = threading.Event()
-    marker_seen = threading.Event()
-    stage_holder: dict[str, str | None] = {}
-
-    def _poll() -> None:
-        stage_holder["stage"] = _poll_until_done(job_id, done, status_holder=stage_holder)
-
-    poll_thread = threading.Thread(target=_poll, daemon=True)
-    poll_thread.start()
-    log_thread = threading.Thread(
-        target=_tail_logs, args=(job_id, done, success_marker, marker_seen), daemon=True
-    )
-    log_thread.start()
-
-    def _detach(sig, frame):
-        detached.set()
-        done.set()
-        print("\nDetached. Job is still running.")
-        print(f"  Monitor: hf jobs logs {job_id}")
-        print(f"  Cancel:  hf jobs cancel {job_id}")
-
-    # signal.signal only works on the main thread; when called from a worker thread
-    # (e.g. an orchestration framework) skip the Ctrl-C-detaches-instead-of-cancels
-    # handler rather than crashing with ValueError.
-    install_sigint = threading.current_thread() is threading.main_thread()
-    original_sigint = signal.getsignal(signal.SIGINT) if install_sigint else None
-    if install_sigint:
-        signal.signal(signal.SIGINT, _detach)
-    try:
-        # Timeout-based join so SIGINT is delivered to the main thread promptly.
-        while poll_thread.is_alive():
-            poll_thread.join(timeout=0.5)
-        log_thread.join(timeout=5)
-    finally:
-        if install_sigint:
-            signal.signal(signal.SIGINT, original_sigint)
-
-    if detached.is_set():
-        return False
-    if marker_seen.is_set():
-        return True
-
-    stage = stage_holder.get("stage")
-    if stage != "COMPLETED":
-        message = stage_holder.get("message")
-        detail = f" ({message})" if message else ""
-        raise RuntimeError(
-            f"Job {job_id} ended with stage={stage}{detail}. Check logs: hf jobs logs {job_id}"
-        )
-    return True
-
-
 def _pod_forwarded_args(
     argv: list[str], drop_names: tuple[str, ...] = (), drop_prefixes: tuple[str, ...] = ()
 ) -> list[str]:
@@ -430,11 +362,64 @@ def submit_to_hf(cfg: TrainPipelineConfig) -> None:
     print(f"  Monitor:    hf jobs logs {job_id}")
     print(f"  Cancel:     hf jobs cancel {job_id}")
 
+    if cfg.job.detach:
+        return
+
+    done = threading.Event()
+    detached = threading.Event()
+    pushed_ok = threading.Event()
+    stage_holder: dict[str, str | None] = {}
+
+    def _poll() -> None:
+        stage_holder["stage"] = _poll_until_done(job_id, done, status_holder=stage_holder)
+
+    poll_thread = threading.Thread(target=_poll, daemon=True)
+    poll_thread.start()
     # Finish as soon as the model is pushed, rather than waiting out the platform's
     # post-run finalization before the job stage flips to COMPLETED. This matches the
     # exact log line emitted by PreTrainedPolicy.push_model_to_hub — the two must stay
     # in sync. If it ever stops matching we just fall back to stage-based completion
     # (~30s slower), so the contract is an optimization, not a correctness requirement.
     success_marker = f"Model pushed to https://huggingface.co/{repo_id}"
-    if follow_job(job_id, detach=cfg.job.detach, success_marker=success_marker):
+    log_thread = threading.Thread(
+        target=_tail_logs, args=(job_id, done, success_marker, pushed_ok), daemon=True
+    )
+    log_thread.start()
+
+    def _detach(sig, frame):
+        detached.set()
+        done.set()
+        print("\nDetached. Job is still running.")
+        print(f"  Monitor: hf jobs logs {job_id}")
+        print(f"  Cancel:  hf jobs cancel {job_id}")
+
+    # signal.signal only works on the main thread; when called from a worker thread
+    # (e.g. an orchestration framework) skip the Ctrl-C-detaches-instead-of-cancels
+    # handler rather than crashing with ValueError.
+    install_sigint = threading.current_thread() is threading.main_thread()
+    original_sigint = signal.getsignal(signal.SIGINT) if install_sigint else None
+    if install_sigint:
+        signal.signal(signal.SIGINT, _detach)
+    try:
+        # Timeout-based join so SIGINT is delivered to the main thread promptly.
+        while poll_thread.is_alive():
+            poll_thread.join(timeout=0.5)
+        log_thread.join(timeout=5)
+    finally:
+        if install_sigint:
+            signal.signal(signal.SIGINT, original_sigint)
+
+    if detached.is_set():
+        return
+
+    if pushed_ok.is_set():
         print(f"\nTraining complete — model pushed to https://huggingface.co/{repo_id}")
+        return
+
+    stage = stage_holder.get("stage")
+    if stage != "COMPLETED":
+        message = stage_holder.get("message")
+        detail = f" ({message})" if message else ""
+        raise RuntimeError(
+            f"Job {job_id} ended with stage={stage}{detail}. Check logs: hf jobs logs {job_id}"
+        )

src/lerobot/motors/damiao/damiao.py

@@ -20,6 +20,7 @@ import logging
 import time
 from contextlib import contextmanager
 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
@@ -853,7 +854,7 @@ class DamiaoMotorsBus(MotorsBusBase):
         else:
             raise ValueError(f"Motor {motor_obj} doesn't have a valid recv_id (None).")
 
-    @property
+    @cached_property
     def is_calibrated(self) -> bool:
         """Check if motors are calibrated."""
         return bool(self.calibration)

src/lerobot/motors/dynamixel/tables.py

@@ -122,9 +122,6 @@ MODEL_ENCODING_TABLE = {
     "xm430-w350": X_SERIES_ENCODINGS_TABLE,
     "xm540-w270": X_SERIES_ENCODINGS_TABLE,
     "xc430-w150": X_SERIES_ENCODINGS_TABLE,
-    "xh540-w150": X_SERIES_ENCODINGS_TABLE,
-    "xc330-t288": X_SERIES_ENCODINGS_TABLE,
-    "xc330-t181": X_SERIES_ENCODINGS_TABLE,
 }
 
 # {model: model_resolution}
@@ -137,9 +134,6 @@ MODEL_RESOLUTION = {
     "xm430-w350": 4096,
     "xm540-w270": 4096,
     "xc430-w150": 4096,
-    "xh540-w150": 4096,
-    "xc330-t288": 4096,
-    "xc330-t181": 4096,
 }
 
 # {model: model_number}
@@ -151,9 +145,6 @@ MODEL_NUMBER_TABLE = {
     "xm430-w350": 1020,
     "xm540-w270": 1120,
     "xc430-w150": 1070,
-    "xh540-w150": 1110,
-    "xc330-t288": 1220,
-    "xc330-t181": 1210,
 }
 
 # {model: available_operating_modes}
@@ -165,9 +156,6 @@ MODEL_OPERATING_MODES = {
     "xm430-w350": [0, 1, 3, 4, 5, 16],
     "xm540-w270": [0, 1, 3, 4, 5, 16],
     "xc430-w150": [1, 3, 4, 16],
-    "xh540-w150": [0, 1, 3, 4, 5, 16],
-    "xc330-t288": [0, 1, 3, 4, 5, 16],
-    "xc330-t181": [0, 1, 3, 4, 5, 16],
 }
 
 MODEL_CONTROL_TABLE = {
@@ -178,9 +166,6 @@ MODEL_CONTROL_TABLE = {
     "xm430-w350": X_SERIES_CONTROL_TABLE,
     "xm540-w270": X_SERIES_CONTROL_TABLE,
     "xc430-w150": X_SERIES_CONTROL_TABLE,
-    "xh540-w150": X_SERIES_CONTROL_TABLE,
-    "xc330-t288": X_SERIES_CONTROL_TABLE,
-    "xc330-t181": X_SERIES_CONTROL_TABLE,
 }
 
 MODEL_BAUDRATE_TABLE = {
@@ -191,9 +176,6 @@ MODEL_BAUDRATE_TABLE = {
     "xm430-w350": X_SERIES_BAUDRATE_TABLE,
     "xm540-w270": X_SERIES_BAUDRATE_TABLE,
     "xc430-w150": X_SERIES_BAUDRATE_TABLE,
-    "xh540-w150": X_SERIES_BAUDRATE_TABLE,
-    "xc330-t288": X_SERIES_BAUDRATE_TABLE,
-    "xc330-t181": X_SERIES_BAUDRATE_TABLE,
 }
 
 AVAILABLE_BAUDRATES = [

src/lerobot/motors/motors_bus.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 
 import abc
 import logging
-import time
 from collections.abc import Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -819,13 +818,13 @@ class SerialMotorsBus(MotorsBusBase):
         """
         motor_names = self._get_motors_list(motors)
 
-        start_positions = self.sync_read("Present_Position", motor_names, normalize=False, num_retry=5)
+        start_positions = self.sync_read("Present_Position", motor_names, 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, num_retry=5)
+            positions = self.sync_read("Present_Position", motor_names, 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()}
 
@@ -838,12 +837,9 @@ class SerialMotorsBus(MotorsBusBase):
             if enter_pressed():
                 user_pressed_enter = True
 
-            if not user_pressed_enter:
-                if display_values:
-                    # Move cursor up to overwrite the previous output
-                    move_cursor_up(len(motor_names) + 3)
-                # Throttle reads even when the live table is disabled.
-                time.sleep(0.02)
+            if display_values and not user_pressed_enter:
+                # Move cursor up to overwrite the previous output
+                move_cursor_up(len(motor_names) + 3)
 
         same_min_max = [motor for motor in motor_names if mins[motor] == maxes[motor]]
         if same_min_max:

src/lerobot/policies/diffusion/configuration_diffusion.py

@@ -79,8 +79,6 @@ class DiffusionConfig(PreTrainedConfig):
         use_film_scale_modulation: FiLM (https://huggingface.co/papers/1709.07871) is used for the Unet conditioning.
             Bias modulation is used be default, while this parameter indicates whether to also use scale
             modulation.
-        gradient_checkpointing: Whether to checkpoint the Unet residual blocks during training. This reduces
-            activation memory at the cost of recomputing those blocks during the backward pass.
         noise_scheduler_type: Name of the noise scheduler to use. Supported options: ["DDPM", "DDIM"].
         num_train_timesteps: Number of diffusion steps for the forward diffusion schedule.
         beta_schedule: Name of the diffusion beta schedule as per DDPMScheduler from Hugging Face diffusers.
@@ -134,7 +132,6 @@ class DiffusionConfig(PreTrainedConfig):
     n_groups: int = 8
     diffusion_step_embed_dim: int = 128
     use_film_scale_modulation: bool = True
-    gradient_checkpointing: bool = False
     # Noise scheduler.
     noise_scheduler_type: str = "DDPM"
     num_train_timesteps: int = 100

src/lerobot/policies/diffusion/modeling_diffusion.py

@@ -31,7 +31,6 @@ import torch
 import torch.nn.functional as F  # noqa: N812
 import torchvision
 from torch import Tensor, nn
-from torch.utils.checkpoint import checkpoint
 
 from lerobot.utils.constants import ACTION, OBS_ENV_STATE, OBS_IMAGES, OBS_STATE
 from lerobot.utils.import_utils import _diffusers_available, require_package
@@ -728,35 +727,22 @@ class DiffusionConditionalUnet1d(nn.Module):
         else:
             global_feature = timesteps_embed
 
-        use_gc = self.config.gradient_checkpointing and self.training
-
         # Run encoder, keeping track of skip features to pass to the decoder.
         encoder_skip_features: list[Tensor] = []
         for resnet, resnet2, downsample in self.down_modules:
-            if use_gc:
-                x = checkpoint(resnet, x, global_feature, use_reentrant=False)
-                x = checkpoint(resnet2, x, global_feature, use_reentrant=False)
-            else:
-                x = resnet(x, global_feature)
-                x = resnet2(x, global_feature)
+            x = resnet(x, global_feature)
+            x = resnet2(x, global_feature)
             encoder_skip_features.append(x)
             x = downsample(x)
 
         for mid_module in self.mid_modules:
-            if use_gc:
-                x = checkpoint(mid_module, x, global_feature, use_reentrant=False)
-            else:
-                x = mid_module(x, global_feature)
+            x = mid_module(x, global_feature)
 
         # Run decoder, using the skip features from the encoder.
         for resnet, resnet2, upsample in self.up_modules:
             x = torch.cat((x, encoder_skip_features.pop()), dim=1)
-            if use_gc:
-                x = checkpoint(resnet, x, global_feature, use_reentrant=False)
-                x = checkpoint(resnet2, x, global_feature, use_reentrant=False)
-            else:
-                x = resnet(x, global_feature)
-                x = resnet2(x, global_feature)
+            x = resnet(x, global_feature)
+            x = resnet2(x, global_feature)
             x = upsample(x)
 
         x = self.final_conv(x)

src/lerobot/policies/factory.py

@@ -44,19 +44,12 @@ from lerobot.utils.constants import (
     POLICY_PREPROCESSOR_DEFAULT_NAME,
 )
 from lerobot.utils.feature_utils import dataset_to_policy_features
-from lerobot.utils.import_utils import _peft_available, require_package
 
 from .evo1.configuration_evo1 import Evo1Config
 from .groot.configuration_groot import GrootConfig
 from .pretrained import PreTrainedPolicy
 from .utils import validate_visual_features_consistency
 
-if TYPE_CHECKING or _peft_available:
-    from peft import PeftConfig, PeftModel
-else:
-    PeftConfig = None
-    PeftModel = None
-
 
 def _reconnect_relative_absolute_steps(
     preprocessor: PolicyProcessorPipeline, postprocessor: PolicyProcessorPipeline
@@ -184,7 +177,6 @@ def make_pre_post_processors(
             return make_groot_pre_post_processors_from_pretrained(
                 config=policy_cfg,
                 pretrained_path=pretrained_path,
-                revision=pretrained_revision,
                 dataset_stats=kwargs.get("dataset_stats"),
                 dataset_meta=kwargs.get("dataset_meta"),
                 preprocessor_overrides=kwargs.get("preprocessor_overrides"),
@@ -341,15 +333,12 @@ def make_policy(
         # Load a pretrained PEFT model on top of the policy. The pretrained path points to the folder/repo
         # of the adapter and the adapter's config contains the path to the base policy. So we need the
         # adapter config first, then load the correct policy and then apply PEFT.
-        require_package("peft", extra="peft")
+        from peft import PeftConfig, PeftModel
 
         logging.info("Loading policy's PEFT adapter.")
 
         peft_pretrained_path = str(cfg.pretrained_path)
-        peft_config = PeftConfig.from_pretrained(
-            peft_pretrained_path,
-            revision=cfg.pretrained_revision,
-        )
+        peft_config = PeftConfig.from_pretrained(peft_pretrained_path)
 
         kwargs["pretrained_name_or_path"] = peft_config.base_model_name_or_path
         if not kwargs["pretrained_name_or_path"]:
@@ -360,14 +349,9 @@ def make_policy(
                 "the adapter was trained."
             )
 
-        kwargs["revision"] = peft_config.revision
         policy = policy_cls.from_pretrained(**kwargs)
         policy = PeftModel.from_pretrained(
-            policy,
-            peft_pretrained_path,
-            config=peft_config,
-            revision=cfg.pretrained_revision,
-            is_trainable=True,
+            policy, peft_pretrained_path, config=peft_config, is_trainable=True
         )
 
     else:

src/lerobot/policies/gaussian_actor/configuration_gaussian_actor.py

@@ -37,19 +37,13 @@ def is_image_feature(key: str) -> bool:
 @dataclass
 class ConcurrencyConfig:
     """Configuration for the concurrency of the actor and learner.
-
     Possible values are:
     - "threads": Use threads for the actor and learner.
     - "processes": Use processes for the actor and learner.
-
-    ``multiprocessing_context`` selects the process-wide start method when
-    processes are used. Set it to ``None`` to preserve Python's default or a
-    method already selected by the embedding application.
     """
 
     actor: str = "threads"
     learner: str = "threads"
-    multiprocessing_context: str | None = "spawn"
 
 
 @dataclass

src/lerobot/policies/groot/processor_groot.py

@@ -475,7 +475,6 @@ def make_groot_pre_post_processors_from_pretrained(
     config: GrootConfig,
     pretrained_path: str,
     *,
-    revision: str | None = None,
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     dataset_meta: Any | None = None,
     preprocessor_overrides: dict[str, Any] | None = None,
@@ -512,7 +511,6 @@ def make_groot_pre_post_processors_from_pretrained(
 
     preprocessor, postprocessor = _load_groot_processor_pipelines(
         pretrained_path,
-        revision=revision,
         preprocessor_overrides=preprocessor_overrides,
         postprocessor_overrides=postprocessor_overrides,
         preprocessor_config_filename=preprocessor_config_filename,
@@ -528,7 +526,6 @@ def make_groot_pre_post_processors_from_pretrained(
 def _load_groot_processor_pipelines(
     pretrained_path: str,
     *,
-    revision: str | None,
     preprocessor_overrides: dict[str, Any],
     postprocessor_overrides: dict[str, Any],
     preprocessor_config_filename: str,
@@ -543,7 +540,6 @@ def _load_groot_processor_pipelines(
     preprocessor = PolicyProcessorPipeline.from_pretrained(
         pretrained_model_name_or_path=pretrained_path,
         config_filename=preprocessor_config_filename,
-        revision=revision,
         overrides=preprocessor_overrides,
         to_transition=batch_to_transition,
         to_output=transition_to_batch,
@@ -551,7 +547,6 @@ def _load_groot_processor_pipelines(
     postprocessor = PolicyProcessorPipeline.from_pretrained(
         pretrained_model_name_or_path=pretrained_path,
         config_filename=postprocessor_config_filename,
-        revision=revision,
         overrides=postprocessor_overrides,
         to_transition=policy_action_to_transition,
         to_output=transition_to_policy_action,

src/lerobot/policies/molmoact2/modeling_molmoact2.py

@@ -43,22 +43,11 @@ from torch.distributions import Beta
 
 from lerobot.policies.pretrained import PreTrainedPolicy
 from lerobot.utils.constants import ACTION
-from lerobot.utils.import_utils import (
-    _peft_available,
-    _scipy_available,
-    _transformers_available,
-    require_package,
-)
+from lerobot.utils.import_utils import _scipy_available, _transformers_available, require_package
 
 from ..rtc.modeling_rtc import RTCProcessor
 from .configuration_molmoact2 import MolmoAct2Config
 
-if TYPE_CHECKING or _peft_available:
-    from peft import LoraConfig, get_peft_model
-else:
-    LoraConfig = None
-    get_peft_model = None
-
 logger = logging.getLogger(__name__)
 
 
@@ -1742,11 +1731,13 @@ class MolmoAct2Policy(PreTrainedPolicy):
 
     def _build_inner_lora_config(self):
         require_package("peft", extra="molmoact2")
+        from peft import LoraConfig
 
         return LoraConfig(**self._get_inner_peft_targets())
 
     def _apply_lora_adapters(self) -> None:
         require_package("peft", extra="molmoact2")
+        from peft import get_peft_model
 
         peft_config = self._build_inner_lora_config()
         self._validate_peft_config(peft_config)

src/lerobot/policies/pi05/modeling_pi05.py

@@ -524,6 +524,8 @@ class PI05Pytorch(nn.Module):  # see openpi `PI0Pytorch`
 
     def embed_suffix(self, noisy_actions, timestep):
         """Embed noisy_actions, timestep to prepare for Expert Gemma processing."""
+        embs = []
+        pad_masks = []
         att_masks = []
 
         # Embed timestep using sine-cosine positional encoding
@@ -549,17 +551,23 @@ class PI05Pytorch(nn.Module):  # see openpi `PI0Pytorch`
             return F.silu(x)
 
         time_emb = self._apply_checkpoint(time_mlp_func, time_emb)
+        action_time_emb = action_emb
         adarms_cond = time_emb
 
-        bsize, action_time_dim = action_emb.shape[:2]
-        pad_masks = torch.ones(bsize, action_time_dim, dtype=torch.bool, device=timestep.device)
+        embs.append(action_time_emb)
+        bsize, action_time_dim = action_time_emb.shape[:2]
+        action_time_mask = torch.ones(bsize, action_time_dim, dtype=torch.bool, device=timestep.device)
+        pad_masks.append(action_time_mask)
 
         # Set attention masks so that image, language and state inputs do not attend to action tokens
         att_masks += [1] + ([0] * (self.config.chunk_size - 1))
-        att_masks = torch.tensor(att_masks, dtype=action_emb.dtype, device=action_emb.device)
+
+        embs = torch.cat(embs, dim=1)
+        pad_masks = torch.cat(pad_masks, dim=1)
+        att_masks = torch.tensor(att_masks, dtype=embs.dtype, device=embs.device)
         att_masks = att_masks[None, :].expand(bsize, len(att_masks))
 
-        return action_emb, pad_masks, att_masks, adarms_cond
+        return embs, pad_masks, att_masks, adarms_cond
 
     def forward(self, images, img_masks, tokens, masks, actions, noise, time) -> Tensor:
         """Do a full training forward pass and compute the loss."""

src/lerobot/policies/pretrained.py

@@ -34,22 +34,14 @@ from lerobot.configs import PreTrainedConfig
 from lerobot.configs.train import TrainPipelineConfig
 from lerobot.utils.device_utils import resolve_safetensors_device
 from lerobot.utils.hub import HubMixin
-from lerobot.utils.import_utils import _peft_available, require_package
 
 from .utils import log_model_loading_keys
 
-if TYPE_CHECKING or _peft_available:
-    from peft import PEFT_TYPE_TO_CONFIG_MAPPING, PeftType, get_peft_model
-else:
-    PEFT_TYPE_TO_CONFIG_MAPPING = None
-    PeftType = None
-    get_peft_model = None
+T = TypeVar("T", bound="PreTrainedPolicy")
 
 if TYPE_CHECKING:
     from lerobot.datasets.dataset_metadata import LeRobotDatasetMetadata
 
-T = TypeVar("T", bound="PreTrainedPolicy")
-
 
 def _build_card_context(
     cfg: TrainPipelineConfig | None,
@@ -392,7 +384,7 @@ class PreTrainedPolicy(nn.Module, HubMixin, abc.ABC):
             peft_cli_overrides: Optional dict of CLI overrides (method_type, target_modules, r, etc.)
                 These are merged with policy defaults to build the final config.
         """
-        require_package("peft", extra="peft")
+        from peft import get_peft_model
 
         # If user provided a complete config, use it directly (with overrides)
         if peft_config is not None:
@@ -463,7 +455,7 @@ class PreTrainedPolicy(nn.Module, HubMixin, abc.ABC):
         Returns:
             Preprocessed dict with renamed keys and init_type mapped to method-specific key.
         """
-        require_package("peft", extra="peft")
+        from peft import PeftType
 
         cli_overrides = cli_overrides.copy()
 
@@ -488,7 +480,7 @@ class PreTrainedPolicy(nn.Module, HubMixin, abc.ABC):
 
     def _build_peft_config(self, cli_overrides: dict):
         """Build a PEFT config from policy defaults and CLI overrides."""
-        require_package("peft", extra="peft")
+        from peft import PEFT_TYPE_TO_CONFIG_MAPPING, PeftType
 
         # Determine PEFT method type (default to LORA)
         method_type_str = cli_overrides.get("method_type") or "lora"
@@ -515,7 +507,7 @@ class PreTrainedPolicy(nn.Module, HubMixin, abc.ABC):
 
     def _apply_peft_cli_overrides(self, peft_config, cli_overrides: dict):
         """Apply CLI overrides to an existing PEFT config."""
-        require_package("peft", extra="peft")
+        from peft import PEFT_TYPE_TO_CONFIG_MAPPING, PeftType
 
         # Get method type from existing config or CLI override
         method_type_str = cli_overrides.get("method_type")

src/lerobot/policies/rtc/action_queue.py

@@ -236,11 +236,16 @@ class ActionQueue:
         if action_index_before_inference is not None:
             indexes_diff = max(0, self.last_index - action_index_before_inference)
             if indexes_diff != real_delay:
+                # take the min of both to avoid discarding actions that were not
+                # actually consumed during inference, which would cause a jump in the queue
+                resolved = min(real_delay, indexes_diff)
                 logger.warning(
-                    "Indexes diff is not equal to real delay. indexes_diff=%d, real_delay=%d",
+                    "Indexes diff != real delay (indexes_diff=%d, real_delay=%d); "
+                    "clamping discard to %d to avoid a queue-splice jump.",
                     indexes_diff,
                     real_delay,
+                    resolved,
                 )
-                return real_delay
+                return resolved
 
         return effective_delay

src/lerobot/processor/delta_action_processor.py

@@ -132,20 +132,10 @@ class MapDeltaActionToRobotActionStep(RobotActionProcessorStep):
     def transform_features(
         self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
     ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-        for axis in ["x", "y", "z"]:
+        for axis in ["x", "y", "z", "gripper"]:
             features[PipelineFeatureType.ACTION].pop(f"delta_{axis}", None)
-        features[PipelineFeatureType.ACTION].pop("gripper", None)
 
-        for feat in [
-            "enabled",
-            "target_x",
-            "target_y",
-            "target_z",
-            "target_wx",
-            "target_wy",
-            "target_wz",
-            "gripper_vel",
-        ]:
+        for feat in ["enabled", "target_x", "target_y", "target_z", "target_wx", "target_wy", "target_wz"]:
             features[PipelineFeatureType.ACTION][f"{feat}"] = PolicyFeature(
                 type=FeatureType.ACTION, shape=(1,)
             )

src/lerobot/processor/pipeline.py

@@ -713,8 +713,6 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
             ProcessorMigrationError: If the model requires migration to processor format.
         """
         model_id = str(pretrained_model_name_or_path)
-        model_path = Path(model_id)
-        is_local_source = model_path.is_dir() or model_path.is_file()
         hub_download_kwargs = {
             "force_download": force_download,
             "resume_download": resume_download,
@@ -733,7 +731,7 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
 
         # 3. Build steps with overrides
         steps, validated_overrides = cls._build_steps_with_overrides(
-            loaded_config, overrides or {}, model_id, base_path, hub_download_kwargs, is_local_source
+            loaded_config, overrides or {}, model_id, base_path, hub_download_kwargs
         )
 
         # 4. Validate that all overrides were used
@@ -923,7 +921,6 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
         model_id: str,
         base_path: Path | None,
         hub_download_kwargs: dict[str, Any],
-        is_local_source: bool = False,
     ) -> tuple[list[ProcessorStep], set[str]]:
         """Build all processor steps with overrides and state loading.
 
@@ -947,7 +944,7 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
         3. **State Loading** (via _load_step_state):
            - **If step has "state_file"**: Load tensor state from .safetensors
            - **Local first**: Check base_path/state_file.safetensors
-           - **Hub fallback**: Download state file if the pipeline was loaded from the Hub
+           - **Hub fallback**: Download state file if not found locally
            - **Optional**: Only load if step has load_state_dict method
 
         4. **Override Tracking**:
@@ -965,7 +962,6 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
             model_id: The model identifier (needed for Hub state file downloads)
             base_path: Local directory path for finding state files
             hub_download_kwargs: Parameters for hf_hub_download (tokens, cache, etc.)
-            is_local_source: Whether model_id resolved to a local directory or config file.
 
         Returns:
             Tuple of (instantiated_steps_list, unused_override_keys)
@@ -979,9 +975,7 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
         steps, remaining_override_keys = cls._build_steps_from_config(loaded_config, overrides)
 
         for step_instance, step_entry in zip(steps, loaded_config["steps"], strict=True):
-            cls._load_step_state(
-                step_instance, step_entry, model_id, base_path, hub_download_kwargs, is_local_source
-            )
+            cls._load_step_state(step_instance, step_entry, model_id, base_path, hub_download_kwargs)
 
         return steps, remaining_override_keys
 
@@ -1145,7 +1139,6 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
         model_id: str,
         base_path: Path | None,
         hub_download_kwargs: dict[str, Any],
-        is_local_source: bool = False,
     ) -> None:
         """Load state dictionary for a processor step if available.
 
@@ -1164,7 +1157,7 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
            - **Use case**: Loading from local saved model directory
 
         2. **Hub download fallback**: Download state file from repository
-           - **When triggered**: Local file not found and the pipeline source is a Hub repo
+           - **When triggered**: Local file not found or base_path is None
            - **Process**: Use hf_hub_download with same parameters as config
            - **Example**: Download "normalize_step_0.safetensors" from "user/repo"
            - **Result**: Downloaded to local cache, path returned
@@ -1185,7 +1178,6 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
             model_id: The model identifier (used for Hub downloads if needed)
             base_path: Local directory path for finding state files (None for Hub-only)
             hub_download_kwargs: Parameters for hf_hub_download (tokens, cache, etc.)
-            is_local_source: Whether model_id resolved to a local directory or config file.
 
         Note:
             This method modifies step_instance in-place and returns None.
@@ -1199,12 +1191,6 @@ class DataProcessorPipeline[TInput, TOutput](HubMixin):
         # Try local file first
         if base_path and (base_path / state_filename).exists():
             state_path = str(base_path / state_filename)
-        elif is_local_source:
-            state_path = base_path / state_filename if base_path else Path(state_filename)
-            raise FileNotFoundError(
-                f"State file '{state_filename}' was not found for local processor pipeline "
-                f"'{model_id}' at '{state_path}'."
-            )
         else:
             # Download from Hub
             state_path = hf_hub_download(

src/lerobot/rl/actor.py

@@ -91,7 +91,7 @@ from lerobot.robots import so_follower  # noqa: F401
 from lerobot.teleoperators import gamepad, so_leader  # noqa: F401
 from lerobot.teleoperators.utils import TeleopEvents
 from lerobot.utils.device_utils import get_safe_torch_device
-from lerobot.utils.process import ProcessSignalHandler, ensure_multiprocessing_start_method
+from lerobot.utils.process import ProcessSignalHandler
 from lerobot.utils.random_utils import set_seed
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.transition import (
@@ -124,7 +124,9 @@ def actor_cli(cfg: TrainRLServerPipelineConfig):
     cfg.validate()
     display_pid = False
     if not use_threads(cfg):
-        ensure_multiprocessing_start_method(cfg.policy.concurrency.multiprocessing_context)
+        import torch.multiprocessing as mp
+
+        mp.set_start_method("spawn")
         display_pid = True
 
     # Create logs directory to ensure it exists

src/lerobot/rl/learner.py

@@ -102,7 +102,7 @@ from lerobot.utils.constants import (
 )
 from lerobot.utils.device_utils import get_safe_torch_device
 from lerobot.utils.io_utils import load_json, write_json
-from lerobot.utils.process import ProcessSignalHandler, ensure_multiprocessing_start_method
+from lerobot.utils.process import ProcessSignalHandler
 from lerobot.utils.random_utils import set_seed
 from lerobot.utils.utils import (
     format_big_number,
@@ -123,7 +123,9 @@ def train_cli(cfg: TrainRLServerPipelineConfig):
     # Fail fast with a friendly error if the optional ``hilserl`` extra is missing.
     require_package("grpcio", extra="hilserl", import_name="grpc")
     if not use_threads(cfg):
-        ensure_multiprocessing_start_method(cfg.policy.concurrency.multiprocessing_context)
+        import torch.multiprocessing as mp
+
+        mp.set_start_method("spawn")
 
     # Use the job_name from the config
     train(

src/lerobot/robots/bi_so_follower/bi_so_follower.py

@@ -58,9 +58,6 @@ class BiSOFollower(BimanualMixin, Robot):
             port=config.left_arm_config.port,
             disable_torque_on_disconnect=config.left_arm_config.disable_torque_on_disconnect,
             max_relative_target=config.left_arm_config.max_relative_target,
-            position_p_coefficient=config.left_arm_config.position_p_coefficient,
-            position_i_coefficient=config.left_arm_config.position_i_coefficient,
-            position_d_coefficient=config.left_arm_config.position_d_coefficient,
             use_degrees=config.left_arm_config.use_degrees,
             cameras=left_arm_cameras,
         )
@@ -71,9 +68,6 @@ class BiSOFollower(BimanualMixin, Robot):
             port=config.right_arm_config.port,
             disable_torque_on_disconnect=config.right_arm_config.disable_torque_on_disconnect,
             max_relative_target=config.right_arm_config.max_relative_target,
-            position_p_coefficient=config.right_arm_config.position_p_coefficient,
-            position_i_coefficient=config.right_arm_config.position_i_coefficient,
-            position_d_coefficient=config.right_arm_config.position_d_coefficient,
             use_degrees=config.right_arm_config.use_degrees,
             cameras=config.right_arm_config.cameras,
         )

src/lerobot/robots/lekiwi/lekiwi_client.py

@@ -323,10 +323,6 @@ class LeKiwiClient(Robot):
             np.ndarray: the action sent to the motors, potentially clipped.
         """
 
-        # Action values may be torch tensors (e.g. replayed from a dataset) or numpy
-        # scalars; json.dumps only serializes Python primitives, so coerce each value to a
-        # plain float before sending.
-        action = {key: float(value) for key, value in action.items()}
         self.zmq_cmd_socket.send_string(json.dumps(action))  # action is in motor space
 
         # TODO(Steven): Remove the np conversion when it is possible to record a non-numpy array value

src/lerobot/robots/openarm_follower/openarm_follower.py

@@ -150,6 +150,9 @@ class OpenArmFollower(Robot):
 
         self.configure()
 
+        if self.is_calibrated:
+            self.bus.set_zero_position()
+
         self.bus.enable_torque()
 
         logger.info(f"{self} connected.")

src/lerobot/robots/so_follower/config_so_follower.py

@@ -41,11 +41,6 @@ class SOFollowerConfig:
     # Set to `True` for backward compatibility with previous policies/dataset
     use_degrees: bool = True
 
-    # Position-mode PID gains written to Feetech STS3215 motors at connect time.
-    position_p_coefficient: int = 16
-    position_i_coefficient: int = 0
-    position_d_coefficient: int = 32
-
 
 @RobotConfig.register_subclass("so101_follower")
 @RobotConfig.register_subclass("so100_follower")

src/lerobot/robots/so_follower/so_follower.py

@@ -161,9 +161,11 @@ class SOFollower(Robot):
             self.bus.configure_motors()
             for motor in self.bus.motors:
                 self.bus.write("Operating_Mode", motor, OperatingMode.POSITION.value)
-                self.bus.write("P_Coefficient", motor, self.config.position_p_coefficient)
-                self.bus.write("I_Coefficient", motor, self.config.position_i_coefficient)
-                self.bus.write("D_Coefficient", motor, self.config.position_d_coefficient)
+                # Set P_Coefficient to lower value to avoid shakiness (Default is 32)
+                self.bus.write("P_Coefficient", motor, 16)
+                # Set I_Coefficient and D_Coefficient to default value 0 and 32
+                self.bus.write("I_Coefficient", motor, 0)
+                self.bus.write("D_Coefficient", motor, 32)
 
                 if motor == "gripper":
                     self.bus.write("Max_Torque_Limit", motor, 500)  # 50% of max torque to avoid burnout

src/lerobot/rollout/configs.py

@@ -326,17 +326,8 @@ class RolloutConfig:
 
         policy_path = parser.get_path_arg("policy")
         if policy_path:
-            yaml_overrides = parser.get_yaml_overrides("policy")
-            cli_overrides = parser.get_cli_overrides("policy") or []
-            policy_overrides = yaml_overrides + cli_overrides
-            pretrained_revision = parser.parse_arg("pretrained_revision", cli_overrides)
-            if pretrained_revision is None:
-                pretrained_revision = parser.parse_arg("pretrained_revision", yaml_overrides)
-            self.policy = PreTrainedConfig.from_pretrained(
-                policy_path,
-                revision=pretrained_revision,
-                cli_overrides=policy_overrides,
-            )
+            cli_overrides = parser.get_cli_overrides("policy")
+            self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
             self.policy.pretrained_path = policy_path
         if self.policy is None:
             raise ValueError("--policy.path is required for rollout")

src/lerobot/rollout/context.py

@@ -24,11 +24,10 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass, field
 from threading import Event
-from typing import TYPE_CHECKING
 
 import torch
 
-from lerobot.configs import FeatureType, PreTrainedConfig
+from lerobot.configs import FeatureType
 from lerobot.datasets import (
     LeRobotDataset,
     aggregate_pipeline_dataset_features,
@@ -48,7 +47,6 @@ from lerobot.processor.relative_action_processor import RelativeActionsProcessor
 from lerobot.robots import make_robot_from_config
 from lerobot.teleoperators import Teleoperator, make_teleoperator_from_config
 from lerobot.utils.feature_utils import combine_feature_dicts, hw_to_dataset_features
-from lerobot.utils.import_utils import _peft_available, require_package
 
 from .configs import BaseStrategyConfig, DAggerStrategyConfig, RolloutConfig
 from .inference import (
@@ -59,12 +57,6 @@ from .inference import (
 )
 from .robot_wrapper import ThreadSafeRobot
 
-if TYPE_CHECKING or _peft_available:
-    from peft import PeftConfig, PeftModel
-else:
-    PeftConfig = None
-    PeftModel = None
-
 logger = logging.getLogger(__name__)
 
 
@@ -167,35 +159,6 @@ class RolloutContext:
 # ---------------------------------------------------------------------------
 
 
-def _load_pretrained_policy(policy_config: PreTrainedConfig) -> PreTrainedPolicy:
-    """Load policy weights, keeping adapter and base-model revisions independent."""
-    pretrained_revision = policy_config.pretrained_revision
-    policy_class = get_policy_class(policy_config.type)
-
-    if not policy_config.use_peft:
-        return policy_class.from_pretrained(
-            policy_config.pretrained_path,
-            config=policy_config,
-            revision=pretrained_revision,
-        )
-
-    require_package("peft", extra="peft")
-
-    peft_path = policy_config.pretrained_path
-    peft_config = PeftConfig.from_pretrained(peft_path, revision=pretrained_revision)
-    policy = policy_class.from_pretrained(
-        pretrained_name_or_path=peft_config.base_model_name_or_path,
-        config=policy_config,
-        revision=peft_config.revision,
-    )
-    return PeftModel.from_pretrained(
-        policy,
-        peft_path,
-        config=peft_config,
-        revision=pretrained_revision,
-    )
-
-
 def build_rollout_context(
     cfg: RolloutConfig,
     shutdown_event: Event,
@@ -213,6 +176,7 @@ def build_rollout_context(
     # --- 1. Policy (heavy I/O, but no hardware yet) -------------------
     logger.info("Loading policy from '%s'...", cfg.policy.pretrained_path)
     policy_config = cfg.policy
+    policy_class = get_policy_class(policy_config.type)
 
     if hasattr(policy_config, "compile_model"):
         policy_config.compile_model = cfg.use_torch_compile
@@ -223,7 +187,17 @@ def build_rollout_context(
             "Please use `cpu` or `cuda` backend."
         )
 
-    policy = _load_pretrained_policy(policy_config)
+    if policy_config.use_peft:
+        from peft import PeftConfig, PeftModel
+
+        peft_path = policy_config.pretrained_path
+        peft_config = PeftConfig.from_pretrained(peft_path)
+        policy = policy_class.from_pretrained(
+            pretrained_name_or_path=peft_config.base_model_name_or_path, config=policy_config
+        )
+        policy = PeftModel.from_pretrained(policy, peft_path, config=peft_config)
+    else:
+        policy = policy_class.from_pretrained(policy_config.pretrained_path, config=policy_config)
 
     if is_rtc:
         policy.config.rtc_config = cfg.inference.rtc
@@ -302,22 +276,12 @@ def build_rollout_context(
     # ``observation_features`` values are either a tuple (camera shape) or the
     # ``float`` type itself used as a sentinel for scalar motor features —
     # see ``dict[str, type | tuple]`` annotation on ``Robot.observation_features``.
-    # Keep cameras (tuple) plus both joint-position (.pos) and base-velocity (.vel)
-    # scalar state features. LeKiwi's observation.state is 9-dim (6 arm .pos +
-    # x/y/theta.vel) and the policy was trained/normalized on all 9; the old .pos-only
-    # filter fed a 6-dim state into a 9-dim normalizer → RuntimeError (size 6 vs 9).
-    # Pure-arm robots have no .vel state keys, so this is a no-op for them.
     observation_features_hw = {
         k: v
         for k, v in all_obs_features.items()
-        if isinstance(v, tuple) or (v is float and k.endswith((".pos", ".vel")))
+        if isinstance(v, tuple) or (v is float and k.endswith(".pos"))
     }
-    # Keep both joint-position (.pos) and base-velocity (.vel) action features so
-    # mobile manipulators command the base too (e.g. LeKiwi: 6 arm .pos +
-    # x/y/theta.vel = 9-dim action). Pure-arm robots have no .vel keys, so this is
-    # a no-op for them. Without the .vel keys the base velocities are silently
-    # dropped from dataset_features[ACTION]/ordered_action_keys and the base never moves.
-    action_features_hw = {k: v for k, v in robot.action_features.items() if k.endswith((".pos", ".vel"))}
+    action_features_hw = {k: v for k, v in robot.action_features.items() if k.endswith(".pos")}
 
     # The action side is always needed: sync inference reads action names from
     # ``dataset_features[ACTION]`` to map policy tensors back to robot actions.
@@ -428,7 +392,6 @@ def build_rollout_context(
     preprocessor, postprocessor = make_pre_post_processors(
         policy_cfg=policy_config,
         pretrained_path=cfg.policy.pretrained_path,
-        pretrained_revision=policy_config.pretrained_revision,
         dataset_stats=dataset_stats,
         preprocessor_overrides={
             "device_processor": {"device": cfg.device},

src/lerobot/rollout/inference/factory.py

@@ -116,7 +116,8 @@ def create_inference_engine(
             postprocessor=postprocessor,
             robot_wrapper=robot_wrapper,
             rtc_config=config.rtc,
-            hw_features=hw_features,
+            dataset_features=dataset_features,
+            ordered_action_keys=ordered_action_keys,
             task=task,
             fps=fps,
             device=device,

src/lerobot/rollout/inference/rtc.py

@@ -34,7 +34,7 @@ import torch
 from lerobot.policies.pretrained import PreTrainedPolicy
 from lerobot.policies.rtc import ActionQueue, LatencyTracker, reanchor_relative_rtc_prefix
 from lerobot.policies.rtc.configuration_rtc import RTCConfig
-from lerobot.policies.utils import prepare_observation_for_inference
+from lerobot.policies.utils import make_robot_action, prepare_observation_for_inference
 from lerobot.processor import (
     NormalizerProcessorStep,
     PolicyProcessorPipeline,
@@ -66,14 +66,16 @@ def _normalize_prev_actions_length(prev_actions: torch.Tensor, target_steps: int
     """Pad or truncate RTC prefix actions to a fixed length for stable compiled inference."""
     if prev_actions.ndim != 2:
         raise ValueError(f"Expected 2D [T, A] tensor, got shape={tuple(prev_actions.shape)}")
-    steps, action_dim = prev_actions.shape
+    steps, _ = prev_actions.shape
     if steps == target_steps:
         return prev_actions
     if steps > target_steps:
         return prev_actions[:target_steps]
-    padded = torch.zeros((target_steps, action_dim), dtype=prev_actions.dtype, device=prev_actions.device)
-    padded[:steps] = prev_actions
-    return padded
+    if steps == 0:
+        raise ValueError("Cannot pad an empty prefix: no last action to hold.")
+    # repeat the last action to fill the remaining steps to avoid a sudden jump
+    hold = prev_actions[-1:].expand(target_steps - steps, -1)
+    return torch.cat([prev_actions, hold], dim=0)
 
 
 # ---------------------------------------------------------------------------
@@ -97,7 +99,8 @@ class RTCInferenceEngine(InferenceEngine):
         postprocessor: PolicyProcessorPipeline,
         robot_wrapper: ThreadSafeRobot,
         rtc_config: RTCConfig,
-        hw_features: dict,
+        dataset_features: dict,
+        ordered_action_keys: list[str],
         task: str,
         fps: float,
         device: str | None,
@@ -111,7 +114,8 @@ class RTCInferenceEngine(InferenceEngine):
         self._postprocessor = postprocessor
         self._robot = robot_wrapper
         self._rtc_config = rtc_config
-        self._hw_features = hw_features
+        self._obs_features = dataset_features
+        self._ordered_action_keys = ordered_action_keys
         self._task = task
         self._fps = fps
         self._device = device or "cpu"
@@ -233,7 +237,13 @@ class RTCInferenceEngine(InferenceEngine):
         """Pop the next action from the RTC queue (ignores ``obs_frame``)."""
         if self._action_queue is None:
             return None
-        return self._action_queue.get()
+        action = self._action_queue.get()
+        if action is None:
+            return None
+
+        # properly reorder the action dict to match the robot's expected order
+        action_dict = make_robot_action(action, self._obs_features)
+        return torch.tensor([action_dict[k] for k in self._ordered_action_keys])
 
     def notify_observation(self, obs: dict) -> None:
         """Publish the latest observation for the RTC thread to consume."""
@@ -252,6 +262,8 @@ class RTCInferenceEngine(InferenceEngine):
             policy_device = torch.device(self._device)
 
             warmup_required = max(1, self._compile_warmup_inferences) if self._use_torch_compile else 0
+            # exclude the first N inferences from the latency tracker to avoid cold-start spikes
+            latency_warmup_required = max(1, warmup_required)
             inference_count = 0
             consecutive_errors = 0
 
@@ -276,7 +288,7 @@ class RTCInferenceEngine(InferenceEngine):
                         latency = latency_tracker.max()
                         delay = math.ceil(latency / time_per_chunk) if latency else 0
 
-                        obs_batch = build_dataset_frame(self._hw_features, obs, prefix="observation")
+                        obs_batch = build_dataset_frame(self._obs_features, obs, prefix="observation")
                         obs_batch = prepare_observation_for_inference(
                             obs_batch, policy_device, self._task, self._robot.robot_type
                         )
@@ -316,7 +328,8 @@ class RTCInferenceEngine(InferenceEngine):
                         inference_count += 1
                         consecutive_errors = 0
                         is_warmup = self._use_torch_compile and inference_count <= warmup_required
-                        if is_warmup:
+                        # Ignore the first N inferences for latency tracking to avoid cold-start spikes
+                        if inference_count <= latency_warmup_required:
                             latency_tracker.reset()
                         else:
                             latency_tracker.add(new_latency)

src/lerobot/scripts/convert_dataset_v21_to_v30.py

@@ -61,7 +61,6 @@ import pyarrow as pa
 import tqdm
 from datasets import Dataset, Features, Image
 from huggingface_hub import HfApi, snapshot_download
-from huggingface_hub.errors import RevisionNotFoundError
 from requests import HTTPError
 
 from lerobot.datasets import CODEBASE_VERSION, LeRobotDataset, aggregate_stats
@@ -94,8 +93,6 @@ from lerobot.datasets.video_utils import concatenate_video_files, get_video_dura
 from lerobot.utils.constants import HF_LEROBOT_HOME
 from lerobot.utils.utils import flatten_dict, init_logging
 
-logger = logging.getLogger(__name__)
-
 V21 = "v2.1"
 V30 = "v3.0"
 
@@ -478,11 +475,11 @@ def convert_dataset(
     # First check if the dataset already has a v3.0 version
     if root is None and not force_conversion:
         try:
-            logger.info("Trying to download v3.0 version of the dataset from the hub...")
+            print("Trying to download v3.0 version of the dataset from the hub...")
             snapshot_download(repo_id, repo_type="dataset", revision=V30, local_dir=HF_LEROBOT_HOME / repo_id)
             return
         except Exception:
-            logger.info("Dataset does not have an uploaded v3.0 version. Continuing with conversion.")
+            print("Dataset does not have an uploaded v3.0 version. Continuing with conversion.")
 
     # Set root based on whether local dataset path is provided
     use_local_dataset = False
@@ -490,7 +487,7 @@ def convert_dataset(
     if root.exists():
         validate_local_dataset_version(root)
         use_local_dataset = True
-        logger.info(f"Using local dataset at {root}")
+        print(f"Using local dataset at {root}")
 
     old_root = root.parent / f"{root.name}_old"
     new_root = root.parent / f"{root.name}_v30"
@@ -524,8 +521,8 @@ def convert_dataset(
         hub_api = HfApi()
         try:
             hub_api.delete_tag(repo_id, tag=CODEBASE_VERSION, repo_type="dataset")
-        except (HTTPError, RevisionNotFoundError) as e:
-            logger.warning(f"tag={CODEBASE_VERSION} probably doesn't exist. Skipping exception ({e})")
+        except HTTPError as e:
+            print(f"tag={CODEBASE_VERSION} probably doesn't exist. Skipping exception ({e})")
             pass
         hub_api.delete_files(
             delete_patterns=["data/chunk*/episode_*", "meta/*.jsonl", "videos/chunk*"],

src/lerobot/scripts/lerobot_annotate.py

@@ -24,14 +24,7 @@ Example:
       --root=/path/to/dataset \\
       --vlm.model_id=Qwen/Qwen2.5-VL-7B-Instruct
 
-Pass ``--job.target=<flavor>`` to run the same command on a Hugging Face
-Jobs GPU instead of this machine (see ``lerobot.jobs.annotate``):
-
-  uv run lerobot-annotate \\
-      --repo_id=user/dataset \\
-      --new_repo_id=user/dataset_annotated \\
-      --push_to_hub=true \\
-      --job.target=h200
+For distributed runs, see ``examples/annotations/run_hf_job.py``.
 """
 
 import logging
@@ -76,14 +69,6 @@ def _resolve_root(cfg: AnnotationPipelineConfig) -> Path:
 def annotate(cfg: AnnotationPipelineConfig) -> None:
     """Run the steerable annotation pipeline against a dataset."""
     logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-
-    if cfg.job.is_remote:
-        # Imported lazily: the submitter pulls in LeRobotDataset (the `dataset`
-        # extra), which a local annotation run over --root doesn't need.
-        from lerobot.jobs.annotate import submit_annotate_to_hf
-
-        return submit_annotate_to_hf(cfg)
-
     root = _resolve_root(cfg)
     logger.info("annotate: root=%s", root)
 
@@ -154,14 +139,14 @@ def _push_to_hub(root: Path, cfg: AnnotationPipelineConfig) -> None:
     repo_id = cfg.new_repo_id or cfg.repo_id
     commit_message = cfg.push_commit_message or "Add steerable annotations (lerobot-annotate)"
     api = HfApi()
-    logger.info(f"[lerobot-annotate] creating/locating dataset repo {repo_id}...")
+    print(f"[lerobot-annotate] creating/locating dataset repo {repo_id}...", flush=True)
     api.create_repo(
         repo_id=repo_id,
         repo_type="dataset",
         private=cfg.push_private,
         exist_ok=True,
     )
-    logger.info(f"[lerobot-annotate] uploading {root} -> {repo_id}...")
+    print(f"[lerobot-annotate] uploading {root} -> {repo_id}...", flush=True)
     commit_info = api.upload_folder(
         folder_path=str(root),
         repo_id=repo_id,
@@ -172,7 +157,7 @@ def _push_to_hub(root: Path, cfg: AnnotationPipelineConfig) -> None:
         # at the source dataset; a fresh card is generated below instead.
         ignore_patterns=[".annotate_staging/**", "**/.DS_Store", "README.md"],
     )
-    logger.info(f"[lerobot-annotate] uploaded to https://huggingface.co/datasets/{repo_id}")
+    print(f"[lerobot-annotate] uploaded to https://huggingface.co/datasets/{repo_id}", flush=True)
 
     dataset_info = load_info(root)
     card = create_lerobot_dataset_card(dataset_info=dataset_info, license="apache-2.0", repo_id=repo_id)
@@ -200,13 +185,14 @@ def _push_to_hub(root: Path, cfg: AnnotationPipelineConfig) -> None:
         with suppress(RevisionNotFoundError):
             api.delete_tag(repo_id, tag=version_tag, repo_type="dataset")
         api.create_tag(**tag_kwargs)
-        logger.info(f"[lerobot-annotate] tagged {repo_id} as {version_tag}")
+        print(f"[lerobot-annotate] tagged {repo_id} as {version_tag}", flush=True)
     except Exception as exc:  # noqa: BLE001
-        logger.warning(
+        print(
             f"[lerobot-annotate] WARNING: could not create tag {version_tag!r} on {repo_id}: {exc}. "
             "Dataset is uploaded but ``LeRobotDataset`` won't be able to load it until it's tagged. "
             "Run: from huggingface_hub import HfApi; "
-            f"HfApi().create_tag({repo_id!r}, tag={version_tag!r}, repo_type='dataset', exist_ok=True)"
+            f"HfApi().create_tag({repo_id!r}, tag={version_tag!r}, repo_type='dataset', exist_ok=True)",
+            flush=True,
         )
 
 

src/lerobot/scripts/lerobot_dataset_viz.py

@@ -89,8 +89,6 @@ from lerobot.datasets import LeRobotDataset
 from lerobot.utils.constants import ACTION, DONE, OBS_STATE, REWARD, SUCCESS
 from lerobot.utils.utils import init_logging
 
-logger = logging.getLogger(__name__)
-
 DEFAULT_FOXGLOVE_PORT = 8765
 DEFAULT_RERUN_PORT = 9090
 
@@ -301,7 +299,7 @@ def visualize_dataset(
             while True:
                 time.sleep(1)
         except KeyboardInterrupt:
-            logger.info("Ctrl-C received. Exiting.")
+            print("Ctrl-C received. Exiting.")
 
 
 def main():

src/lerobot/scripts/lerobot_eval.py

@@ -62,7 +62,7 @@ from dataclasses import asdict
 from functools import partial
 from pathlib import Path
 from pprint import pformat
-from typing import TYPE_CHECKING, Any, TypedDict
+from typing import Any, TypedDict
 
 import einops
 import gymnasium as gym
@@ -87,7 +87,7 @@ from lerobot.processor import PolicyProcessorPipeline
 from lerobot.types import PolicyAction
 from lerobot.utils.constants import ACTION, DONE, OBS_IMAGE, OBS_IMAGES, OBS_STR, REWARD
 from lerobot.utils.device_utils import get_safe_torch_device
-from lerobot.utils.import_utils import _peft_available, register_third_party_plugins, require_package
+from lerobot.utils.import_utils import register_third_party_plugins
 from lerobot.utils.io_utils import write_video
 from lerobot.utils.random_utils import set_seed
 from lerobot.utils.utils import (
@@ -95,14 +95,6 @@ from lerobot.utils.utils import (
     inside_slurm,
 )
 
-if TYPE_CHECKING or _peft_available:
-    from peft import PeftModel
-else:
-    PeftModel = None
-
-
-logger = logging.getLogger(__name__)
-
 
 def _env_features_to_dataset_features(env_features: dict) -> dict:
     """Convert EnvConfig.features to the dict format expected by LeRobotDataset.create()."""
@@ -452,16 +444,15 @@ def eval_policy(
         exc = ValueError(
             f"Policy of type 'PreTrainedPolicy' is expected, but type '{type(policy)}' was provided."
         )
-        if not _peft_available:
-            raise exc
-        require_package("peft", extra="peft")
-        if not isinstance(policy, PeftModel):
-            raise exc
+        try:
+            from peft import PeftModel
+
+            if not isinstance(policy, PeftModel):
+                raise exc
+        except ImportError:
+            raise exc from None
 
     start = time.time()
-    # Preserve the mode for direct callers. eval_policy_all scopes the mode
-    # around all tasks so parallel evaluations cannot race with each other.
-    was_training = policy.training
     policy.eval()
 
     # Determine how many batched rollouts we need to get n_episodes. Note that if n_episodes is not evenly
@@ -683,8 +674,6 @@ def eval_policy(
     if save_predicted_video:
         info["predicted_video_paths"] = predicted_video_paths
 
-    policy.train(was_training)
-
     return info
 
 
@@ -802,13 +791,13 @@ def eval_main(cfg: EvalPipelineConfig):
             recording_repo_id=cfg.eval.recording_repo_id,
             recording_private=cfg.eval.recording_private,
         )
-        logger.info("Overall Aggregated Metrics:")
-        logger.info(info["overall"])
+        print("Overall Aggregated Metrics:")
+        print(info["overall"])
 
         # Print per-suite stats
         for task_group, task_group_info in info.items():
-            logger.info(f"\nAggregated Metrics for {task_group}:")
-            logger.info(task_group_info)
+            print(f"\nAggregated Metrics for {task_group}:")
+            print(task_group_info)
     # Close all vec envs
     close_envs(envs)
 
@@ -1021,48 +1010,40 @@ def eval_policy_all(
         recording_private=recording_private,
     )
 
-    # Set the shared policy's mode before launching any workers. Restoring it
-    # inside individual tasks would let one task enable training mode while
-    # another task is still evaluating.
-    was_training = policy.training
-    policy.eval()
-    try:
-        if max_parallel_tasks <= 1:
-            prefetch_thread: threading.Thread | None = None
-            for i, (task_group, task_id, env) in enumerate(tasks):
-                if prefetch_thread is not None:
-                    prefetch_thread.join()
-                    prefetch_thread = None
+    if max_parallel_tasks <= 1:
+        prefetch_thread: threading.Thread | None = None
+        for i, (task_group, task_id, env) in enumerate(tasks):
+            if prefetch_thread is not None:
+                prefetch_thread.join()
+                prefetch_thread = None
 
+            try:
+                tg, tid, metrics = task_runner(task_group, task_id, env)
+                _accumulate_to(tg, metrics)
+                per_task_infos.append({"task_group": tg, "task_id": tid, "metrics": metrics})
+            finally:
+                env.close()
+                # Prefetch next task's workers *after* closing current env to prevent
+                # GPU memory overlap between consecutive tasks.
+                if i + 1 < len(tasks):
+                    next_env = tasks[i + 1][2]
+                    if hasattr(next_env, "_ensure"):
+                        prefetch_thread = threading.Thread(target=next_env._ensure, daemon=True)
+                        prefetch_thread.start()
+    else:
+        with cf.ThreadPoolExecutor(max_workers=max_parallel_tasks) as executor:
+            fut2meta = {}
+            for task_group, task_id, env in tasks:
+                fut = executor.submit(task_runner, task_group, task_id, env)
+                fut2meta[fut] = (task_group, task_id, env)
+            for fut in cf.as_completed(fut2meta):
+                tg, tid, env = fut2meta[fut]
                 try:
-                    tg, tid, metrics = task_runner(task_group, task_id, env)
+                    tg, tid, metrics = fut.result()
                     _accumulate_to(tg, metrics)
                     per_task_infos.append({"task_group": tg, "task_id": tid, "metrics": metrics})
                 finally:
                     env.close()
-                    # Prefetch next task's workers *after* closing current env to prevent
-                    # GPU memory overlap between consecutive tasks.
-                    if i + 1 < len(tasks):
-                        next_env = tasks[i + 1][2]
-                        if hasattr(next_env, "_ensure"):
-                            prefetch_thread = threading.Thread(target=next_env._ensure, daemon=True)
-                            prefetch_thread.start()
-        else:
-            with cf.ThreadPoolExecutor(max_workers=max_parallel_tasks) as executor:
-                fut2meta = {}
-                for task_group, task_id, env in tasks:
-                    fut = executor.submit(task_runner, task_group, task_id, env)
-                    fut2meta[fut] = (task_group, task_id, env)
-                for fut in cf.as_completed(fut2meta):
-                    tg, tid, env = fut2meta[fut]
-                    try:
-                        tg, tid, metrics = fut.result()
-                        _accumulate_to(tg, metrics)
-                        per_task_infos.append({"task_group": tg, "task_id": tid, "metrics": metrics})
-                    finally:
-                        env.close()
-    finally:
-        policy.train(was_training)
 
     # compute aggregated metrics helper (robust to lists/scalars)
     def _agg_from_list(xs):

src/lerobot/scripts/lerobot_find_cameras.py

@@ -40,7 +40,6 @@ from PIL import Image
 from lerobot.cameras import ColorMode
 from lerobot.cameras.opencv import OpenCVCamera, OpenCVCameraConfig
 from lerobot.cameras.realsense import RealSenseCamera, RealSenseCameraConfig
-from lerobot.utils.utils import init_logging
 
 logger = logging.getLogger(__name__)
 
@@ -286,8 +285,6 @@ def save_images_from_all_cameras(
 
 
 def main():
-    init_logging()
-
     parser = argparse.ArgumentParser(
         description="Unified camera utility script for listing cameras and capturing images."
     )

src/lerobot/scripts/lerobot_record.py

@@ -453,11 +453,9 @@ def record(
                 encoder_queue_maxsize=cfg.dataset.encoder_queue_maxsize,
             )
 
-        # Connect the teleoperator before the robot so the robot isn't left idle (and possibly
-        # tripping a firmware watchdog) during teleop init. Matches lerobot_teleoperate.py.
+        robot.connect()
         if teleop is not None:
             teleop.connect()
-        robot.connect()
 
         listener, events = init_keyboard_listener()
 

src/lerobot/scripts/lerobot_replay.py

@@ -61,7 +61,6 @@ from lerobot.robots import (  # noqa: F401
     earthrover_mini_plus,
     hope_jr,
     koch_follower,
-    lekiwi,
     make_robot_from_config,
     omx_follower,
     openarm_follower,

src/lerobot/scripts/lerobot_rollout.py

@@ -165,7 +165,6 @@ from lerobot.robots import (  # noqa: F401
     earthrover_mini_plus,
     hope_jr,
     koch_follower,
-    lekiwi,
     omx_follower,
     openarm_follower,
     reachy2,

src/lerobot/scripts/lerobot_setup_motors.py

@@ -51,7 +51,19 @@ from lerobot.teleoperators import (  # noqa: F401
     rebot_102_leader,
     so_leader,
 )
-from lerobot.utils.import_utils import register_third_party_plugins
+
+COMPATIBLE_DEVICES = [
+    "koch_follower",
+    "koch_leader",
+    "omx_follower",
+    "omx_leader",
+    "openarm_mini",
+    "so100_follower",
+    "so100_leader",
+    "so101_follower",
+    "so101_leader",
+    "lekiwi",
+]
 
 
 @dataclass
@@ -68,19 +80,18 @@ class SetupConfig:
 
 @draccus.wrap()
 def setup_motors(cfg: SetupConfig):
+    if cfg.device.type not in COMPATIBLE_DEVICES:
+        raise NotImplementedError
+
     if isinstance(cfg.device, RobotConfig):
         device = make_robot_from_config(cfg.device)
     else:
         device = make_teleoperator_from_config(cfg.device)
 
-    setup = getattr(device, "setup_motors", None)
-    if not callable(setup):
-        raise NotImplementedError(f"Device type '{cfg.device.type}' does not support motor setup.")
-    setup()
+    device.setup_motors()
 
 
 def main():
-    register_third_party_plugins()
     setup_motors()
 
 

src/lerobot/scripts/lerobot_train.py

@@ -57,7 +57,7 @@ from lerobot.optim.factory import make_optimizer_and_scheduler
 from lerobot.policies import PreTrainedPolicy, make_policy, make_pre_post_processors
 from lerobot.rewards import make_reward_pre_post_processors
 from lerobot.utils.collate import lerobot_collate_fn
-from lerobot.utils.import_utils import _peft_available, register_third_party_plugins, require_package
+from lerobot.utils.import_utils import register_third_party_plugins
 from lerobot.utils.logging_utils import AverageMeter, MetricsTracker
 from lerobot.utils.random_utils import set_seed
 from lerobot.utils.utils import (
@@ -68,24 +68,9 @@ from lerobot.utils.utils import (
     inside_slurm,
 )
 
-if TYPE_CHECKING or _peft_available:
-    from peft import PeftModel
-else:
-    PeftModel = None
-
 from .lerobot_eval import eval_policy_all
 
 
-def _dataloader_worker_kwargs(cfg: TrainPipelineConfig) -> dict[str, Any]:
-    """Return worker-only DataLoader options, disabling them for single-process loading."""
-    workers_enabled = cfg.num_workers > 0
-    return {
-        "prefetch_factor": cfg.prefetch_factor if workers_enabled else None,
-        "persistent_workers": cfg.persistent_workers and workers_enabled,
-        "multiprocessing_context": cfg.dataloader_multiprocessing_context if workers_enabled else None,
-    }
-
-
 def update_policy(
     train_metrics: MetricsTracker,
     policy: PreTrainedPolicy,
@@ -212,6 +197,8 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
     if cfg.job.is_remote:
         return submit_to_hf(cfg)
 
+    from lerobot.utils.import_utils import require_package
+
     require_package("accelerate", extra="training")
     from accelerate import Accelerator
     from accelerate.utils import DistributedDataParallelKwargs, DistributedType
@@ -315,7 +302,7 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
     if cfg.peft is not None:
         if cfg.is_reward_model_training:
             raise ValueError("PEFT is only supported for policy training. ")
-        require_package("peft", extra="peft")
+        from peft import PeftModel
 
         if isinstance(policy, PeftModel):
             logging.info("PEFT adapter already loaded from checkpoint, skipping wrap_with_peft.")
@@ -486,7 +473,8 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
         pin_memory=device.type == "cuda",
         drop_last=False,
         collate_fn=collate_fn,
-        **_dataloader_worker_kwargs(cfg),
+        prefetch_factor=cfg.prefetch_factor if cfg.num_workers > 0 else None,
+        persistent_workers=cfg.persistent_workers and cfg.num_workers > 0,
     )
 
     # Build eval dataloader if a held-out split exists
@@ -512,7 +500,8 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
             pin_memory=device.type == "cuda",
             drop_last=False,
             collate_fn=eval_collate_fn,
-            **_dataloader_worker_kwargs(cfg),
+            prefetch_factor=cfg.prefetch_factor if cfg.num_workers > 0 else None,
+            persistent_workers=cfg.persistent_workers and cfg.num_workers > 0,
         )
 
     # Prepare everything with accelerator

src/lerobot/scripts/lerobot_train_tokenizer.py

@@ -45,7 +45,6 @@ lerobot-train-tokenizer \
 """
 
 import json
-import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -64,9 +63,6 @@ else:
 from lerobot.configs import NormalizationMode, parser
 from lerobot.datasets import LeRobotDataset
 from lerobot.utils.constants import ACTION, OBS_STATE
-from lerobot.utils.utils import init_logging
-
-logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -278,8 +274,11 @@ def process_episode(args):
 
         return action_chunks
 
-    except Exception:
-        logger.exception("Error processing episode %s", ep_idx)
+    except Exception as e:
+        print(f"Error processing episode {ep_idx}: {e}")
+        import traceback
+
+        traceback.print_exc()
         return None
 
 
@@ -301,10 +300,10 @@ def train_fast_tokenizer(
     Returns:
         Trained FAST tokenizer
     """
-    logger.info(f"Training FAST tokenizer on {len(action_chunks)} action chunks...")
-    logger.info(f"Action chunk shape: {action_chunks.shape}")
-    logger.info(f"Vocab size: {vocab_size}")
-    logger.info(f"DCT scale: {scale}")
+    print(f"Training FAST tokenizer on {len(action_chunks)} action chunks...")
+    print(f"Action chunk shape: {action_chunks.shape}")
+    print(f"Vocab size: {vocab_size}")
+    print(f"DCT scale: {scale}")
 
     # download the tokenizer source code (not pretrained weights)
     # we'll train a new tokenizer on our own data
@@ -315,7 +314,7 @@ def train_fast_tokenizer(
 
     # train the new tokenizer on our action data using .fit()
     # this trains the BPE tokenizer on DCT coefficients
-    logger.info("Training new tokenizer (this may take a few minutes)...")
+    print("Training new tokenizer (this may take a few minutes)...")
     tokenizer = base_tokenizer.fit(
         action_data_list,
         scale=scale,
@@ -323,21 +322,21 @@ def train_fast_tokenizer(
         time_horizon=action_chunks.shape[1],  # action_horizon
         action_dim=action_chunks.shape[2],  # encoded dimensions
     )
-    logger.info("✓ Tokenizer training complete!")
+    print("✓ Tokenizer training complete!")
 
     # validate it works
     sample_chunk = action_chunks[0]
     encoded = tokenizer(sample_chunk[None])[0]
     if isinstance(encoded, list):
         encoded = np.array(encoded)
-    logger.info(f"Sample encoding: {len(encoded)} tokens for chunk shape {sample_chunk.shape}")
+    print(f"Sample encoding: {len(encoded)} tokens for chunk shape {sample_chunk.shape}")
 
     return tokenizer
 
 
 def compute_compression_stats(tokenizer, action_chunks: np.ndarray):
     """Compute compression statistics."""
-    logger.info("\nComputing compression statistics...")
+    print("\nComputing compression statistics...")
 
     # sample for stats (use max 1000 chunks for speed)
     sample_size = min(1000, len(action_chunks))
@@ -367,12 +366,12 @@ def compute_compression_stats(tokenizer, action_chunks: np.ndarray):
         "max_token_length": float(np.max(token_lengths)),
     }
 
-    logger.info("Compression Statistics:")
-    logger.info(f"  Average compression ratio: {stats['compression_ratio']:.2f}x")
-    logger.info(f"  Mean token length: {stats['mean_token_length']:.1f}")
-    logger.info(f"  P99 token length: {stats['p99_token_length']:.0f}")
-    logger.info(f"  Min token length: {stats['min_token_length']:.0f}")
-    logger.info(f"  Max token length: {stats['max_token_length']:.0f}")
+    print("Compression Statistics:")
+    print(f"  Average compression ratio: {stats['compression_ratio']:.2f}x")
+    print(f"  Mean token length: {stats['mean_token_length']:.1f}")
+    print(f"  P99 token length: {stats['p99_token_length']:.0f}")
+    print(f"  Min token length: {stats['min_token_length']:.0f}")
+    print(f"  Max token length: {stats['max_token_length']:.0f}")
 
     return stats
 
@@ -386,9 +385,9 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
         cfg: TokenizerTrainingConfig dataclass with all configuration parameters
     """
     # load dataset
-    logger.info(f"Loading dataset: {cfg.repo_id}")
+    print(f"Loading dataset: {cfg.repo_id}")
     dataset = LeRobotDataset(repo_id=cfg.repo_id, root=cfg.root)
-    logger.info(f"Dataset loaded: {dataset.num_episodes} episodes, {dataset.num_frames} frames")
+    print(f"Dataset loaded: {dataset.num_episodes} episodes, {dataset.num_frames} frames")
 
     # parse normalization mode
     try:
@@ -398,7 +397,7 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
             f"Invalid normalization_mode: {cfg.normalization_mode}. "
             f"Must be one of: {', '.join([m.value for m in NormalizationMode])}"
         ) from err
-    logger.info(f"Normalization mode: {norm_mode.value}")
+    print(f"Normalization mode: {norm_mode.value}")
 
     # parse encoded dimensions
     encoded_dim_ranges = []
@@ -407,38 +406,38 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
         encoded_dim_ranges.append((start, end))
 
     total_encoded_dims = sum(end - start for start, end in encoded_dim_ranges)
-    logger.info(f"Encoding {total_encoded_dims} dimensions: {cfg.encoded_dims}")
+    print(f"Encoding {total_encoded_dims} dimensions: {cfg.encoded_dims}")
 
     # parse relative dimensions
     relative_dim_list = None
     if cfg.relative_dims is not None and cfg.relative_dims.strip():
         relative_dim_list = [int(d.strip()) for d in cfg.relative_dims.split(",")]
-        logger.info(f"Relative dimensions: {relative_dim_list}")
+        print(f"Relative dimensions: {relative_dim_list}")
     else:
-        logger.info("No relative dimensions specified")
+        print("No relative dimensions specified")
 
-    logger.info(f"Use relative transform: {cfg.use_relative_transform}")
+    print(f"Use relative transform: {cfg.use_relative_transform}")
     if cfg.use_relative_transform and (relative_dim_list is None or len(relative_dim_list) == 0):
-        logger.warning(
+        print(
             "Warning: use_relative_transform=True but no relative_dims specified. "
             "No relative transform will be applied."
         )
 
-    logger.info(f"Action horizon: {cfg.action_horizon}")
-    logger.info(f"State key: {cfg.state_key}")
+    print(f"Action horizon: {cfg.action_horizon}")
+    print(f"State key: {cfg.state_key}")
 
     # determine episodes to process
     num_episodes = dataset.num_episodes
     if cfg.max_episodes is not None:
         num_episodes = min(cfg.max_episodes, num_episodes)
 
-    logger.info(f"Processing {num_episodes} episodes...")
+    print(f"Processing {num_episodes} episodes...")
 
     # process episodes sequentially (to avoid pickling issues with dataset)
     all_chunks = []
     for ep_idx in range(num_episodes):
         if ep_idx % 10 == 0:
-            logger.info(f"  Processing episode {ep_idx}/{num_episodes}...")
+            print(f"  Processing episode {ep_idx}/{num_episodes}...")
 
         chunks = process_episode(
             (
@@ -456,19 +455,19 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
 
     # concatenate all chunks
     all_chunks = np.concatenate(all_chunks, axis=0)
-    logger.info(f"Collected {len(all_chunks)} action chunks")
+    print(f"Collected {len(all_chunks)} action chunks")
 
     # extract only encoded dimensions FIRST (before normalization)
     encoded_chunks = []
     for start, end in encoded_dim_ranges:
         encoded_chunks.append(all_chunks[:, :, start:end])
     encoded_chunks = np.concatenate(encoded_chunks, axis=-1)  # [N, H, D_encoded]
-    logger.info(f"Extracted {encoded_chunks.shape[-1]} encoded dimensions")
+    print(f"Extracted {encoded_chunks.shape[-1]} encoded dimensions")
 
     # apply normalization to encoded dimensions
-    logger.info("\nBefore normalization - overall stats:")
-    logger.info(f"  Min: {np.min(encoded_chunks):.4f}, Max: {np.max(encoded_chunks):.4f}")
-    logger.info(f"  Mean: {np.mean(encoded_chunks):.4f}, Std: {np.std(encoded_chunks):.4f}")
+    print("\nBefore normalization - overall stats:")
+    print(f"  Min: {np.min(encoded_chunks):.4f}, Max: {np.max(encoded_chunks):.4f}")
+    print(f"  Mean: {np.mean(encoded_chunks):.4f}, Std: {np.std(encoded_chunks):.4f}")
 
     # get normalization stats from dataset
     norm_stats = dataset.meta.stats
@@ -490,9 +489,9 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
                     encoded_stats[stat_name] = stat_array[encoded_dim_indices]
 
         if encoded_stats:
-            logger.info(f"\nNormalization stats for encoded dimensions (mode: {norm_mode.value}):")
+            print(f"\nNormalization stats for encoded dimensions (mode: {norm_mode.value}):")
             for stat_name, stat_values in encoded_stats.items():
-                logger.info(
+                print(
                     f"  {stat_name}: shape={stat_values.shape}, "
                     f"range=[{np.min(stat_values):.4f}, {np.max(stat_values):.4f}]"
                 )
@@ -500,27 +499,27 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
             # apply normalization based on mode
             try:
                 encoded_chunks = apply_normalization(encoded_chunks, encoded_stats, norm_mode, eps=1e-8)
-                logger.info(f"\nApplied {norm_mode.value} normalization")
+                print(f"\nApplied {norm_mode.value} normalization")
             except ValueError as e:
-                logger.warning(f"Warning: {e}. Using raw actions without normalization.")
+                print(f"Warning: {e}. Using raw actions without normalization.")
 
-            logger.info("\nAfter normalization - overall stats:")
-            logger.info(f"  Min: {np.min(encoded_chunks):.4f}, Max: {np.max(encoded_chunks):.4f}")
-            logger.info(f"  Mean: {np.mean(encoded_chunks):.4f}, Std: {np.std(encoded_chunks):.4f}")
+            print("\nAfter normalization - overall stats:")
+            print(f"  Min: {np.min(encoded_chunks):.4f}, Max: {np.max(encoded_chunks):.4f}")
+            print(f"  Mean: {np.mean(encoded_chunks):.4f}, Std: {np.std(encoded_chunks):.4f}")
 
-            logger.info("\nPer-dimension stats (after normalization):")
+            print("\nPer-dimension stats (after normalization):")
             for d in range(encoded_chunks.shape[-1]):
                 dim_data = encoded_chunks[:, :, d]
-                logger.info(
+                print(
                     f"  Dim {d}: min={np.min(dim_data):7.4f}, max={np.max(dim_data):7.4f}, "
                     f"mean={np.mean(dim_data):7.4f}, std={np.std(dim_data):7.4f}"
                 )
         else:
-            logger.warning("Warning: Could not extract stats for encoded dimensions, using raw actions")
+            print("Warning: Could not extract stats for encoded dimensions, using raw actions")
     else:
-        logger.warning("Warning: No normalization stats found in dataset, using raw actions")
+        print("Warning: No normalization stats found in dataset, using raw actions")
 
-    logger.info(f"Encoded chunks shape: {encoded_chunks.shape}")
+    print(f"Encoded chunks shape: {encoded_chunks.shape}")
 
     # train FAST tokenizer
     tokenizer = train_fast_tokenizer(
@@ -562,8 +561,8 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
     with open(output_path / "metadata.json", "w") as f:
         json.dump(metadata, f, indent=2)
 
-    logger.info(f"\nSaved FAST tokenizer to {output_path}")
-    logger.info(f"Metadata: {json.dumps(metadata, indent=2)}")
+    print(f"\nSaved FAST tokenizer to {output_path}")
+    print(f"Metadata: {json.dumps(metadata, indent=2)}")
 
     # push to Hugging Face Hub if requested
     if cfg.push_to_hub:
@@ -571,10 +570,10 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
         hub_repo_id = cfg.hub_repo_id
         if hub_repo_id is None:
             hub_repo_id = output_path.name
-            logger.info(f"\nNo hub_repo_id provided, using: {hub_repo_id}")
+            print(f"\nNo hub_repo_id provided, using: {hub_repo_id}")
 
-        logger.info(f"\nPushing tokenizer to Hugging Face Hub: {hub_repo_id}")
-        logger.info(f"   Private: {cfg.hub_private}")
+        print(f"\nPushing tokenizer to Hugging Face Hub: {hub_repo_id}")
+        print(f"   Private: {cfg.hub_private}")
 
         try:
             # use the tokenizer's push_to_hub method
@@ -594,15 +593,14 @@ def train_tokenizer(cfg: TokenizerTrainingConfig):
                 commit_message="Upload tokenizer metadata",
             )
 
-            logger.info(f"Successfully pushed tokenizer to: https://huggingface.co/{hub_repo_id}")
+            print(f"Successfully pushed tokenizer to: https://huggingface.co/{hub_repo_id}")
         except Exception as e:
-            logger.error(f"Error pushing to hub: {e}")
-            logger.error("   Make sure you're logged in with `huggingface-cli login`")
+            print(f"Error pushing to hub: {e}")
+            print("   Make sure you're logged in with `huggingface-cli login`")
 
 
 def main():
     """CLI entry point that parses arguments and runs the tokenizer training."""
-    init_logging()
     train_tokenizer()
 
 

src/lerobot/teleoperators/gamepad/configuration_gamepad.py

@@ -23,5 +23,3 @@ from ..config import TeleoperatorConfig
 @dataclass
 class GamepadTeleopConfig(TeleoperatorConfig):
     use_gripper: bool = True
-    # Use hidapi instead of pygame for controllers that pygame cannot detect reliably.
-    hidapi_fallback: bool = False

src/lerobot/teleoperators/gamepad/teleop_gamepad.py

@@ -14,7 +14,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging
 import sys
 from enum import IntEnum
 from typing import Any
@@ -28,8 +27,6 @@ from ..teleoperator import Teleoperator
 from ..utils import TeleopEvents
 from .configuration_gamepad import GamepadTeleopConfig
 
-logger = logging.getLogger(__name__)
-
 
 class GripperAction(IntEnum):
     CLOSE = 0
@@ -59,13 +56,6 @@ class GamepadTeleop(Teleoperator):
 
         self.gamepad = None
 
-        self.hidapi_fallback = config.hidapi_fallback
-        if sys.platform == "darwin" and not self.hidapi_fallback:
-            logger.warning(
-                "On macOS, pygame may not reliably detect input from some controllers. "
-                "If you experience issues, set `hidapi_fallback=true`."
-            )
-
     @property
     def action_features(self) -> dict:
         if self.config.use_gripper:
@@ -86,7 +76,9 @@ class GamepadTeleop(Teleoperator):
         return {}
 
     def connect(self) -> None:
-        if self.hidapi_fallback:
+        # use HidApi for macos
+        if sys.platform == "darwin":
+            # NOTE: On macOS, pygame doesn’t reliably detect input from some controllers so we fall back to hidapi
             from .gamepad_utils import GamepadControllerHID as Gamepad
         else:
             from .gamepad_utils import GamepadController as Gamepad

src/lerobot/transforms/transforms.py

@@ -41,7 +41,7 @@ class RandomSubsetApply(Transform):
 
     def __init__(
         self,
-        transforms: Sequence[Callable[..., Any]],
+        transforms: Sequence[Callable],
         p: list[float] | None = None,
         n_subset: int | None = None,
         random_order: bool = False,
@@ -50,7 +50,7 @@ class RandomSubsetApply(Transform):
         if not isinstance(transforms, Sequence):
             raise TypeError("Argument transforms should be a sequence of callables")
         if p is None:
-            p = [1.0] * len(transforms)
+            p = [1] * len(transforms)
         elif len(p) != len(transforms):
             raise ValueError(
                 f"Length of p doesn't match the number of transforms: {len(p)} != {len(transforms)}"
@@ -69,7 +69,7 @@ class RandomSubsetApply(Transform):
         self.n_subset = n_subset
         self.random_order = random_order
 
-        self.selected_transforms: list[Callable[..., Any]] = []
+        self.selected_transforms = None
 
     def forward(self, *inputs: Any) -> Any:
         needs_unpacking = len(inputs) > 1
@@ -119,7 +119,7 @@ class SharpnessJitter(Transform):
         super().__init__()
         self.sharpness = self._check_input(sharpness)
 
-    def _check_input(self, sharpness: float | Sequence[float]) -> tuple[float, float]:
+    def _check_input(self, sharpness):
         if isinstance(sharpness, (int | float)):
             if sharpness < 0:
                 raise ValueError("If sharpness is a single number, it must be non negative.")
@@ -215,7 +215,7 @@ class ImageTransformsConfig:
     )
 
 
-def make_transform_from_config(cfg: ImageTransformConfig) -> Transform:
+def make_transform_from_config(cfg: ImageTransformConfig):
     if cfg.type == "SharpnessJitter":
         return SharpnessJitter(**cfg.kwargs)
 
@@ -236,8 +236,8 @@ class ImageTransforms(Transform):
         super().__init__()
         self._cfg = cfg
 
-        self.weights: list[float] = []
-        self.transforms: dict[str, Transform] = {}
+        self.weights = []
+        self.transforms = {}
         for tf_name, tf_cfg in cfg.tfs.items():
             if tf_cfg.weight <= 0.0:
                 continue

src/lerobot/utils/process.py

@@ -16,39 +16,11 @@
 # limitations under the License.
 
 import logging
-import multiprocessing
 import os
 import signal
 import sys
 
 
-def ensure_multiprocessing_start_method(start_method: str | None) -> None:
-    """Set a multiprocessing start method once, or verify the existing method matches.
-
-    Passing ``None`` leaves Python's process-wide default untouched. This is useful
-    when LeRobot is embedded in an application that owns multiprocessing setup.
-    """
-    if start_method is None:
-        return
-
-    available_methods = multiprocessing.get_all_start_methods()
-    if start_method not in available_methods:
-        raise ValueError(
-            f"Multiprocessing start method must be one of {available_methods} on this platform, "
-            f"got {start_method!r}."
-        )
-
-    current_method = multiprocessing.get_start_method(allow_none=True)
-    if current_method is None:
-        multiprocessing.set_start_method(start_method)
-    elif current_method != start_method:
-        raise RuntimeError(
-            f"Multiprocessing start method is already {current_method!r}; cannot change it to "
-            f"{start_method!r}. Set the configured multiprocessing context to null to keep the "
-            "application's existing method, or launch LeRobot in a fresh process."
-        )
-
-
 class ProcessSignalHandler:
     """Utility class to attach graceful shutdown signal handlers.
 

tests/cameras/test_opencv.py

@@ -20,13 +20,13 @@
 # ```
 
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import cv2
 import numpy as np
 import pytest
 
-from lerobot.cameras.configs import ColorMode, Cv2Rotation
+from lerobot.cameras.configs import Cv2Rotation
 from lerobot.cameras.opencv import OpenCVCamera, OpenCVCameraConfig
 from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
@@ -123,73 +123,6 @@ def test_invalid_width_connect():
         camera.connect(warmup=False)
 
 
-def test_connect_cleans_up_after_settings_failure_and_allows_retry():
-    config = OpenCVCameraConfig(index_or_path=DEFAULT_PNG_FILE_PATH, warmup_s=0)
-    camera = OpenCVCamera(config)
-    opened_captures = []
-
-    def fail_settings():
-        opened_captures.append(camera.videocapture)
-        raise RuntimeError("settings failed")
-
-    with (
-        patch.object(camera, "_configure_capture_settings", side_effect=fail_settings),
-        pytest.raises(RuntimeError, match="settings failed"),
-    ):
-        camera.connect(warmup=False)
-
-    assert camera.videocapture is None
-    assert camera.thread is None
-    assert not camera.is_connected
-    assert opened_captures[0] is not None
-    assert not opened_captures[0].isOpened()
-
-    camera.connect(warmup=False)
-    assert camera.is_connected
-    camera.disconnect()
-
-
-def test_connect_cleans_up_after_warmup_failure_and_allows_retry():
-    config = OpenCVCameraConfig(index_or_path=DEFAULT_PNG_FILE_PATH, warmup_s=1)
-    camera = OpenCVCamera(config)
-    read_threads = []
-
-    def fail_warmup(*_args, **_kwargs):
-        read_threads.append(camera.thread)
-        raise TimeoutError("no frame")
-
-    with (
-        patch.object(camera, "async_read", side_effect=fail_warmup),
-        pytest.raises(TimeoutError, match="no frame"),
-    ):
-        camera.connect()
-
-    assert camera.videocapture is None
-    assert camera.thread is None
-    assert not camera.is_connected
-    assert read_threads[0] is not None
-    assert not read_threads[0].is_alive()
-
-    camera.connect(warmup=False)
-    assert camera.is_connected
-    camera.disconnect()
-
-
-def test_find_cameras_releases_unopened_handles():
-    module_path = OpenCVCamera.__module__
-    unopened_capture = MagicMock()
-    unopened_capture.isOpened.return_value = False
-
-    with (
-        patch(f"{module_path}.platform.system", return_value="Darwin"),
-        patch(f"{module_path}.MAX_OPENCV_INDEX", 1),
-        patch(f"{module_path}.cv2.VideoCapture", return_value=unopened_capture),
-    ):
-        assert OpenCVCamera.find_cameras() == []
-
-    unopened_capture.release.assert_called_once_with()
-
-
 @pytest.mark.parametrize("index_or_path", TEST_IMAGE_PATHS, ids=TEST_IMAGE_SIZES)
 def test_read(index_or_path):
     config = OpenCVCameraConfig(index_or_path=index_or_path, warmup_s=0)
@@ -199,28 +132,6 @@ def test_read(index_or_path):
         assert isinstance(img, np.ndarray)
 
 
-@pytest.mark.parametrize("index_or_path", TEST_IMAGE_PATHS, ids=TEST_IMAGE_SIZES)
-def test_color_mode_conversion(index_or_path):
-    """RGB and BGR reads of the same frame must differ only by a channel-axis reversal."""
-    rgb_config = OpenCVCameraConfig(index_or_path=index_or_path, color_mode=ColorMode.RGB, warmup_s=0)
-    bgr_config = OpenCVCameraConfig(index_or_path=index_or_path, color_mode=ColorMode.BGR, warmup_s=0)
-    with OpenCVCamera(rgb_config) as rgb_cam:
-        rgb = rgb_cam.read()
-    with OpenCVCamera(bgr_config) as bgr_cam:
-        bgr = bgr_cam.read()
-
-    assert rgb.shape == bgr.shape
-    np.testing.assert_array_equal(rgb, bgr[..., ::-1])
-
-
-def test_postprocess_invalid_color_mode():
-    config = OpenCVCameraConfig(index_or_path=DEFAULT_PNG_FILE_PATH)
-    camera = OpenCVCamera(config)
-    camera.color_mode = "invalid"
-    with pytest.raises(ValueError):
-        camera._postprocess_image(np.zeros((120, 160, 3), dtype=np.uint8))
-
-
 def test_read_before_connect():
     config = OpenCVCameraConfig(index_or_path=DEFAULT_PNG_FILE_PATH)
 

tests/cameras/test_reachy2_camera.py

@@ -22,7 +22,6 @@ import pytest
 
 pytest.importorskip("reachy2_sdk")
 
-from lerobot.cameras.configs import ColorMode
 from lerobot.cameras.reachy2_camera import Reachy2Camera, Reachy2CameraConfig
 from lerobot.utils.errors import DeviceNotConnectedError
 
@@ -34,19 +33,28 @@ PARAMS = [
 ]
 
 
-def _make_cam_manager_mock(color_frame, depth_frame=None):
+def _make_cam_manager_mock():
     c = MagicMock(name="CameraManagerMock")
 
     teleop = MagicMock(name="TeleopCam")
     teleop.width = 640
     teleop.height = 480
-    teleop.get_frame = MagicMock(side_effect=lambda *_, **__: (color_frame, time.time()))
+    teleop.get_frame = MagicMock(
+        side_effect=lambda *_, **__: (
+            np.zeros((480, 640, 3), dtype=np.uint8),
+            time.time(),
+        )
+    )
 
     depth = MagicMock(name="DepthCam")
     depth.width = 640
     depth.height = 480
-    depth.get_frame = MagicMock(side_effect=lambda *_, **__: (color_frame, time.time()))
-    depth.get_depth_frame = MagicMock(side_effect=lambda *_, **__: (depth_frame, time.time()))
+    depth.get_frame = MagicMock(
+        side_effect=lambda *_, **__: (
+            np.zeros((480, 640, 3), dtype=np.uint8),
+            time.time(),
+        )
+    )
 
     c.is_connected.return_value = True
     c.teleop = teleop
@@ -76,14 +84,12 @@ def _make_cam_manager_mock(color_frame, depth_frame=None):
     # ids=["teleop-left", "teleop-right", "torso-rgb", "torso-depth"],
     ids=["teleop-left", "teleop-right", "torso-rgb"],
 )
-def camera(request, img_array_factory):
+def camera(request):
     name, image_type = request.param
-    color_frame = img_array_factory(height=480, width=640)
-    depth_frame = img_array_factory(height=480, width=640, channels=1, dtype=np.uint16)[..., 0]
     with (
         patch(
             "lerobot.cameras.reachy2_camera.reachy2_camera.CameraManager",
-            side_effect=lambda *a, **k: _make_cam_manager_mock(color_frame, depth_frame),
+            side_effect=lambda *a, **k: _make_cam_manager_mock(),
         ),
     ):
         config = Reachy2CameraConfig(name=name, image_type=image_type)
@@ -182,41 +188,6 @@ def test_read_latest_too_old(camera):
         _ = camera.read_latest(max_age_ms=0)  # immediately too old
 
 
-def test_color_mode_conversion(img_array_factory):
-    """teleop frames are native BGR: RGB reverses the channel axis, BGR is passed through."""
-    frame = img_array_factory(height=8, width=8)
-
-    outputs = {}
-    for color_mode in (ColorMode.RGB, ColorMode.BGR):
-        with patch(
-            "lerobot.cameras.reachy2_camera.reachy2_camera.CameraManager",
-            side_effect=lambda *a, **k: _make_cam_manager_mock(frame),
-        ):
-            cam = Reachy2Camera(Reachy2CameraConfig(name="teleop", image_type="left", color_mode=color_mode))
-            cam.connect()
-            outputs[color_mode] = cam.read()
-            cam.disconnect()
-
-    np.testing.assert_array_equal(outputs[ColorMode.BGR], frame)
-    np.testing.assert_array_equal(outputs[ColorMode.RGB], frame[..., ::-1])
-
-
-def test_depth_frame_not_color_converted(img_array_factory):
-    """A depth/depth frame must be returned as-is, without BGR<->RGB conversion."""
-    color_frame = img_array_factory(height=8, width=8)
-    depth = img_array_factory(height=8, width=8, channels=1, dtype=np.uint16)[..., 0]
-    with patch(
-        "lerobot.cameras.reachy2_camera.reachy2_camera.CameraManager",
-        side_effect=lambda *a, **k: _make_cam_manager_mock(color_frame, depth_frame=depth),
-    ):
-        cam = Reachy2Camera(Reachy2CameraConfig(name="depth", image_type="depth"))
-        cam.connect()
-        out = cam.read()
-        cam.disconnect()
-
-    np.testing.assert_array_equal(out, depth)
-
-
 def test_wrong_camera_name():
     with pytest.raises(ValueError):
         _ = Reachy2CameraConfig(name="wrong-name", image_type="left")

tests/cameras/test_realsense.py

@@ -20,18 +20,16 @@
 # ```
 
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import numpy as np
 import pytest
 
-from lerobot.cameras.configs import ColorMode, Cv2Rotation
+from lerobot.cameras.configs import Cv2Rotation
 from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
 
 pytest.importorskip("pyrealsense2")
 
-import pyrealsense2 as rs
-
 from lerobot.cameras.realsense import RealSenseCamera, RealSenseCameraConfig
 
 TEST_ARTIFACTS_DIR = Path(__file__).parent.parent / "artifacts" / "cameras"
@@ -63,17 +61,6 @@ def test_abc_implementation():
     _ = RealSenseCamera(config)
 
 
-@pytest.mark.parametrize("option", ["exposure", "gain", "white_balance"])
-def test_manual_color_option_requires_rgb(option):
-    with pytest.raises(ValueError, match="use_rgb=True"):
-        RealSenseCameraConfig(
-            serial_number_or_name="042",
-            use_rgb=False,
-            use_depth=True,
-            **{option: 100},
-        )
-
-
 def test_connect():
     config = RealSenseCameraConfig(serial_number_or_name="042", warmup_s=0)
 
@@ -96,27 +83,6 @@ def test_connect_invalid_camera_path(patch_realsense):
         camera.connect(warmup=False)
 
 
-def test_connect_cleans_up_when_sensor_configuration_fails():
-    config = RealSenseCameraConfig(serial_number_or_name="042", exposure=120)
-    camera = RealSenseCamera(config)
-    pipeline = MagicMock()
-    pipeline.start.return_value = MagicMock()
-
-    with (
-        patch("lerobot.cameras.realsense.camera_realsense.rs.pipeline", return_value=pipeline),
-        patch.object(camera, "_configure_rs_pipeline_config"),
-        patch.object(camera, "_configure_capture_settings"),
-        patch.object(camera, "_configure_sensor_options", side_effect=ValueError("invalid exposure")),
-        pytest.raises(ValueError, match="invalid exposure"),
-    ):
-        camera.connect(warmup=False)
-
-    pipeline.stop.assert_called_once_with()
-    assert camera.rs_pipeline is None
-    assert camera.rs_profile is None
-    assert not camera.is_connected
-
-
 def test_invalid_width_connect():
     config = RealSenseCameraConfig(serial_number_or_name="042", width=99999, height=480, fps=30)
     camera = RealSenseCamera(config)
@@ -125,33 +91,6 @@ def test_invalid_width_connect():
         camera.connect(warmup=False)
 
 
-def test_connect_cleans_up_after_warmup_failure_and_allows_retry():
-    config = RealSenseCameraConfig(serial_number_or_name="042", width=640, height=480, fps=30)
-    camera = RealSenseCamera(config)
-    read_threads = []
-
-    def fail_warmup(*_args, **_kwargs):
-        read_threads.append(camera.thread)
-        raise TimeoutError("no frame")
-
-    with (
-        patch.object(camera, "async_read", side_effect=fail_warmup),
-        pytest.raises(TimeoutError, match="no frame"),
-    ):
-        camera.connect()
-
-    assert camera.rs_pipeline is None
-    assert camera.rs_profile is None
-    assert camera.thread is None
-    assert not camera.is_connected
-    assert read_threads[0] is not None
-    assert not read_threads[0].is_alive()
-
-    camera.connect(warmup=False)
-    assert camera.is_connected
-    camera.disconnect()
-
-
 def test_read():
     config = RealSenseCameraConfig(serial_number_or_name="042", width=640, height=480, fps=30, warmup_s=0)
     with RealSenseCamera(config) as camera:
@@ -170,32 +109,6 @@ def test_read_depth():
     assert isinstance(img, np.ndarray)
 
 
-# These exercise _postprocess_image directly rather than read(): the bag playback returns
-# non-deterministic frames we can't compare against, and the depth read() path is skipped
-# (see test_read_depth) with the current pyrealsense2 version.
-def test_color_mode_conversion(img_array_factory):
-    """RGB (native for RealSense) is passed through; BGR reverses the channel axis."""
-    color = img_array_factory(height=3, width=4)
-
-    outputs = {}
-    for color_mode in (ColorMode.RGB, ColorMode.BGR):
-        camera = RealSenseCamera(RealSenseCameraConfig(serial_number_or_name="042", color_mode=color_mode))
-        camera.capture_height, camera.capture_width = color.shape[:2]
-        outputs[color_mode] = camera._postprocess_image(color)
-
-    np.testing.assert_array_equal(outputs[ColorMode.RGB], color)
-    np.testing.assert_array_equal(outputs[ColorMode.BGR], color[..., ::-1])
-
-
-def test_depth_frame_not_color_converted(img_array_factory):
-    """Depth frames must bypass color conversion, even when a BGR color_mode is set."""
-    camera = RealSenseCamera(RealSenseCameraConfig(serial_number_or_name="042", color_mode=ColorMode.BGR))
-    depth = img_array_factory(height=3, width=4, channels=1, dtype=np.uint16)[..., 0]
-    camera.capture_height, camera.capture_width = depth.shape
-
-    np.testing.assert_array_equal(camera._postprocess_image(depth, depth_frame=True), depth)
-
-
 def test_read_before_connect():
     config = RealSenseCameraConfig(serial_number_or_name="042")
     camera = RealSenseCamera(config)
@@ -289,203 +202,6 @@ def test_read_latest_too_old():
             _ = camera.read_latest(max_age_ms=0)  # immediately too old
 
 
-def _make_mock_sensor(name: str, supported_options: set | None = None) -> MagicMock:
-    """Build a fake rs.sensor that reports a name and a configurable supported-options set."""
-    supported = supported_options if supported_options is not None else set()
-    sensor = MagicMock()
-    sensor.get_info.return_value = name
-    sensor.supports.side_effect = lambda opt: opt in supported
-    return sensor
-
-
-def _attach_mock_color_sensor(camera: RealSenseCamera, sensor: MagicMock) -> None:
-    """Wire camera.rs_profile so _get_color_sensor finds the given sensor."""
-    profile = MagicMock()
-    device = MagicMock()
-    device.query_sensors.return_value = [sensor]
-    profile.get_device.return_value = device
-    camera.rs_profile = profile
-
-
-def test_get_color_sensor_prefers_rgb_camera():
-    config = RealSenseCameraConfig(serial_number_or_name="042")
-    camera = RealSenseCamera(config)
-
-    rgb = _make_mock_sensor("RGB Camera")
-    stereo = _make_mock_sensor("Stereo Module")
-    profile = MagicMock()
-    device = MagicMock()
-    device.query_sensors.return_value = [stereo, rgb]
-    profile.get_device.return_value = device
-    camera.rs_profile = profile
-
-    assert camera._get_color_sensor() is rgb
-
-
-def test_get_color_sensor_falls_back_to_stereo_module():
-    """D405 has no separate RGB module; color comes from Stereo Module."""
-    config = RealSenseCameraConfig(serial_number_or_name="042")
-    camera = RealSenseCamera(config)
-
-    stereo = _make_mock_sensor("Stereo Module")
-    _attach_mock_color_sensor(camera, stereo)
-
-    assert camera._get_color_sensor() is stereo
-
-
-def test_get_color_sensor_raises_with_available_sensors():
-    config = RealSenseCameraConfig(serial_number_or_name="042")
-    camera = RealSenseCamera(config)
-
-    other = _make_mock_sensor("Motion Module")
-    _attach_mock_color_sensor(camera, other)
-
-    with pytest.raises(RuntimeError, match="Motion Module"):
-        camera._get_color_sensor()
-
-
-def test_configure_sensor_options_skipped_when_none():
-    config = RealSenseCameraConfig(serial_number_or_name="042")
-    camera = RealSenseCamera(config)
-
-    with patch.object(RealSenseCamera, "_get_color_sensor") as mock_get:
-        camera._configure_sensor_options()
-        mock_get.assert_not_called()
-
-
-def test_configure_sensor_options_applies_all_values():
-    config = RealSenseCameraConfig(serial_number_or_name="042", exposure=120, gain=64, white_balance=4600)
-    camera = RealSenseCamera(config)
-
-    sensor = _make_mock_sensor(
-        "RGB Camera",
-        supported_options={
-            rs.option.enable_auto_exposure,
-            rs.option.exposure,
-            rs.option.gain,
-            rs.option.enable_auto_white_balance,
-            rs.option.white_balance,
-        },
-    )
-    _attach_mock_color_sensor(camera, sensor)
-
-    camera._configure_sensor_options()
-
-    sensor.set_option.assert_any_call(rs.option.enable_auto_exposure, 0)
-    sensor.set_option.assert_any_call(rs.option.exposure, 120)
-    sensor.set_option.assert_any_call(rs.option.gain, 64)
-    sensor.set_option.assert_any_call(rs.option.enable_auto_white_balance, 0)
-    sensor.set_option.assert_any_call(rs.option.white_balance, 4600)
-
-
-@pytest.mark.parametrize(
-    ("config_field", "option", "label"),
-    [
-        ("exposure", rs.option.exposure, "exposure"),
-        ("gain", rs.option.gain, "gain"),
-        ("white_balance", rs.option.white_balance, "white balance"),
-    ],
-)
-def test_configure_sensor_options_raises_when_requested_option_is_unsupported(config_field, option, label):
-    config = RealSenseCameraConfig(serial_number_or_name="042", **{config_field: 100})
-    camera = RealSenseCamera(config)
-
-    sensor = _make_mock_sensor("RGB Camera", supported_options=set())
-    _attach_mock_color_sensor(camera, sensor)
-
-    with pytest.raises(ValueError, match=label):
-        camera._configure_sensor_options()
-
-    sensor.supports.assert_any_call(option)
-    sensor.set_option.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    ("config_field", "option", "value"),
-    [
-        ("exposure", rs.option.exposure, 120),
-        ("gain", rs.option.gain, 64),
-    ],
-)
-def test_configure_sensor_options_exposure_or_gain_disables_auto_exposure(config_field, option, value):
-    """white_balance=None should not touch auto white balance."""
-    config = RealSenseCameraConfig(serial_number_or_name="042", **{config_field: value})
-    camera = RealSenseCamera(config)
-
-    sensor = _make_mock_sensor(
-        "RGB Camera",
-        supported_options={rs.option.enable_auto_exposure, option},
-    )
-    _attach_mock_color_sensor(camera, sensor)
-
-    camera._configure_sensor_options()
-
-    calls = [call.args for call in sensor.set_option.call_args_list]
-    assert (rs.option.enable_auto_exposure, 0) in calls
-    assert (option, value) in calls
-    for opt, _ in calls:
-        assert opt != rs.option.enable_auto_white_balance
-        assert opt != rs.option.white_balance
-
-
-def test_configure_sensor_options_warns_when_auto_exposure_control_is_unsupported(caplog):
-    config = RealSenseCameraConfig(serial_number_or_name="042", exposure=120)
-    camera = RealSenseCamera(config)
-
-    sensor = _make_mock_sensor("RGB Camera", supported_options={rs.option.exposure})
-    _attach_mock_color_sensor(camera, sensor)
-
-    with caplog.at_level("WARNING"):
-        camera._configure_sensor_options()
-
-    sensor.set_option.assert_called_once_with(rs.option.exposure, 120)
-    assert "does not support disabling auto-exposure" in caplog.text
-
-
-def test_configure_sensor_options_warns_when_auto_white_balance_control_is_unsupported(caplog):
-    config = RealSenseCameraConfig(serial_number_or_name="042", white_balance=4600)
-    camera = RealSenseCamera(config)
-
-    sensor = _make_mock_sensor("RGB Camera", supported_options={rs.option.white_balance})
-    _attach_mock_color_sensor(camera, sensor)
-
-    with caplog.at_level("WARNING"):
-        camera._configure_sensor_options()
-
-    sensor.set_option.assert_called_once_with(rs.option.white_balance, 4600)
-    assert "does not support disabling auto white balance" in caplog.text
-
-
-def test_configure_sensor_options_out_of_range_raises_value_error():
-    """set_option errors should be re-raised as ValueError with range diagnostics."""
-    config = RealSenseCameraConfig(serial_number_or_name="042", exposure=999999)
-    camera = RealSenseCamera(config)
-
-    sensor = _make_mock_sensor(
-        "RGB Camera",
-        supported_options={rs.option.enable_auto_exposure, rs.option.exposure},
-    )
-
-    def fake_set_option(option, value):
-        if option == rs.option.exposure:
-            raise RuntimeError("value out of range")
-
-    sensor.set_option.side_effect = fake_set_option
-
-    option_range = MagicMock(min=1, max=10000, step=1, default=156)
-    sensor.get_option_range.return_value = option_range
-
-    _attach_mock_color_sensor(camera, sensor)
-
-    with pytest.raises(ValueError, match="exposure") as exc_info:
-        camera._configure_sensor_options()
-
-    msg = str(exc_info.value)
-    assert "999999" in msg
-    assert "min=1" in msg
-    assert "max=10000" in msg
-
-
 @pytest.mark.parametrize(
     "rotation",
     [

tests/datasets/test_dataset_utils.py

@@ -14,21 +14,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from types import SimpleNamespace
-from unittest.mock import Mock
-
 import pytest
 import torch
-from packaging.version import Version
 
 pytest.importorskip("datasets", reason="datasets is required (install lerobot[dataset])")
 
 from datasets import Dataset  # noqa: E402
 from huggingface_hub import DatasetCard
 
-import lerobot.datasets.utils as dataset_utils
 from lerobot.datasets.io_utils import hf_transform_to_torch
-from lerobot.datasets.utils import create_lerobot_dataset_card, get_repo_versions, get_safe_version
+from lerobot.datasets.utils import create_lerobot_dataset_card
 from lerobot.utils.constants import ACTION, OBS_IMAGES
 from lerobot.utils.feature_utils import combine_feature_dicts
 
@@ -62,30 +57,6 @@ def test_default_parameters():
     ]
 
 
-@pytest.mark.parametrize("token", ["hf_test_token", True, False])
-def test_get_repo_versions_forwards_token(monkeypatch, token):
-    api = Mock()
-    api.list_repo_refs.return_value = SimpleNamespace(
-        branches=[SimpleNamespace(name="v3.0")],
-        tags=[],
-    )
-    hf_api = Mock(return_value=api)
-    monkeypatch.setattr(dataset_utils, "HfApi", hf_api)
-
-    assert get_repo_versions("private/repo", token=token) == [Version("3.0")]
-    hf_api.assert_called_once_with(token=token)
-    api.list_repo_refs.assert_called_once_with("private/repo", repo_type="dataset")
-
-
-@pytest.mark.parametrize("token", ["hf_test_token", True, False])
-def test_get_safe_version_forwards_token(monkeypatch, token):
-    get_versions = Mock(return_value=[Version("3.0")])
-    monkeypatch.setattr(dataset_utils, "get_repo_versions", get_versions)
-
-    assert get_safe_version("private/repo", "v3.0", token=token) == "v3.0"
-    get_versions.assert_called_once_with("private/repo", token=token)
-
-
 def test_with_tags():
     tags = ["tag1", "tag2"]
     card = create_lerobot_dataset_card(tags=tags)

tests/datasets/test_dataset_writer.py

@@ -204,38 +204,6 @@ def test_clear_resets_buffer(tmp_path):
     assert dataset.writer.episode_buffer["size"] == 0
 
 
-def test_clear_removes_video_frame_staging_dir(tmp_path):
-    """clear_episode_buffer() removes PNG staging dirs for video features."""
-    video_key = "observation.images.cam"
-    features = {
-        video_key: {
-            "dtype": "video",
-            "shape": (64, 96, 3),
-            "names": ["height", "width", "channels"],
-        },
-        "action": {"dtype": "float32", "shape": (2,), "names": None},
-    }
-    dataset = LeRobotDataset.create(
-        repo_id=DUMMY_REPO_ID,
-        fps=DEFAULT_FPS,
-        features=features,
-        root=tmp_path / "ds",
-        use_videos=True,
-    )
-
-    dataset.add_frame(_make_frame(features))
-    video_staging_dir = (
-        dataset.root
-        / Path(DEFAULT_IMAGE_PATH.format(image_key=video_key, episode_index=0, frame_index=0)).parent
-    )
-    assert video_staging_dir.is_dir()
-
-    dataset.clear_episode_buffer()
-
-    assert dataset.writer.episode_buffer["size"] == 0
-    assert not video_staging_dir.exists()
-
-
 def test_finalize_is_idempotent(tmp_path):
     """Calling finalize() twice does not raise."""
     dataset = LeRobotDataset.create(

tests/datasets/test_datasets.py

@@ -114,20 +114,6 @@ def test_dataset_initialization(tmp_path, lerobot_dataset_factory):
     assert dataset.num_frames == len(dataset)
 
 
-def test_dataset_slice(tmp_path, lerobot_dataset_factory):
-    dataset = lerobot_dataset_factory(
-        root=tmp_path / "test", total_episodes=3, total_frames=30, use_videos=False
-    )
-
-    assert len(dataset[:5]) == 5
-    assert len(dataset[::2]) == (len(dataset) + 1) // 2
-    assert [item["index"].item() for item in dataset[4::-1]] == [4, 3, 2, 1, 0]
-    assert [item["index"].item() for item in dataset[-3:]] == list(range(len(dataset) - 3, len(dataset)))
-    assert dataset[len(dataset) :] == []
-    assert isinstance(dataset[0], dict)
-    assert dataset[:1][0].keys() == dataset[0].keys()
-
-
 # TODO(rcadene, aliberts): do not run LeRobotDataset.create, instead refactor LeRobotDatasetMetadata.create
 # and test the small resulting function that validates the features
 def test_dataset_feature_with_forward_slash_raises_error():
@@ -1755,38 +1741,6 @@ def test_delta_timestamps_query_returns_correct_values(tmp_path, empty_lerobot_d
     assert is_pad == [True, False], f"Expected [True, False], got {is_pad}"
 
 
-def test_dataset_slice_with_delta_timestamps(tmp_path, empty_lerobot_dataset_factory):
-    features = {
-        "observation.state": {"dtype": "float32", "shape": (1,), "names": ["x"]},
-    }
-    dataset = empty_lerobot_dataset_factory(
-        root=tmp_path / "test_slice_delta", features=features, use_videos=False, fps=10
-    )
-
-    for frame_idx in range(5):
-        dataset.add_frame(
-            {
-                "observation.state": torch.tensor([frame_idx], dtype=torch.float32),
-                "task": "task_0",
-            }
-        )
-    dataset.save_episode()
-    dataset.finalize()
-
-    sliced_dataset = LeRobotDataset(
-        dataset.repo_id,
-        root=dataset.root,
-        delta_timestamps={"observation.state": [-0.1, 0.0]},
-        tolerance_s=0.04,
-    )
-
-    items = sliced_dataset[:2]
-
-    assert items[0]["observation.state"].tolist() == [0.0, 0.0]
-    assert items[0]["observation.state_is_pad"].tolist() == [True, False]
-    assert items[1]["observation.state"].tolist() == [0.0, 1.0]
-
-
 def test_episode_filter_filters_dataset(tmp_path, lerobot_dataset_factory):
     """episode_filter on LeRobotDataset narrows the loaded dataset to matching episodes."""
     dataset = lerobot_dataset_factory(root=tmp_path / "test", total_episodes=8, total_frames=200)

tests/datasets/test_lerobot_dataset.py

@@ -20,7 +20,6 @@ property delegation, and the full create-record-finalize-read lifecycle.
 """
 
 from pathlib import Path
-from types import SimpleNamespace
 from unittest.mock import Mock
 
 import pytest
@@ -192,48 +191,6 @@ def test_metadata_without_root_uses_hub_cache_snapshot_download(
     }
 
 
-@pytest.mark.parametrize("token", ["hf_test_token", True, False])
-def test_metadata_download_forwards_token(tmp_path, monkeypatch, token):
-    snapshot_root = tmp_path / "snapshot"
-    snapshot_download = Mock(return_value=str(snapshot_root))
-    get_safe_version = Mock(return_value="v3.0")
-    load_metadata = Mock(side_effect=[FileNotFoundError, None])
-    monkeypatch.setattr(dataset_metadata_module, "snapshot_download", snapshot_download)
-    monkeypatch.setattr(dataset_metadata_module, "get_safe_version", get_safe_version)
-    monkeypatch.setattr(LeRobotDatasetMetadata, "_load_metadata", load_metadata)
-
-    meta = LeRobotDatasetMetadata(
-        repo_id=DUMMY_REPO_ID,
-        revision="v3.0",
-        token=token,
-    )
-
-    assert meta.root == snapshot_root
-    assert not hasattr(meta, "_token")
-    get_safe_version.assert_called_once_with(DUMMY_REPO_ID, "v3.0", token=token)
-    assert snapshot_download.call_args.kwargs["token"] is token
-
-
-@pytest.mark.parametrize("token", ["hf_test_token", True, False])
-def test_data_download_forwards_token(tmp_path, monkeypatch, token):
-    snapshot_root = tmp_path / "snapshot"
-    snapshot_download = Mock(return_value=str(snapshot_root))
-    monkeypatch.setattr(lerobot_dataset_module, "snapshot_download", snapshot_download)
-
-    dataset = LeRobotDataset.__new__(LeRobotDataset)
-    dataset.repo_id = DUMMY_REPO_ID
-    dataset.revision = "main"
-    dataset.episodes = None
-    dataset._requested_root = None
-    dataset.meta = SimpleNamespace(root=None)
-    dataset.reader = SimpleNamespace(root=None)
-
-    dataset._download(token=token)
-
-    assert dataset.root == snapshot_root
-    assert snapshot_download.call_args.kwargs["token"] is token
-
-
 def test_without_root_reads_different_revisions_from_distinct_snapshot_roots(
     tmp_path,
     info_factory,
@@ -482,20 +439,6 @@ def test_add_frame_works_in_write_mode(tmp_path):
 # ── Resume mode ──────────────────────────────────────────────────────
 
 
-def test_resume_freshly_created_empty_dataset(tmp_path):
-    """resume() accepts a local dataset created before any episode was recorded."""
-    root = tmp_path / "resume_empty_ds"
-    LeRobotDataset.create(repo_id=DUMMY_REPO_ID, fps=DEFAULT_FPS, features=SIMPLE_FEATURES, root=root)
-
-    resumed = LeRobotDataset.resume(repo_id=DUMMY_REPO_ID, root=root)
-
-    assert isinstance(resumed.writer, DatasetWriter)
-    assert resumed.meta.total_episodes == 0
-    assert resumed.meta.total_frames == 0
-    assert resumed.meta.tasks is None
-    assert resumed.meta.episodes is None
-
-
 def test_resume_creates_writer(tmp_path):
     """After resume(), writer is a DatasetWriter."""
     root = tmp_path / "resume_ds"

tests/datasets/test_streaming.py

@@ -13,16 +13,12 @@
 # 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.
-from types import SimpleNamespace
-from unittest.mock import Mock
-
 import numpy as np
 import pytest
 import torch
 
 pytest.importorskip("datasets", reason="datasets is required (install lerobot[dataset])")
 
-import lerobot.datasets.streaming_dataset as streaming_dataset_module
 from lerobot.datasets.streaming_dataset import StreamingLeRobotDataset
 from lerobot.datasets.utils import safe_shard
 from lerobot.utils.constants import ACTION
@@ -75,40 +71,6 @@ def get_frames_expected_order(streaming_ds: StreamingLeRobotDataset) -> list[int
     return expected_indices
 
 
-@pytest.mark.parametrize("token", ["hf_test_token", True, False])
-@pytest.mark.parametrize("from_local", [False, True])
-def test_streaming_dataset_forwards_hub_token_only_for_remote_data(tmp_path, monkeypatch, token, from_local):
-    requested_root = tmp_path / "local" if from_local else None
-    metadata = SimpleNamespace(
-        root=requested_root or tmp_path / "snapshot",
-        revision=streaming_dataset_module.CODEBASE_VERSION,
-        _version=streaming_dataset_module.CODEBASE_VERSION,
-        features={},
-        depth_keys=[],
-        image_keys=[],
-        rescale_depth_stats=Mock(),
-    )
-    metadata_cls = Mock(return_value=metadata)
-    load_dataset = Mock(return_value=SimpleNamespace(num_shards=1))
-    monkeypatch.setattr(streaming_dataset_module, "LeRobotDatasetMetadata", metadata_cls)
-    monkeypatch.setattr(streaming_dataset_module, "load_dataset", load_dataset)
-
-    dataset = StreamingLeRobotDataset(DUMMY_REPO_ID, root=requested_root, token=token)
-
-    metadata_cls.assert_called_once_with(
-        DUMMY_REPO_ID,
-        requested_root,
-        streaming_dataset_module.CODEBASE_VERSION,
-        force_cache_sync=False,
-        token=token,
-    )
-    if from_local:
-        assert "token" not in load_dataset.call_args.kwargs
-    else:
-        assert load_dataset.call_args.kwargs["token"] is token
-    assert not hasattr(dataset, "_token")
-
-
 def test_single_frame_consistency(tmp_path, lerobot_dataset_factory):
     """Test if are correctly accessed"""
     ds_num_frames = 400

tests/envs/test_dispatch.py

@@ -35,17 +35,6 @@ def test_unknown_type():
         make_env_config("nonexistent")
 
 
-def test_libero_fps_controls_simulator_frequency():
-    cfg = LiberoEnv(fps=17)
-
-    assert cfg.gym_kwargs["control_freq"] == 17
-
-
-def test_libero_rejects_nonpositive_fps():
-    with pytest.raises(ValueError, match="fps must be positive"):
-        LiberoEnv(fps=0)
-
-
 def test_identity_processors():
     """Base class get_env_processors() returns identity pipelines."""
     cfg = make_env_config("aloha")

tests/jobs/test_annotate.py

@@ -1,245 +0,0 @@
-# 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 shlex
-import sys
-from unittest.mock import MagicMock
-
-import draccus
-import pytest
-
-pytest.importorskip("datasets", reason="datasets is required (install lerobot[dataset])")
-
-from lerobot.annotations.steerable_pipeline.config import (
-    DEFAULT_ANNOTATE_JOB_IMAGE,
-    AnnotationJobConfig,
-    AnnotationPipelineConfig,
-)
-from lerobot.jobs.annotate import build_pod_command, build_pod_setup, submit_annotate_to_hf
-
-
-def _parse(*args):
-    return draccus.parse(AnnotationPipelineConfig, args=list(args))
-
-
-def _set_argv(monkeypatch, *args):
-    monkeypatch.setattr(sys, "argv", ["lerobot-annotate", *args])
-
-
-# --- config ----------------------------------------------------------------
-
-
-def test_annotation_job_defaults_are_local_with_vllm_image():
-    cfg = AnnotationJobConfig()
-    assert cfg.target is None
-    assert cfg.is_remote is False
-    assert cfg.image == DEFAULT_ANNOTATE_JOB_IMAGE
-    assert cfg.timeout == "2h"
-    assert cfg.lerobot_ref == "main"
-
-
-def test_annotation_config_parses_job_target():
-    cfg = _parse("--repo_id", "u/d", "--job.target", "h200")
-    assert cfg.job.target == "h200"
-    assert cfg.job.is_remote is True
-
-
-def test_annotation_config_defaults_to_local():
-    assert _parse("--repo_id", "u/d").job.is_remote is False
-
-
-# --- pod command -----------------------------------------------------------
-
-
-def test_pod_setup_installs_requested_ref():
-    setup = build_pod_setup("my-branch")
-    assert "git+https://github.com/huggingface/lerobot.git@my-branch" in setup
-    # The vLLM image has neither ffmpeg (video decode) nor lerobot's pinned deps.
-    assert "ffmpeg" in setup
-    assert "'draccus==0.10.0'" in setup
-
-
-def _annotate_argv(command):
-    """Extract the `lerobot-annotate ...` argv from a `bash -c` pod command."""
-    assert command[:2] == ["bash", "-c"]
-    _setup, _, annotate = command[2].rpartition(" && ")
-    return shlex.split(annotate)
-
-
-def test_pod_command_forwards_user_flags_and_pins_local_target():
-    command = build_pod_command(
-        "u/d",
-        "main",
-        ["--repo_id=u/d", "--new_repo_id=u/d_annotated", "--push_to_hub=true", "--job.target=h200"],
-    )
-    argv = _annotate_argv(command)
-    assert argv[0] == "lerobot-annotate"
-    # --job.* is client-side orchestration; the pod must not re-dispatch itself.
-    assert not any(a.startswith("--job.") for a in argv[1:-1])
-    assert argv[-1] == "--job.target=local"
-    assert "--new_repo_id=u/d_annotated" in argv
-    assert "--push_to_hub=true" in argv
-
-
-def test_pod_command_replaces_host_local_root_with_repo_id():
-    """--root points at a directory only the client has; the pod resolves by repo_id."""
-    command = build_pod_command("u/d", "main", ["--root", "/home/me/datasets/d", "--seed=7"])
-    argv = _annotate_argv(command)
-    assert "--root" not in argv
-    assert "/home/me/datasets/d" not in argv
-    assert argv.count("--repo_id=u/d") == 1
-    assert "--seed=7" in argv
-
-
-def test_pod_command_does_not_duplicate_repo_id():
-    command = build_pod_command("u/d", "main", ["--repo_id", "u/d"])
-    assert _annotate_argv(command).count("--repo_id=u/d") == 1
-
-
-def test_pod_command_quotes_flags_containing_spaces_and_json():
-    """serve_command and chat_template_kwargs must survive the trip through `bash -c`."""
-    serve = "--vlm.serve_command=vllm serve Qwen/Qwen3.6-27B --max-model-len 32768 --port {port}"
-    kwargs = '--vlm.chat_template_kwargs={"enable_thinking": false}'
-    command = build_pod_command("u/d", "main", [serve, kwargs])
-    argv = _annotate_argv(command)
-    assert serve in argv
-    assert kwargs in argv
-
-
-# --- submission ------------------------------------------------------------
-
-
-def test_submit_requires_login(monkeypatch):
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: None)
-    with pytest.raises(RuntimeError, match="hf auth login"):
-        submit_annotate_to_hf(_parse("--repo_id", "u/d", "--job.target", "h200"))
-
-
-def test_submit_requires_repo_id(monkeypatch):
-    """A remote run over --root alone can't work: the pod can't see the client's disk."""
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: "tok")
-    cfg = _parse("--root", "/tmp/d", "--job.target", "h200")
-    with pytest.raises(ValueError, match="--repo_id"):
-        submit_annotate_to_hf(cfg)
-
-
-@pytest.mark.parametrize("arg", ["--config_path=annotate.yaml", "--vlm=vlm.yaml", "--job=job.yaml"])
-def test_submit_rejects_local_config_files(monkeypatch, arg):
-    """draccus takes a config file for the whole config and for each nested one; the
-    pod can read none of them, so a remote run must refuse rather than drop them."""
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: "tok")
-    _set_argv(monkeypatch, arg, "--job.target=h200")
-    cfg = _parse("--repo_id", "u/d", "--job.target", "h200")
-    with pytest.raises(ValueError, match="cannot read config files"):
-        submit_annotate_to_hf(cfg)
-
-
-def test_pod_command_drops_bare_job_config_file_arg():
-    """`--job` isn't caught by the `--job.` prefix, and could carry a remote target
-    that would make the pod submit a job of its own — recursively."""
-    argv = _annotate_argv(build_pod_command("u/d", "main", ["--job", "job.yaml", "--seed=7"]))
-    assert "--job" not in argv
-    assert "job.yaml" not in argv
-    assert argv[-1] == "--job.target=local"
-
-
-def test_submit_dispatches_job(monkeypatch):
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: "tok")
-    monkeypatch.setattr("lerobot.jobs.annotate.HfApi", lambda token=None: MagicMock())
-    monkeypatch.setattr("lerobot.jobs.annotate.ensure_dataset_available", lambda *a, **kw: None)
-
-    run_job_calls = []
-
-    def fake_run_job(**kwargs):
-        run_job_calls.append(kwargs)
-        return MagicMock(id="job-123")
-
-    monkeypatch.setattr("lerobot.jobs.annotate.run_job", fake_run_job)
-    _set_argv(monkeypatch, "--repo_id=u/d", "--push_to_hub=true", "--job.target=h200", "--job.detach=true")
-
-    cfg = _parse("--repo_id", "u/d", "--push_to_hub", "true", "--job.target", "h200", "--job.detach", "true")
-    submit_annotate_to_hf(cfg)
-
-    assert len(run_job_calls) == 1
-    call = run_job_calls[0]
-    assert call["flavor"] == "h200"
-    assert call["image"] == DEFAULT_ANNOTATE_JOB_IMAGE
-    assert call["timeout"] == "2h"
-    # The Hub token is forwarded so the pod can pull a private dataset and push the result.
-    assert call["secrets"]["HF_TOKEN"] == "tok"
-    assert call["labels"].get("lerobot") == "true"
-    argv = _annotate_argv(call["command"])
-    assert argv[0] == "lerobot-annotate"
-    assert "--push_to_hub=true" in argv
-
-
-@pytest.mark.timeout(15)
-def test_submit_follows_job_to_completion(monkeypatch, capsys):
-    """Non-detach path must stream logs and RETURN (not hang) once the job is terminal.
-
-    Exercises the `follow_job` helper shared with the training submitter from the
-    annotation side, which is why the job-state patches target `lerobot.jobs.hf`.
-    Asserting on the completion message and not merely on "didn't hang" is what makes
-    this fail if `follow_job` ever reports detached-without-a-verdict instead.
-    """
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: "tok")
-    monkeypatch.setattr("lerobot.jobs.annotate.HfApi", lambda token=None: MagicMock())
-    monkeypatch.setattr("lerobot.jobs.annotate.ensure_dataset_available", lambda *a, **kw: None)
-    monkeypatch.setattr("lerobot.jobs.annotate.run_job", lambda **kw: MagicMock(id="job-1", url="http://x"))
-    monkeypatch.setattr(
-        "lerobot.jobs.hf.inspect_job",
-        lambda job_id: MagicMock(status=MagicMock(stage=MagicMock(value="COMPLETED"), message=None)),
-    )
-    monkeypatch.setattr("lerobot.jobs.hf.fetch_job_logs", lambda job_id, follow=True: iter(()))
-    _set_argv(monkeypatch, "--repo_id=u/d", "--job.target=h200")
-
-    submit_annotate_to_hf(_parse("--repo_id", "u/d", "--push_to_hub", "true", "--job.target", "h200"))
-    assert "Annotation complete" in capsys.readouterr().out
-
-
-@pytest.mark.timeout(15)
-def test_submit_raises_when_job_fails(monkeypatch):
-    """A job that ends in a non-COMPLETED stage must surface as an error, not a silent return."""
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: "tok")
-    monkeypatch.setattr("lerobot.jobs.annotate.HfApi", lambda token=None: MagicMock())
-    monkeypatch.setattr("lerobot.jobs.annotate.ensure_dataset_available", lambda *a, **kw: None)
-    monkeypatch.setattr("lerobot.jobs.annotate.run_job", lambda **kw: MagicMock(id="job-1", url=None))
-    monkeypatch.setattr(
-        "lerobot.jobs.hf.inspect_job",
-        lambda job_id: MagicMock(status=MagicMock(stage=MagicMock(value="ERROR"), message="Job timeout")),
-    )
-    monkeypatch.setattr("lerobot.jobs.hf.fetch_job_logs", lambda job_id, follow=True: iter(()))
-    _set_argv(monkeypatch, "--repo_id=u/d", "--job.target=h200")
-
-    with pytest.raises(RuntimeError, match="stage=ERROR .Job timeout."):
-        submit_annotate_to_hf(_parse("--repo_id", "u/d", "--job.target", "h200"))
-
-
-def test_submit_ensures_dataset_is_on_the_hub(monkeypatch):
-    """A local-only dataset is pushed (privately) before the job can reach it by repo_id."""
-    monkeypatch.setattr("lerobot.jobs.annotate.get_token", lambda: "tok")
-    monkeypatch.setattr("lerobot.jobs.annotate.HfApi", lambda token=None: MagicMock())
-    monkeypatch.setattr("lerobot.jobs.annotate.run_job", lambda **kw: MagicMock(id="job-1"))
-
-    seen = []
-    monkeypatch.setattr(
-        "lerobot.jobs.annotate.ensure_dataset_available",
-        lambda repo_id, *, api, tags=None: seen.append((repo_id, tags)),
-    )
-    _set_argv(monkeypatch, "--repo_id=u/d", "--job.target=h200", "--job.detach=true")
-
-    submit_annotate_to_hf(
-        _parse("--repo_id", "u/d", "--job.target", "h200", "--job.detach", "true", "--job.tags", '["lelab"]')
-    )
-    assert seen == [("u/d", ["lerobot", "lelab"])]

tests/jobs/test_hf.py

@@ -29,26 +29,12 @@ from lerobot.jobs.hf import (
     _poll_until_done,
     build_remote_config_file,
     build_repo_id,
-    follow_job,
     resolve_job_tags,
     resolve_wandb_api_key,
     submit_to_hf,
 )
 
 
-def test_follow_job_detach_returns_without_watching(monkeypatch):
-    """`detach` must short-circuit before any polling or log streaming starts."""
-
-    def _boom(*a, **kw):
-        raise AssertionError("detach must not touch the job")
-
-    monkeypatch.setattr("lerobot.jobs.hf.inspect_job", _boom)
-    monkeypatch.setattr("lerobot.jobs.hf.fetch_job_logs", _boom)
-    # False = "stopped watching without a verdict", so callers stay quiet rather than
-    # claiming success for a job that is still running.
-    assert follow_job("job-1", detach=True) is False
-
-
 def test_resolve_job_tags_always_includes_lerobot_and_dedups():
     assert resolve_job_tags(None) == ["lerobot"]
     assert resolve_job_tags([]) == ["lerobot"]

tests/motors/test_dynamixel.py

@@ -405,18 +405,12 @@ def test_record_ranges_of_motion(mock_motors, dummy_motors):
     read_pos_stub = mock_motors.build_sequential_sync_read_stub(
         *X_SERIES_CONTROL_TABLE["Present_Position"], positions
     )
-    bus = DynamixelMotorsBus(port=mock_motors.port, motors=dummy_motors)
-    bus.connect(handshake=False)
+    with patch("lerobot.motors.motors_bus.enter_pressed", side_effect=[False, True]):
+        bus = DynamixelMotorsBus(port=mock_motors.port, motors=dummy_motors)
+        bus.connect(handshake=False)
 
-    with (
-        patch("lerobot.motors.motors_bus.enter_pressed", side_effect=[False, True]),
-        patch("lerobot.motors.motors_bus.time.sleep") as mock_sleep,
-        patch.object(bus, "sync_read", wraps=bus.sync_read) as mock_sync_read,
-    ):
         mins, maxes = bus.record_ranges_of_motion(display_values=False)
 
     assert mock_motors.stubs[read_pos_stub].calls == 3
-    assert all(call.kwargs["num_retry"] == 5 for call in mock_sync_read.call_args_list)
-    mock_sleep.assert_called_once_with(0.02)
     assert mins == expected_mins
     assert maxes == expected_maxes

tests/motors/test_feetech.py

@@ -509,18 +509,12 @@ def test_record_ranges_of_motion(mock_motors, dummy_motors):
     stub = mock_motors.build_sequential_sync_read_stub(
         *STS_SMS_SERIES_CONTROL_TABLE["Present_Position"], positions
     )
-    bus = FeetechMotorsBus(port=mock_motors.port, motors=dummy_motors)
-    bus.connect(handshake=False)
+    with patch("lerobot.motors.motors_bus.enter_pressed", side_effect=[False, True]):
+        bus = FeetechMotorsBus(port=mock_motors.port, motors=dummy_motors)
+        bus.connect(handshake=False)
 
-    with (
-        patch("lerobot.motors.motors_bus.enter_pressed", side_effect=[False, True]),
-        patch("lerobot.motors.motors_bus.time.sleep") as mock_sleep,
-        patch.object(bus, "sync_read", wraps=bus.sync_read) as mock_sync_read,
-    ):
         mins, maxes = bus.record_ranges_of_motion(display_values=False)
 
     assert mock_motors.stubs[stub].calls == 3
-    assert all(call.kwargs["num_retry"] == 5 for call in mock_sync_read.call_args_list)
-    mock_sleep.assert_called_once_with(0.02)
     assert mins == expected_mins
     assert maxes == expected_maxes

tests/policies/rtc/test_action_queue.py

@@ -457,8 +457,9 @@ def test_merge_validates_delay_consistency(action_queue_rtc_enabled, sample_acti
         action_index_before_inference=0,
     )
 
-    # Check warning was logged
-    assert "Indexes diff is not equal to real delay" in caplog.text
+    # Check warning was logged (reworded when the discard clamp was added)
+    assert "Indexes diff != real delay" in caplog.text
+    assert "clamping discard" in caplog.text
 
 
 def test_merge_no_warning_when_delays_match(action_queue_rtc_enabled, sample_actions, caplog):
@@ -790,8 +791,12 @@ def test_typical_rtc_workflow(action_queue_rtc_enabled, sample_actions):
 
     assert action_queue_rtc_enabled.qsize() == 40
 
-    # Second inference with delay
+    # Second inference with delay. Capture the index at inference *start*, then consume
+    # `real_delay` actions to simulate the robot executing during inference, so the
+    # measured `indexes_diff` matches `real_delay` and the discard clamp is a no-op.
     action_index_before = action_queue_rtc_enabled.get_action_index()
+    for _ in range(5):
+        action_queue_rtc_enabled.get()
 
     action_queue_rtc_enabled.merge(
         sample_actions["original"],

tests/policies/test_factory_peft_revision.py

@@ -1,79 +0,0 @@
-# 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 sys
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-import torch
-
-import lerobot.policies.factory as policy_factory
-
-
-def test_make_policy_keeps_peft_adapter_and_base_revisions_separate(monkeypatch):
-    cfg = SimpleNamespace(
-        type="mock",
-        device="cpu",
-        pretrained_path="user/adapter",
-        pretrained_revision="adapter-sha",
-        use_peft=True,
-        input_features={},
-        output_features={},
-    )
-    dataset_meta = SimpleNamespace(features={}, stats={})
-
-    base_policy = torch.nn.Linear(1, 1)
-    policy_from_pretrained = MagicMock(return_value=base_policy)
-    policy_class = SimpleNamespace(from_pretrained=policy_from_pretrained)
-    monkeypatch.setattr(policy_factory, "get_policy_class", lambda _: policy_class)
-    monkeypatch.setattr(policy_factory, "dataset_to_policy_features", lambda _: {})
-    monkeypatch.setattr(policy_factory, "validate_visual_features_consistency", lambda *args: None)
-
-    peft_config = SimpleNamespace(
-        base_model_name_or_path="user/base-policy",
-        revision="base-sha",
-    )
-    peft_config_from_pretrained = MagicMock(return_value=peft_config)
-    adapted_policy = torch.nn.Linear(1, 1)
-    peft_model_from_pretrained = MagicMock(return_value=adapted_policy)
-    monkeypatch.setitem(
-        sys.modules,
-        "peft",
-        SimpleNamespace(
-            PeftConfig=SimpleNamespace(from_pretrained=peft_config_from_pretrained),
-            PeftModel=SimpleNamespace(from_pretrained=peft_model_from_pretrained),
-        ),
-    )
-
-    policy = policy_factory.make_policy(cfg, ds_meta=dataset_meta)
-
-    assert policy is adapted_policy
-    peft_config_from_pretrained.assert_called_once_with(
-        "user/adapter",
-        revision="adapter-sha",
-    )
-    policy_from_pretrained.assert_called_once_with(
-        config=cfg,
-        dataset_stats=dataset_meta.stats,
-        dataset_meta=dataset_meta,
-        pretrained_name_or_path="user/base-policy",
-        revision="base-sha",
-    )
-    peft_model_from_pretrained.assert_called_once_with(
-        base_policy,
-        "user/adapter",
-        config=peft_config,
-        revision="adapter-sha",
-        is_trainable=True,
-    )

tests/policies/test_gaussian_actor_config.py

@@ -113,7 +113,6 @@ def test_gaussian_actor_config_default_initialization():
     # Concurrency configuration
     assert config.concurrency.actor == "threads"
     assert config.concurrency.learner == "threads"
-    assert config.concurrency.multiprocessing_context == "spawn"
 
     assert isinstance(config.actor_network_kwargs, ActorNetworkConfig)
     assert isinstance(config.policy_kwargs, PolicyConfig)
@@ -153,7 +152,6 @@ def test_concurrency_config():
     config = ConcurrencyConfig()
     assert config.actor == "threads"
     assert config.learner == "threads"
-    assert config.multiprocessing_context == "spawn"
 
 
 def test_gaussian_actor_config_custom_initialization():

tests/processor/test_pipeline_from_pretrained_helpers.py

@@ -26,17 +26,8 @@ import tempfile
 from pathlib import Path
 
 import pytest
-import torch
-from safetensors.torch import save_file
 
-from lerobot.configs import PipelineFeatureType, PolicyFeature
-from lerobot.processor.pipeline import (
-    DataProcessorPipeline,
-    ProcessorMigrationError,
-    ProcessorStep,
-    ProcessorStepRegistry,
-)
-from lerobot.types import EnvTransition
+from lerobot.processor.pipeline import DataProcessorPipeline, ProcessorMigrationError
 
 # Simplified Config Loading Tests
 
@@ -107,140 +98,6 @@ def test_load_config_nonexistent_path_tries_hub():
         DataProcessorPipeline._load_config("nonexistent/path", "processor.json", {})
 
 
-def test_from_pretrained_local_directory_missing_state_does_not_call_hub(monkeypatch):
-    """Local processor dirs must fail locally when a state file is missing."""
-
-    @ProcessorStepRegistry.register("local_missing_state_step")
-    class LocalMissingStateStep(ProcessorStep):
-        def __call__(self, transition: EnvTransition) -> EnvTransition:
-            return transition
-
-        def transform_features(
-            self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-        ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-            return features
-
-        def load_state_dict(self, state: dict[str, torch.Tensor]) -> None:
-            pass
-
-    try:
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            tmp_path = Path(tmp_dir)
-            config = {
-                "name": "LocalMissingStatePipeline",
-                "steps": [{"registry_name": "local_missing_state_step", "state_file": "missing.safetensors"}],
-            }
-            (tmp_path / "processor.json").write_text(json.dumps(config))
-
-            def fail_hub_download(*args, **kwargs):
-                pytest.fail("local missing processor state should not call hf_hub_download")
-
-            monkeypatch.setattr("lerobot.processor.pipeline.hf_hub_download", fail_hub_download)
-
-            with pytest.raises(FileNotFoundError, match="missing.safetensors.*local processor pipeline"):
-                DataProcessorPipeline.from_pretrained(tmp_path, config_filename="processor.json")
-    finally:
-        ProcessorStepRegistry.unregister("local_missing_state_step")
-
-
-def test_from_pretrained_local_config_file_missing_state_does_not_call_hub(monkeypatch):
-    """Local single-file processor configs must also keep missing state resolution local."""
-
-    @ProcessorStepRegistry.register("local_file_missing_state_step")
-    class LocalFileMissingStateStep(ProcessorStep):
-        def __call__(self, transition: EnvTransition) -> EnvTransition:
-            return transition
-
-        def transform_features(
-            self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-        ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-            return features
-
-        def load_state_dict(self, state: dict[str, torch.Tensor]) -> None:
-            pass
-
-    try:
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            tmp_path = Path(tmp_dir)
-            config_path = tmp_path / "processor.json"
-            config = {
-                "name": "LocalFileMissingStatePipeline",
-                "steps": [
-                    {"registry_name": "local_file_missing_state_step", "state_file": "missing.safetensors"}
-                ],
-            }
-            config_path.write_text(json.dumps(config))
-
-            def fail_hub_download(*args, **kwargs):
-                pytest.fail("local missing processor state should not call hf_hub_download")
-
-            monkeypatch.setattr("lerobot.processor.pipeline.hf_hub_download", fail_hub_download)
-
-            with pytest.raises(FileNotFoundError, match="missing.safetensors.*local processor pipeline"):
-                DataProcessorPipeline.from_pretrained(config_path, config_filename="ignored.json")
-    finally:
-        ProcessorStepRegistry.unregister("local_file_missing_state_step")
-
-
-def test_from_pretrained_hub_source_missing_local_state_still_calls_hub(monkeypatch, tmp_path):
-    """Hub sources still fall back to hf_hub_download for state files."""
-
-    @ProcessorStepRegistry.register("hub_state_step")
-    class HubStateStep(ProcessorStep):
-        def __init__(self):
-            self.value = torch.tensor(0)
-
-        def __call__(self, transition: EnvTransition) -> EnvTransition:
-            return transition
-
-        def transform_features(
-            self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-        ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-            return features
-
-        def load_state_dict(self, state: dict[str, torch.Tensor]) -> None:
-            self.value = state["value"]
-
-    try:
-        state_path = tmp_path / "downloaded.safetensors"
-        save_file({"value": torch.tensor(7)}, state_path)
-        loaded_config = {
-            "name": "HubStatePipeline",
-            "steps": [{"registry_name": "hub_state_step", "state_file": "hub_state.safetensors"}],
-        }
-        calls = []
-
-        def fake_load_config(cls, model_id, config_filename, hub_download_kwargs):
-            return loaded_config, tmp_path / "hub_cache"
-
-        def fake_hub_download(**kwargs):
-            calls.append(kwargs)
-            return str(state_path)
-
-        monkeypatch.setattr(DataProcessorPipeline, "_load_config", classmethod(fake_load_config))
-        monkeypatch.setattr("lerobot.processor.pipeline.hf_hub_download", fake_hub_download)
-
-        pipeline = DataProcessorPipeline.from_pretrained("user/repo", config_filename="processor.json")
-
-        assert calls == [
-            {
-                "repo_id": "user/repo",
-                "filename": "hub_state.safetensors",
-                "repo_type": "model",
-                "force_download": False,
-                "resume_download": None,
-                "proxies": None,
-                "token": None,
-                "cache_dir": None,
-                "local_files_only": False,
-                "revision": None,
-            }
-        ]
-        assert pipeline.steps[0].value.item() == 7
-    finally:
-        ProcessorStepRegistry.unregister("hub_state_step")
-
-
 # Config Validation Tests
 
 

tests/robots/test_so100_follower.py

@@ -109,22 +109,3 @@ def test_send_action(follower):
 
     goal_pos = {m: (i + 1) * 10 for i, m in enumerate(follower.bus.motors)}
     follower.bus.sync_write.assert_called_once_with("Goal_Position", goal_pos)
-
-
-def test_configure_writes_position_pid_coefficients():
-    bus_mock = _make_bus_mock()
-    bus_mock.motors = ["shoulder_pan"]
-    robot = MagicMock()
-    robot.bus = bus_mock
-    robot.config = SO100FollowerConfig(
-        port="/dev/null",
-        position_p_coefficient=32,
-        position_i_coefficient=1,
-        position_d_coefficient=16,
-    )
-
-    SO100Follower.configure(robot)
-
-    bus_mock.write.assert_any_call("P_Coefficient", "shoulder_pan", 32)
-    bus_mock.write.assert_any_call("I_Coefficient", "shoulder_pan", 1)
-    bus_mock.write.assert_any_call("D_Coefficient", "shoulder_pan", 16)

tests/scripts/test_setup_motors.py

@@ -1,49 +0,0 @@
-# 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.
-
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-import pytest
-
-import lerobot.scripts.lerobot_setup_motors as motors_module
-
-
-def test_main_registers_plugins_before_parsing(monkeypatch):
-    calls = []
-    monkeypatch.setattr(motors_module, "register_third_party_plugins", lambda: calls.append("register"))
-    monkeypatch.setattr(motors_module, "setup_motors", lambda: calls.append("setup"))
-
-    motors_module.main()
-
-    assert calls == ["register", "setup"]
-
-
-def test_setup_motors_accepts_third_party_device(monkeypatch):
-    device = MagicMock()
-    monkeypatch.setattr(motors_module, "make_teleoperator_from_config", lambda _: device)
-    cfg = SimpleNamespace(device=SimpleNamespace(type="third_party"))
-
-    motors_module.setup_motors.__wrapped__(cfg)
-
-    device.setup_motors.assert_called_once_with()
-
-
-def test_setup_motors_reports_unsupported_device(monkeypatch):
-    device = object()
-    monkeypatch.setattr(motors_module, "make_teleoperator_from_config", lambda _: device)
-    cfg = SimpleNamespace(device=SimpleNamespace(type="third_party"))
-
-    with pytest.raises(NotImplementedError, match="third_party"):
-        motors_module.setup_motors.__wrapped__(cfg)

tests/test_rollout.py

@@ -17,8 +17,6 @@
 from __future__ import annotations
 
 import dataclasses
-import sys
-from types import SimpleNamespace
 from unittest.mock import MagicMock
 
 import pytest
@@ -108,116 +106,6 @@ def test_sentry_config_defaults():
     assert cfg.target_video_file_size_mb is None
 
 
-def test_rollout_config_passes_policy_pretrained_revision(monkeypatch):
-    from lerobot.configs import PreTrainedConfig, parser
-    from lerobot.rollout import RolloutConfig
-    from tests.mocks.mock_robot import MockRobotConfig
-
-    captured = {}
-
-    def fake_from_pretrained(cls, pretrained_name_or_path, **kwargs):
-        captured["pretrained_name_or_path"] = pretrained_name_or_path
-        captured.update(kwargs)
-        return SimpleNamespace(device="cpu", pretrained_revision=kwargs["revision"])
-
-    monkeypatch.setattr(parser, "get_yaml_overrides", lambda _: ["--pretrained_revision=yaml-sha"])
-    monkeypatch.setattr(
-        sys,
-        "argv",
-        ["lerobot-rollout", "--policy.path=user/policy", "--policy.pretrained_revision=cli-sha"],
-    )
-    monkeypatch.setattr(PreTrainedConfig, "from_pretrained", classmethod(fake_from_pretrained))
-
-    cfg = RolloutConfig(robot=MockRobotConfig())
-
-    assert captured["pretrained_name_or_path"] == "user/policy"
-    assert captured["revision"] == "cli-sha"
-    assert captured["cli_overrides"] == [
-        "--pretrained_revision=yaml-sha",
-        "--pretrained_revision=cli-sha",
-    ]
-    assert cfg.policy.pretrained_path == "user/policy"
-    assert cfg.policy.pretrained_revision == "cli-sha"
-
-
-def test_load_pretrained_policy_passes_revision(monkeypatch):
-    import lerobot.rollout.context as rollout_context
-
-    policy_config = SimpleNamespace(
-        type="mock",
-        use_peft=False,
-        pretrained_path="user/policy",
-        pretrained_revision="policy-sha",
-    )
-    policy_class = MagicMock()
-    loaded_policy = MagicMock()
-    policy_class.from_pretrained.return_value = loaded_policy
-    monkeypatch.setattr(rollout_context, "get_policy_class", lambda _: policy_class)
-
-    policy = rollout_context._load_pretrained_policy(policy_config)
-
-    assert policy is loaded_policy
-    policy_class.from_pretrained.assert_called_once_with(
-        "user/policy",
-        config=policy_config,
-        revision="policy-sha",
-    )
-
-
-def test_load_pretrained_peft_policy_keeps_adapter_and_base_revisions_separate(monkeypatch):
-    import lerobot.rollout.context as rollout_context
-
-    policy_config = SimpleNamespace(
-        type="mock",
-        use_peft=True,
-        pretrained_path="user/adapter",
-        pretrained_revision="adapter-sha",
-    )
-    policy_class = MagicMock()
-    base_policy = MagicMock()
-    policy_class.from_pretrained.return_value = base_policy
-    monkeypatch.setattr(rollout_context, "get_policy_class", lambda _: policy_class)
-
-    peft_config = SimpleNamespace(
-        base_model_name_or_path="user/base-policy",
-        revision="base-sha",
-    )
-    peft_config_from_pretrained = MagicMock(return_value=peft_config)
-    adapted_policy = MagicMock()
-    peft_model_from_pretrained = MagicMock(return_value=adapted_policy)
-    require_package = MagicMock()
-    monkeypatch.setattr(rollout_context, "require_package", require_package)
-    monkeypatch.setattr(
-        rollout_context,
-        "PeftConfig",
-        SimpleNamespace(from_pretrained=peft_config_from_pretrained),
-        raising=False,
-    )
-    monkeypatch.setattr(
-        rollout_context,
-        "PeftModel",
-        SimpleNamespace(from_pretrained=peft_model_from_pretrained),
-        raising=False,
-    )
-
-    policy = rollout_context._load_pretrained_policy(policy_config)
-
-    assert policy is adapted_policy
-    require_package.assert_called_once_with("peft", extra="peft")
-    peft_config_from_pretrained.assert_called_once_with("user/adapter", revision="adapter-sha")
-    policy_class.from_pretrained.assert_called_once_with(
-        pretrained_name_or_path="user/base-policy",
-        config=policy_config,
-        revision="base-sha",
-    )
-    peft_model_from_pretrained.assert_called_once_with(
-        base_policy,
-        "user/adapter",
-        config=peft_config,
-        revision="adapter-sha",
-    )
-
-
 # ---------------------------------------------------------------------------
 # RolloutRingBuffer
 # ---------------------------------------------------------------------------
@@ -363,6 +251,69 @@ def test_create_inference_engine_sync():
     assert isinstance(engine, SyncInferenceEngine)
 
 
+# ---------------------------------------------------------------------------
+# RTC action-key ordering and prefix padding
+# ---------------------------------------------------------------------------
+
+
+def test_rtc_get_action_remaps_model_order_to_ordered_action_keys():
+    """RTC must remap the model-order action vector to ``ordered_action_keys`` by NAME
+    before returning — matching sync. Otherwise the strategy maps model outputs onto the
+    wrong joints (a per-joint permutation) whenever the two orders differ."""
+    from lerobot.rollout import RTCInferenceConfig, RTCInferenceEngine, create_inference_engine
+    from lerobot.utils.constants import ACTION
+
+    # The model emits actions in dataset order [a, b, c]; the robot wants [c, a, b].
+    dataset_action_names = ["a.pos", "b.pos", "c.pos"]
+    ordered_action_keys = ["c.pos", "a.pos", "b.pos"]
+    dataset_features = {
+        ACTION: {"dtype": "float32", "shape": (3,), "names": dataset_action_names},
+    }
+
+    engine = create_inference_engine(
+        RTCInferenceConfig(),
+        policy=MagicMock(),
+        preprocessor=MagicMock(steps=[]),
+        postprocessor=MagicMock(steps=[]),
+        robot_wrapper=MagicMock(robot_type="mock"),
+        hw_features={},
+        dataset_features=dataset_features,
+        ordered_action_keys=ordered_action_keys,
+        task="test",
+        fps=30.0,
+        device="cpu",
+    )
+    assert isinstance(engine, RTCInferenceEngine)
+
+    # Queue yields the model-order vector a=1, b=2, c=3.
+    engine._action_queue = MagicMock()
+    engine._action_queue.get.return_value = torch.tensor([1.0, 2.0, 3.0])
+
+    out = engine.get_action(None)
+    # Remapped by name to [c, a, b] = [3, 1, 2]; positional pass-through would give [1, 2, 3].
+    torch.testing.assert_close(out, torch.tensor([3.0, 1.0, 2.0]))
+
+
+def test_normalize_prev_actions_length_holds_last_action_not_zeros():
+    """A short RTC prefix is padded by repeating the last action, never with zeros —
+    zeros decode to the mean action and cause the intermittent chunk-seam spike."""
+    from lerobot.rollout.inference.rtc import _normalize_prev_actions_length
+
+    prev = torch.tensor([[1.0, -1.0], [2.0, -2.0]])  # 2 steps, dim 2
+
+    # Pad up to 5: rows 2..4 must equal the last real row, not zeros.
+    padded = _normalize_prev_actions_length(prev, target_steps=5)
+    assert padded.shape == (5, 2)
+    torch.testing.assert_close(padded[:2], prev)
+    for i in range(2, 5):
+        torch.testing.assert_close(padded[i], prev[-1])
+    assert not torch.any(padded[2:] == 0.0), "pad rows must not be zeros"
+
+    # Exact length: unchanged. Truncation: first `target_steps` rows.
+    torch.testing.assert_close(_normalize_prev_actions_length(prev, 2), prev)
+    torch.testing.assert_close(_normalize_prev_actions_length(prev, 1), prev[:1])
+
+
 # ---------------------------------------------------------------------------
 # Pure functions
 # ---------------------------------------------------------------------------