feat(kiwi): excluding LeKiwi from depth support (for now)

docs/source/cheat-sheet.mdx

@@ -89,36 +89,6 @@ Control the data recording flow using keyboard shortcuts:
 - Press **Left Arrow (`←`)**: Delete current episode and retry.
 - Press **Escape (`ESC`)**: Stop, encode videos, and upload.
 
-### Recording depth
-
-Intel RealSense cameras (`type: intelrealsense`) record a depth stream when you set `use_depth: true`. Depth is quantized to 12-bit codes and stored as its own video.
-
-```bash
-lerobot-record \
-    ... \
-    --robot.cameras="{ head: {type: intelrealsense, serial_number_or_name: \"0123456789\", width: 640, height: 480, fps: 30, use_depth: true} }" \
-    --dataset.repo_id=${HF_USER}/so101_depth_test \
-    --dataset.single_task="put the red brick in a bowl" \
-    --dataset.depth_encoder.depth_min=0.01 \
-    --dataset.depth_encoder.depth_max=10.0 \
-    --dataset.depth_encoder.shift=0.0 \
-    --dataset.depth_encoder.use_log=true
-```
-
-### Video encoding parameters
-
-RGB and depth streams are encoded independently via the `--dataset.rgb_encoder.*` and `--dataset.depth_encoder.*` keys.
-
-```bash
-lerobot-record \
-    ... \
-    --dataset.rgb_encoder.vcodec=h264 \
-    --dataset.rgb_encoder.pix_fmt=yuv420p \
-    --dataset.rgb_encoder.crf=23 \
-    --dataset.depth_encoder.vcodec=hevc \
-    --dataset.depth_encoder.extra_options='{"x265-params": "lossless=1"}'
-```
-
 ### Training
 
 Depending on your hardware training the policy might take a few hours. That's how you train simple `ACT` policy:

docs/source/pi0fast.mdx

@@ -96,7 +96,7 @@ lerobot-train \
     --policy.type=pi0_fast \
     --output_dir=./outputs/pi0fast_training \
     --job_name=pi0fast_training \
-    --policy.pretrained_path=lerobot/pi0fast-base \
+    --policy.pretrained_path=lerobot/pi0_fast_base \
     --policy.dtype=bfloat16 \
     --policy.gradient_checkpointing=true \
     --policy.chunk_size=10 \
@@ -187,7 +187,7 @@ lerobot-train \
   --dataset.repo_id=lerobot/libero \
   --output_dir=outputs/libero_pi0fast \
   --job_name=libero_pi0fast \
-  --policy.path=lerobot/pi0fast-base \
+  --policy.path=lerobot/pi0fast_base \
   --policy.dtype=bfloat16 \
   --steps=100000 \
   --save_freq=20000 \

docs/source/using_dataset_tools.mdx

@@ -181,8 +181,8 @@ lerobot-edit-dataset \
 lerobot-edit-dataset \
     --repo_id lerobot/pusht_depth \
     --operation.type reencode_videos \
-    --operation.rgb_encoder.vcodec h264 \
-    --operation.depth_encoder.crf 50
+    --operation.rgb_encoder.vcodec libx264 \
+    --operation.depth_encoder.vcodec ffv1
 ```
 
 **Parameters:**

docs/source/video_encoding_parameters.mdx

@@ -100,15 +100,14 @@ lerobot-record \
     --dataset.depth_encoder.use_log=true
 ```
 
-| Parameter       | Type    | Default                         | Description                                                                                                                            |
-| --------------- | ------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| `vcodec`        | `str`   | `"hevc"`                        | HEVC Main 12 (a 12-bit-capable codec, MP4-compatible).                                                                                 |
-| `extra_options` | `dict`  | `{"x265-params": "lossless=1"}` | **Depth defaults to lossless** (exact round-trip); `crf` is ignored. Pass `extra_options={}` and set `crf` for a smaller lossy stream. |
-| `pix_fmt`       | `str`   | `"gray12le"`                    | Single-channel 12-bit pixel format used to carry the quantized codes.                                                                  |
-| `depth_min`     | `float` | `0.01`                          | Depth in metres mapped to quantum `0`. Values below are clipped on decode.                                                             |
-| `depth_max`     | `float` | `10.0`                          | Depth in metres mapped to quantum `4095`. Values above are clipped on decode.                                                          |
-| `shift`         | `float` | `3.5`                           | Pre-log offset (metres) used in logarithmic quantization for numerical stability near zero. Must satisfy `depth_min + shift > 0`.      |
-| `use_log`       | `bool`  | `True`                          | If `true`, quantize in log-space (recommended for typical depth sensors). Set to `false` for uniform/linear quantization.              |
+| Parameter   | Type    | Default      | Description                                                                                                                       |
+| ----------- | ------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------- |
+| `vcodec`    | `str`   | `"hevc"`     | Defaults to HEVC Main 12 (a 12-bit-capable codec). `ffv1` is a lossless alternative.                                              |
+| `pix_fmt`   | `str`   | `"gray12le"` | Single-channel 12-bit pixel format used to carry the quantized codes.                                                             |
+| `depth_min` | `float` | `0.01`       | Depth in metres mapped to quantum `0`. Values below are clipped on decode.                                                        |
+| `depth_max` | `float` | `10.0`       | Depth in metres mapped to quantum `4095`. Values above are clipped on decode.                                                     |
+| `shift`     | `float` | `3.5`        | Pre-log offset (metres) used in logarithmic quantization for numerical stability near zero. Must satisfy `depth_min + shift > 0`. |
+| `use_log`   | `bool`  | `True`       | If `true`, quantize in log-space (recommended for typical depth sensors). Set to `false` for uniform/linear quantization.         |
 
 > [!TIP]
 > `depth_min`, `depth_max`, and `shift` are always interpreted in **metres**, regardless of the input depth's unit. Inputs are auto-detected: integer arrays (e.g. `uint16` millimetres straight from a RealSense) are treated as millimetres, floating arrays as metres.

pyproject.toml

@@ -140,14 +140,7 @@ av-dep = ["av>=15.0.0,<16.0.0"]
 pygame-dep = ["pygame>=2.5.1,<2.7.0"]
 # NOTE: 0.9.16 links against liburdfdom_sensor.so.4, which is unavailable on Ubuntu 24.04
 # (noble ships urdfdom 3.x). Cap below 0.9.16 until system urdfdom 4.x is broadly available.
-#
-# NOTE: placo pulls in pin (Pinocchio), whose binary wheels dlopen specific cmeel sonames
-# (liburdfdom_sensor.so.4.0, libtinyxml2.so.10) but declare only `>=` floors on their cmeel
-# packages. The 2026-05-21 major bumps (cmeel-urdfdom 6.0.0 -> .so.6, cmeel-tinyxml2 11.0.0
-# -> .so.11) ship newer sonames, so left unpinned the resolver grabs them and `import placo`
-# fails at load with "liburdfdom_sensor.so.4.0: cannot open shared object file" (see #3755).
-# There is no cmeel-urdfdom 5.x; <5 selects the 4.x ABI the placo/pin wheels are built against.
-placo-dep = ["placo>=0.9.6,<0.9.16", "cmeel-urdfdom>=4,<5", "cmeel-tinyxml2<11"]
+placo-dep = ["placo>=0.9.6,<0.9.16"]
 transformers-dep = ["transformers>=5.4.0,<5.6.0"]
 grpcio-dep = ["grpcio>=1.73.1,<2.0.0", "protobuf>=6.31.1,<8.0.0"]
 accelerate-dep = ["accelerate>=1.14.0,<2.0.0"]

src/lerobot/configs/default.py

@@ -82,17 +82,8 @@ class EvalConfig:
     # `use_async_envs` specifies whether to use asynchronous environments (multiprocessing).
     # Defaults to True; automatically downgraded to SyncVectorEnv when batch_size=1.
     use_async_envs: bool = True
-    # Whether to record eval rollouts as a LeRobot dataset on disk.
-    recording: bool = False
-    # If set, push recorded eval datasets to the Hub under this repo id (one repo per task,
-    # suffixed by task and env index). Requires recording=true.
-    recording_repo_id: str | None = None
-    # Whether the pushed recording repositories should be private.
-    recording_private: bool = False
 
     def __post_init__(self) -> None:
-        if self.recording_repo_id is not None and not self.recording:
-            raise ValueError("eval.recording_repo_id requires eval.recording=true.")
         if self.batch_size == 0:
             self.batch_size = self._auto_batch_size()
         if self.batch_size > self.n_episodes:

src/lerobot/configs/video.py

@@ -36,7 +36,9 @@ HW_VIDEO_CODECS = [
     "h264_vaapi",  # Linux Intel/AMD
     "h264_qsv",  # Intel Quick Sync
 ]
-VALID_VIDEO_CODECS: frozenset[str] = frozenset({"h264", "hevc", "libsvtav1", "auto", *HW_VIDEO_CODECS})
+VALID_VIDEO_CODECS: frozenset[str] = frozenset(
+    {"h264", "hevc", "libsvtav1", "ffv1", "auto", *HW_VIDEO_CODECS}
+)
 # Aliases for legacy video codec names.
 VIDEO_CODECS_ALIASES: dict[str, str] = {"av1": "libsvtav1"}
 
@@ -232,6 +234,10 @@ class VideoEncoderConfig:
         elif self.vcodec == "h264_qsv":
             set_if("global_quality", self.crf)
             set_if("preset", self.preset)
+        elif self.vcodec == "ffv1":
+            # Lossless intra-frame codec. ``crf``/``preset``/``fast_decode``
+            # are not meaningful.
+            set_if("threads", encoder_threads)
         else:
             set_if("crf", self.crf)
             set_if("preset", self.preset)
@@ -270,9 +276,8 @@ class DepthEncoderConfig(VideoEncoderConfig):
     ``"gray12le"``.
     """
 
-    vcodec: str = "hevc"  # Video codec name. Defaults to HEVC Main 12 (a 12-bit-capable codec).
-    pix_fmt: str = "gray12le"  # Pixel format. Defaults to 12-bit grayscale.
-    extra_options: dict[str, Any] = field(default_factory=lambda: {"x265-params": "lossless=1"})
+    vcodec: str = "hevc"
+    pix_fmt: str = "gray12le"
 
     depth_min: float = DEFAULT_DEPTH_MIN  # Minimum depth in meters, mapped to the lowest quantum.
     depth_max: float = DEFAULT_DEPTH_MAX  # Maximum depth in meters, mapped to the highest quantum.

src/lerobot/datasets/dataset_reader.py

@@ -324,9 +324,8 @@ class DatasetReader:
             item = {**video_frames, **item}
 
         if self._image_transforms is not None:
-            for cam in self._meta.camera_keys:
-                if cam in self._meta.depth_keys:
-                    continue
+            image_keys = self._meta.camera_keys
+            for cam in image_keys:
                 item[cam] = self._image_transforms(item[cam])
 
         # Add task as a string

src/lerobot/datasets/depth_utils.py

@@ -79,7 +79,7 @@ def quantize_depth(
 
     Depth maps are packed into 12-bit integer frames so they fit in standard
     high-bit-depth pixel formats (e.g. ``yuv420p12le`` / ``gray12le``)
-    and can be encoded by widely supported video codecs (e.g. HEVC Main 12).
+    and can be encoded by widely supported video codecs (HEVC Main 12, ffv1).
     Logarithmic quantization is the default because it allocates more quanta
     to near-range depth, which matches the (1/depth) error profile of typical
     depth sensors. Math is ported from BEHAVIOR-1K's ``obs_utils.py``.

src/lerobot/scripts/lerobot_edit_dataset.py

@@ -224,8 +224,8 @@ Re-encode both RGB and depth videos in a dataset (depth quantization params are
     lerobot-edit-dataset \
         --repo_id lerobot/pusht_depth \
         --operation.type reencode_videos \
-        --operation.rgb_encoder.vcodec h264 \
-        --operation.depth_encoder.extra_options '{"x265-params": "lossless=1"}'
+        --operation.rgb_encoder.vcodec libx264 \
+        --operation.depth_encoder.vcodec ffv1
 
 Using JSON config file:
     lerobot-edit-dataset \

src/lerobot/scripts/lerobot_eval.py

@@ -72,9 +72,8 @@ from termcolor import colored
 from torch import Tensor, nn
 from tqdm import trange
 
-from lerobot.configs import FeatureType, parser
+from lerobot.configs import parser
 from lerobot.configs.eval import EvalPipelineConfig
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.envs import (
     check_env_attributes_and_types,
     close_envs,
@@ -85,7 +84,7 @@ from lerobot.envs import (
 from lerobot.policies import PreTrainedPolicy, make_policy, make_pre_post_processors
 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.constants import ACTION, DONE, OBS_STR, REWARD
 from lerobot.utils.device_utils import get_safe_torch_device
 from lerobot.utils.import_utils import register_third_party_plugins
 from lerobot.utils.io_utils import write_video
@@ -96,65 +95,6 @@ from lerobot.utils.utils import (
 )
 
 
-def _env_features_to_dataset_features(env_features: dict) -> dict:
-    """Convert EnvConfig.features to the dict format expected by LeRobotDataset.create()."""
-    features = {}
-    for key, ft in env_features.items():
-        shape = tuple(ft.shape)
-        if ft.type is FeatureType.VISUAL:
-            features[key] = {"dtype": "video", "shape": shape, "names": ["height", "width", "channel"]}
-        else:
-            features[key] = {"dtype": "float32", "shape": shape, "names": None}
-    features["next.reward"] = {"dtype": "float32", "shape": (1,), "names": None}
-    features["next.success"] = {"dtype": "bool", "shape": (1,), "names": None}
-    features["next.done"] = {"dtype": "bool", "shape": (1,), "names": None}
-    return features
-
-
-def _build_raw_frame(
-    raw_obs: dict,
-    env_idx: int,
-    action: np.ndarray,
-    reward: float,
-    success: bool,
-    done: bool,
-    task: str,
-    env_features: dict,
-) -> dict:
-    """Build a dataset frame from raw env observations for one env index.
-
-    Keys in the frame match the keys in env_features so they align with the
-    dataset schema created by _env_features_to_dataset_features().
-    """
-    frame: dict[str, Any] = {}
-    for key in env_features:
-        if key == ACTION:
-            continue
-        if key.startswith("next."):
-            continue
-        if "pixels" in raw_obs and isinstance(raw_obs["pixels"], dict):
-            for cam_name, img in raw_obs["pixels"].items():
-                candidate = f"{OBS_IMAGES}.{cam_name}"
-                if candidate == key:
-                    frame[key] = img[env_idx]
-            if key in frame:
-                continue
-        if "pixels" in raw_obs and not isinstance(raw_obs["pixels"], dict) and key in ("pixels", OBS_IMAGE):
-            frame[key] = raw_obs["pixels"][env_idx]
-            continue
-        if key in raw_obs and isinstance(raw_obs[key], np.ndarray):
-            val = raw_obs[key][env_idx]
-            if val.dtype == np.float64:
-                val = val.astype(np.float32)
-            frame[key] = val
-    frame[ACTION] = action
-    frame["next.reward"] = np.atleast_1d(np.float32(reward))
-    frame["next.success"] = np.atleast_1d(np.bool_(success))
-    frame["next.done"] = np.atleast_1d(np.bool_(done))
-    frame["task"] = task
-    return frame
-
-
 def rollout(
     env: gym.vector.VectorEnv,
     policy: PreTrainedPolicy,
@@ -165,10 +105,6 @@ def rollout(
     seeds: list[int] | None = None,
     return_observations: bool = False,
     render_callback: Callable[[gym.vector.VectorEnv], None] | None = None,
-    recording_dir: Path | None = None,
-    env_features: dict | None = None,
-    recording_repo_id: str | None = None,
-    recording_private: bool = False,
 ) -> dict:
     """Run a batched policy rollout once through a batch of environments.
 
@@ -209,33 +145,6 @@ def rollout(
     if render_callback is not None:
         render_callback(env)
 
-    recording_datasets: list[LeRobotDataset] | None = None
-    raw_observation = None
-    task_desc = ""
-    if recording_dir is not None and env_features is not None:
-        features = _env_features_to_dataset_features(env_features)
-        fps = env.unwrapped.metadata.get("render_fps", 30)
-        recording_datasets = []
-        multi_env = env.num_envs > 1
-        base_repo_id = recording_repo_id or "eval_recording"
-        for i in range(env.num_envs):
-            root = str(recording_dir / f"env_{i}") if multi_env else str(recording_dir)
-            repo_id = f"{base_repo_id}_env_{i}" if multi_env else base_repo_id
-            recording_datasets.append(
-                LeRobotDataset.create(
-                    repo_id=repo_id,
-                    fps=fps,
-                    features=features,
-                    root=root,
-                    use_videos=True,
-                )
-            )
-        raw_observation = deepcopy(observation)
-        try:
-            task_desc = list(env.call("task_description"))[0]
-        except (AttributeError, NotImplementedError):
-            task_desc = ""
-
     all_observations = []
     all_actions = []
     all_rewards = []
@@ -253,112 +162,80 @@ def rollout(
         leave=False,
     )
     check_env_attributes_and_types(env)
-    try:
-        while not np.all(done) and step < max_steps:
-            # Numpy array to tensor and changing dictionary keys to LeRobot policy format.
-            observation = preprocess_observation(observation)
-            if return_observations:
-                all_observations.append(deepcopy(observation))
+    while not np.all(done) and step < max_steps:
+        # Numpy array to tensor and changing dictionary keys to LeRobot policy format.
+        observation = preprocess_observation(observation)
+        if return_observations:
+            all_observations.append(deepcopy(observation))
 
-            # Infer "task" from sub-environments (prefer natural language description).
-            # env.call() works with both SyncVectorEnv and AsyncVectorEnv.
+        # Infer "task" from sub-environments (prefer natural language description).
+        # env.call() works with both SyncVectorEnv and AsyncVectorEnv.
+        try:
+            observation["task"] = list(env.call("task_description"))
+        except (AttributeError, NotImplementedError):
             try:
-                observation["task"] = list(env.call("task_description"))
+                observation["task"] = list(env.call("task"))
             except (AttributeError, NotImplementedError):
-                try:
-                    observation["task"] = list(env.call("task"))
-                except (AttributeError, NotImplementedError):
-                    observation["task"] = [""] * env.num_envs
+                observation["task"] = [""] * env.num_envs
 
-            # Apply environment-specific preprocessing (e.g., LiberoProcessorStep for LIBERO)
-            observation = env_preprocessor(observation)
+        # Apply environment-specific preprocessing (e.g., LiberoProcessorStep for LIBERO)
+        observation = env_preprocessor(observation)
 
-            observation = preprocessor(observation)
-            with torch.inference_mode():
-                action = policy.select_action(observation)
-            action = postprocessor(action)
+        observation = preprocessor(observation)
+        with torch.inference_mode():
+            action = policy.select_action(observation)
+        action = postprocessor(action)
 
-            action_transition = {ACTION: action}
-            action_transition = env_postprocessor(action_transition)
-            action = action_transition[ACTION]
+        action_transition = {ACTION: action}
+        action_transition = env_postprocessor(action_transition)
+        action = action_transition[ACTION]
 
-            # Convert to CPU / numpy.
-            action_numpy: np.ndarray = action.to("cpu").numpy()
-            assert action_numpy.ndim == 2, "Action dimensions should be (batch, action_dim)"
+        # Convert to CPU / numpy.
+        action_numpy: np.ndarray = action.to("cpu").numpy()
+        assert action_numpy.ndim == 2, "Action dimensions should be (batch, action_dim)"
 
-            # Apply the next action.
-            observation, reward, terminated, truncated, info = env.step(action_numpy)
-            if render_callback is not None:
-                render_callback(env)
+        # Apply the next action.
+        observation, reward, terminated, truncated, info = env.step(action_numpy)
+        if render_callback is not None:
+            render_callback(env)
 
-            # VectorEnv stores is_success in `info["final_info"][env_index]["is_success"]`. "final_info" isn't
-            # available if none of the envs finished.
-            if "final_info" in info:
-                final_info = info["final_info"]
-                if not isinstance(final_info, dict):
-                    raise RuntimeError(
-                        "Unsupported `final_info` format: expected dict (Gymnasium >= 1.0). "
-                        "You're likely using an older version of gymnasium (< 1.0). Please upgrade."
-                    )
-                successes = final_info["is_success"].tolist()
-            elif "is_success" in info:
-                is_success = info["is_success"]
-                successes = (
-                    is_success.tolist()
-                    if hasattr(is_success, "tolist")
-                    else [bool(is_success)] * env.num_envs
+        # VectorEnv stores is_success in `info["final_info"][env_index]["is_success"]`. "final_info" isn't
+        # available if none of the envs finished.
+        if "final_info" in info:
+            final_info = info["final_info"]
+            if not isinstance(final_info, dict):
+                raise RuntimeError(
+                    "Unsupported `final_info` format: expected dict (Gymnasium >= 1.0). "
+                    "You're likely using an older version of gymnasium (< 1.0). Please upgrade."
                 )
-            else:
-                successes = [False] * env.num_envs
-
-            if recording_datasets is not None and raw_observation is not None:
-                prev_done = done.copy()
-                for env_idx in range(env.num_envs):
-                    if prev_done[env_idx]:
-                        continue
-                    frame = _build_raw_frame(
-                        raw_observation,
-                        env_idx,
-                        action_numpy[env_idx],
-                        reward[env_idx],
-                        successes[env_idx],
-                        bool(terminated[env_idx] | truncated[env_idx]),
-                        task_desc,
-                        recording_datasets[env_idx].features,
-                    )
-                    recording_datasets[env_idx].add_frame(frame)
-                    if terminated[env_idx] or truncated[env_idx]:
-                        recording_datasets[env_idx].save_episode()
-                raw_observation = deepcopy(observation)
-
-            # Keep track of which environments are done so far.
-            # Mark the episode as done if we reach the maximum step limit.
-            # This ensures that the rollout always terminates cleanly at `max_steps`,
-            # and allows logging/saving (e.g., videos) to be triggered consistently.
-            done = terminated | truncated | done
-            if step + 1 == max_steps:
-                done = np.ones_like(done, dtype=bool)
-
-            all_actions.append(torch.from_numpy(action_numpy))
-            all_rewards.append(torch.from_numpy(reward))
-            all_dones.append(torch.from_numpy(done))
-            all_successes.append(torch.tensor(successes))
-
-            step += 1
-            running_success_rate = (
-                einops.reduce(torch.stack(all_successes, dim=1), "b n -> b", "any").numpy().mean()
+            successes = final_info["is_success"].tolist()
+        elif "is_success" in info:
+            is_success = info["is_success"]
+            successes = (
+                is_success.tolist() if hasattr(is_success, "tolist") else [bool(is_success)] * env.num_envs
             )
-            progbar.set_postfix({"running_success_rate": f"{running_success_rate.item() * 100:.1f}%"})
-            progbar.update()
-    finally:
-        if recording_datasets is not None:
-            for ds in recording_datasets:
-                ds.finalize()
-                if recording_repo_id is not None:
-                    if ds.num_episodes > 0:
-                        ds.push_to_hub(private=recording_private)
-                    else:
-                        logging.warning("No episodes recorded for %s — skipping push to hub.", ds.repo_id)
+        else:
+            successes = [False] * env.num_envs
+
+        # Keep track of which environments are done so far.
+        # Mark the episode as done if we reach the maximum step limit.
+        # This ensures that the rollout always terminates cleanly at `max_steps`,
+        # and allows logging/saving (e.g., videos) to be triggered consistently.
+        done = terminated | truncated | done
+        if step + 1 == max_steps:
+            done = np.ones_like(done, dtype=bool)
+
+        all_actions.append(torch.from_numpy(action_numpy))
+        all_rewards.append(torch.from_numpy(reward))
+        all_dones.append(torch.from_numpy(done))
+        all_successes.append(torch.tensor(successes))
+
+        step += 1
+        running_success_rate = (
+            einops.reduce(torch.stack(all_successes, dim=1), "b n -> b", "any").numpy().mean()
+        )
+        progbar.set_postfix({"running_success_rate": f"{running_success_rate.item() * 100:.1f}%"})
+        progbar.update()
 
     # Track the final observation.
     if return_observations:
@@ -396,10 +273,6 @@ def eval_policy(
     videos_dir: Path | None = None,
     return_episode_data: bool = False,
     start_seed: int | None = None,
-    recording_dir: Path | None = None,
-    env_features: dict | None = None,
-    recording_repo_id: str | None = None,
-    recording_private: bool = False,
 ) -> dict:
     """
     Args:
@@ -488,10 +361,6 @@ def eval_policy(
             seeds=list(seeds) if seeds else None,
             return_observations=return_episode_data,
             render_callback=render_frame if max_episodes_rendered > 0 else None,
-            recording_dir=recording_dir,
-            env_features=env_features,
-            recording_repo_id=recording_repo_id,
-            recording_private=recording_private,
         )
 
         # Figure out where in each rollout sequence the first done condition was encountered (results after
@@ -694,10 +563,6 @@ def eval_main(cfg: EvalPipelineConfig):
     # Create environment-specific preprocessor and postprocessor (e.g., for LIBERO environments)
     env_preprocessor, env_postprocessor = make_env_pre_post_processors(env_cfg=cfg.env, policy_cfg=cfg.policy)
 
-    recording_dir = Path(cfg.output_dir) / "recordings" if cfg.eval.recording else None
-    max_episodes_rendered = 0 if cfg.eval.recording else 10
-    videos_dir = None if cfg.eval.recording else Path(cfg.output_dir) / "videos"
-
     with torch.no_grad(), torch.autocast(device_type=device.type) if cfg.policy.use_amp else nullcontext():
         info = eval_policy_all(
             envs=envs,
@@ -707,15 +572,10 @@ def eval_main(cfg: EvalPipelineConfig):
             preprocessor=preprocessor,
             postprocessor=postprocessor,
             n_episodes=cfg.eval.n_episodes,
-            max_episodes_rendered=max_episodes_rendered,
-            videos_dir=videos_dir,
-            return_episode_data=False,
+            max_episodes_rendered=10,
+            videos_dir=Path(cfg.output_dir) / "videos",
             start_seed=cfg.seed,
             max_parallel_tasks=cfg.env.max_parallel_tasks,
-            recording_dir=recording_dir,
-            env_features=cfg.env.features if cfg.eval.recording else None,
-            recording_repo_id=cfg.eval.recording_repo_id,
-            recording_private=cfg.eval.recording_private,
         )
         print("Overall Aggregated Metrics:")
         print(info["overall"])
@@ -758,10 +618,6 @@ def eval_one(
     videos_dir: Path | None,
     return_episode_data: bool,
     start_seed: int | None,
-    recording_dir: Path | None = None,
-    env_features: dict | None = None,
-    recording_repo_id: str | None = None,
-    recording_private: bool = False,
 ) -> TaskMetrics:
     """Evaluates one task_id of one suite using the provided vec env."""
 
@@ -779,10 +635,6 @@ def eval_one(
         videos_dir=task_videos_dir,
         return_episode_data=return_episode_data,
         start_seed=start_seed,
-        recording_dir=recording_dir,
-        env_features=env_features,
-        recording_repo_id=recording_repo_id,
-        recording_private=recording_private,
     )
 
     per_episode = task_result["per_episode"]
@@ -809,10 +661,6 @@ def run_one(
     videos_dir: Path | None,
     return_episode_data: bool,
     start_seed: int | None,
-    recording_dir: Path | None = None,
-    env_features: dict | None = None,
-    recording_repo_id: str | None = None,
-    recording_private: bool = False,
 ):
     """
     Run eval_one for a single (task_group, task_id, env).
@@ -824,13 +672,7 @@ def run_one(
         task_videos_dir = videos_dir / f"{task_group}_{task_id}"
         task_videos_dir.mkdir(parents=True, exist_ok=True)
 
-    task_recording_dir = None
-    task_repo_id = None
-    if recording_dir is not None and env_features is not None:
-        task_recording_dir = recording_dir / f"{task_group}_{task_id}"
-        if recording_repo_id is not None:
-            task_repo_id = f"{recording_repo_id}_{task_group}_{task_id}"
-
+    # Call the existing eval_one (assumed to return TaskMetrics-like dict)
     metrics = eval_one(
         env,
         policy=policy,
@@ -843,12 +685,8 @@ def run_one(
         videos_dir=task_videos_dir,
         return_episode_data=return_episode_data,
         start_seed=start_seed,
-        recording_dir=task_recording_dir,
-        env_features=env_features,
-        recording_repo_id=task_repo_id,
-        recording_private=recording_private,
     )
-
+    # ensure we always provide video_paths key to simplify accumulation
     if max_episodes_rendered > 0:
         metrics.setdefault("video_paths", [])
     return task_group, task_id, metrics
@@ -864,10 +702,6 @@ def eval_policy_all(
     n_episodes: int,
     *,
     max_episodes_rendered: int = 0,
-    recording_dir: Path | None = None,
-    env_features: dict | None = None,
-    recording_repo_id: str | None = None,
-    recording_private: bool = False,
     videos_dir: Path | None = None,
     return_episode_data: bool = False,
     start_seed: int | None = None,
@@ -927,10 +761,6 @@ def eval_policy_all(
         videos_dir=videos_dir,
         return_episode_data=return_episode_data,
         start_seed=start_seed,
-        recording_dir=recording_dir,
-        env_features=env_features,
-        recording_repo_id=recording_repo_id,
-        recording_private=recording_private,
     )
 
     if max_parallel_tasks <= 1:

tests/annotations/test_frames.py

@@ -47,7 +47,6 @@ class _FakeMeta:
     def __init__(self, video_keys: list[str], image_keys: list[str], video_path: Path | None = None) -> None:
         self.video_keys = video_keys
         self.camera_keys = [*video_keys, *image_keys]
-        self.depth_keys = []
         self._video_path = video_path
         self.episodes = {0: {f"videos/{key}/from_timestamp": 0.0 for key in video_keys}}
 

tests/datasets/test_datasets.py

@@ -1531,6 +1531,7 @@ def test_valid_video_codecs_constant():
     assert "h264" in VALID_VIDEO_CODECS
     assert "hevc" in VALID_VIDEO_CODECS
     assert "libsvtav1" in VALID_VIDEO_CODECS
+    assert "ffv1" in VALID_VIDEO_CODECS
     assert "auto" in VALID_VIDEO_CODECS
     assert "h264_videotoolbox" in VALID_VIDEO_CODECS
     assert "h264_nvenc" in VALID_VIDEO_CODECS
@@ -1538,7 +1539,7 @@ def test_valid_video_codecs_constant():
     assert "h264_qsv" in VALID_VIDEO_CODECS
     assert "hevc_videotoolbox" in VALID_VIDEO_CODECS
     assert "hevc_nvenc" in VALID_VIDEO_CODECS
-    assert len(VALID_VIDEO_CODECS) == 10
+    assert len(VALID_VIDEO_CODECS) == 11
 
 
 def test_delta_timestamps_with_episodes_filter(tmp_path, empty_lerobot_dataset_factory):

tests/datasets/test_image_writer.py

@@ -344,7 +344,7 @@ def test_with_different_image_formats(tmp_path, img_array_factory):
     writer = AsyncImageWriter()
     try:
         image_array = img_array_factory()
-        formats = ["png", "tiff", "tif"]
+        formats = ["png", "jpeg", "bmp"]
         for fmt in formats:
             fpath = tmp_path / f"test_image.{fmt}"
             write_image(image_array, fpath)

tests/datasets/test_video_encoding.py

@@ -730,7 +730,6 @@ class TestEncodeDepthVideoFrames:
             pix_fmt="gray12le",
             g=4,
             crf=25,
-            extra_options={},
             depth_min=0.05,
             depth_max=8.0,
             shift=2.5,
@@ -778,7 +777,6 @@ class TestDepthEncoderConfigPersistence:
             pix_fmt="gray12le",
             g=2,
             crf=30,
-            extra_options={},
             depth_min=0.05,
             depth_max=8.0,
             shift=2.5,

tests/scripts/test_edit_dataset_parsing.py

@@ -123,15 +123,15 @@ class TestDepthEncoderParsing:
                 "test/repo",
                 "--operation.type",
                 "reencode_videos",
-                "--operation.depth_encoder.extra_options",
-                '{"x265-params": "lossless=1"}',
+                "--operation.depth_encoder.vcodec",
+                "ffv1",
                 "--operation.depth_encoder.depth_max",
                 "12.0",
                 "--operation.depth_encoder.use_log",
                 "false",
             ]
         )
-        assert cfg.operation.depth_encoder.extra_options == {"x265-params": "lossless=1"}
+        assert cfg.operation.depth_encoder.vcodec == "ffv1"
         assert cfg.operation.depth_encoder.depth_max == 12.0
         assert cfg.operation.depth_encoder.use_log is False
 

uv.lock

@@ -768,46 +768,34 @@ wheels = [
 
 [[package]]
 name = "cmeel-tinyxml2"
-version = "10.0.0"
+version = "11.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cmeel" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/28/9f/030eca702c485f7a641f975f167fa93164911b3329f005fb0730ff5e793f/cmeel_tinyxml2-10.0.0.tar.gz", hash = "sha256:00252aefc1c94a55b89f25ad08ee79fda2da8d1d94703e051598ddb52a9088fe", size = 645297, upload-time = "2025-02-06T10:29:00.106Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/96/4311533fee0a364bb605b585762f04c249f47857b33548a8ea837a7eb860/cmeel_tinyxml2-11.0.0.tar.gz", hash = "sha256:85d9c7680b3369af4c6b40a0dce70bbd84aa67832755622e57eb260cd95abe40", size = 645900, upload-time = "2026-05-21T11:49:32.652Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/5d/bc3a932eb7996a0a789979426a9bb8a3948bf57f3f17bab87dddbef62433/cmeel_tinyxml2-10.0.0-0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:924499bb1b60b9a17bd001d12a9af88ddbee4ca888638ae684ba7f0f3ce49e87", size = 111913, upload-time = "2025-02-06T10:28:45.723Z" },
-    { url = "https://files.pythonhosted.org/packages/92/bf/67d11e123313c034712896e94038291fe506bb099bdb75a136392002ffd0/cmeel_tinyxml2-10.0.0-0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:26a1eb30c2a00bfc172e89ed015a18b8efb2b383546252ca8859574aed684686", size = 109487, upload-time = "2025-02-06T10:28:47.546Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/48/d8c81ce19b4b278ed0e8f81f93ae8670209bf3a9ac20141b9c386bb40cc7/cmeel_tinyxml2-10.0.0-0-py3-none-manylinux_2_17_i686.whl", hash = "sha256:53d86e02864c712f51f9a9adfcd8b6046b2ed51d44a0c34a8438d93b72b48325", size = 160118, upload-time = "2025-02-06T10:28:49.627Z" },
-    { url = "https://files.pythonhosted.org/packages/87/4e/62193e27c9581f8ba7aeaeca7805632a64f2f4a824b1db37ad02ee953e8a/cmeel_tinyxml2-10.0.0-0-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:74112e2e9473afbf6ee2d25c9942553e9f6a40465e714533db72db48bc7658e1", size = 158477, upload-time = "2025-02-06T10:28:51.667Z" },
-    { url = "https://files.pythonhosted.org/packages/14/f9/d0420c39e9ade99beeec61cd3abc68880fe6e14d85e9df292af8fabe65c8/cmeel_tinyxml2-10.0.0-0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:ecd6e99caa2a06ac0d4b333b740c20fca526d0ca426f99eb5c0a0039117afdb6", size = 147025, upload-time = "2025-02-06T10:28:53.944Z" },
-    { url = "https://files.pythonhosted.org/packages/66/9e/df63147fc162ab487217fa5596778ab7a81a82d9b3ce4236fd3a1e48cecb/cmeel_tinyxml2-10.0.0-0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:30993fffb7032a45d5d3b1e5670cb879dad667a13144cd68c8f4e0371a8a3d2e", size = 150958, upload-time = "2025-02-06T10:28:55.301Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/a8/b03567275fd83f5af33ddb61de942689dec72c5b21bec01e6a5b11101aa5/cmeel_tinyxml2-10.0.0-0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:8c09ede51784af54211a6225884dc7ddbb02ea1681656d173060c7ad2a5b9a3c", size = 160300, upload-time = "2025-02-06T10:28:57.189Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/ec/2781635b66c1059ca1243ae0f5a0410e171a5d8b8a71be3e34cb172f9f2d/cmeel_tinyxml2-10.0.0-0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3bd511d6d0758224efdebc23d3ead6e94f0755b04141ebf7d5493377829e8332", size = 149184, upload-time = "2025-02-06T10:28:58.734Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f0/90c1640c53b623359d75ab1c70bdf19dc0afe82722bc5df57d09f8eaf83a/cmeel_tinyxml2-11.0.0-0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:b0bd974e549b8c444626671a8e645897603ebf5225734cbe04a9dd3461477754", size = 111719, upload-time = "2026-05-21T11:49:25.999Z" },
+    { url = "https://files.pythonhosted.org/packages/56/40/166447150a31bc3b794ffb493d5a634f67ffbc75dd8b4c46373701b7ef15/cmeel_tinyxml2-11.0.0-0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9a1406f408262c37ae7c4566b1d67801c4b10c4980903fb1ef0ba45fa4407072", size = 109146, upload-time = "2026-05-21T11:49:27.829Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/ca/3cc665afe2d76999f15454bb3b2f7c05f0088ad7de35718648291a536fd9/cmeel_tinyxml2-11.0.0-0-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:6f830007917c3e36f26b27d170ce84a619a62f46104d3cce435dff0125dd665f", size = 157109, upload-time = "2026-05-21T11:49:29.358Z" },
+    { url = "https://files.pythonhosted.org/packages/87/4e/dcc0d9756d93be734d824e2a570cc9ac68909a1d7d3b6fc87c2fb32726c0/cmeel_tinyxml2-11.0.0-0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:18674156bd41f3993dc1d5199da04fa496674358daa6588090fb9f86c71917b0", size = 148825, upload-time = "2026-05-21T11:49:31.035Z" },
 ]
 
 [[package]]
 name = "cmeel-urdfdom"
-version = "4.0.1"
+version = "6.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cmeel" },
     { name = "cmeel-console-bridge" },
     { name = "cmeel-tinyxml2" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/31/09/be81a5e7db56f34b6ccdbe7afe855c95a18c8439e173519e0146e9276a8c/cmeel_urdfdom-4.0.1.tar.gz", hash = "sha256:2e3f41e8483889e195b574acb326a4464cf11a3c0a8724031ac28bcda2223efc", size = 291511, upload-time = "2025-02-12T12:07:09.699Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/75/4e8aff079e98582aeeb8e752805081da0c2dea405e79bafeefb555defe9f/cmeel_urdfdom-6.0.0.tar.gz", hash = "sha256:65c0fdc6021300fc55b2d0c03ab64dedc328034a74e40498e671bc894bb1dcf7", size = 303688, upload-time = "2026-05-21T12:08:56.663Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/d0/20147dd6bb723afc44a58d89ea624df2bad1bed7b898a2df112aaca4a479/cmeel_urdfdom-4.0.1-0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:2fe56939c6b47f6ec57021aac154123da47ecdcd79a217f3a5e3c4b705a07dee", size = 300860, upload-time = "2025-02-12T12:06:58.536Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/98/f832bca347e2d987c6b0ebb6930caf7b2c402535324aeed466b6aa2c4513/cmeel_urdfdom-4.0.1-0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:00a0aba78b68c428b27abeed1db58d73e65319ed966911a0e97b37367442e756", size = 300616, upload-time = "2025-02-12T12:07:00.556Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/10/bf5765b6f388037cff166a754a0958ac2fee34ca3c0975ef64d0324e4647/cmeel_urdfdom-4.0.1-0-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:a701a8f9671331f11b18ecf37a6537db546a21e6a0e5d0ff53341fea0693ed7f", size = 385951, upload-time = "2025-02-12T12:07:02.556Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/82/cb3f8f587d293a17bdbea15b50cdaa4a1e28e04583eb4cb4821685b89466/cmeel_urdfdom-4.0.1-0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:12e39fc388c077d79fc9b3841d3d972a1da90b90de754d3363194c1540e18abf", size = 399619, upload-time = "2025-02-12T12:07:04.388Z" },
-    { url = "https://files.pythonhosted.org/packages/24/77/322d7ac92c692d8dfaeda9de2d937087d15e2b564dc457d656e5fde3991d/cmeel_urdfdom-4.0.1-0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c4a83925df1d5923c4485c3eb2b80b3a61b14f119ab724fb5bd04cec494690ee", size = 373969, upload-time = "2025-02-12T12:07:06.222Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/63/bdc6b55cc8bd99bb9dce6be801b30feffaa1c3841ecb7f4fe4d137424518/cmeel_urdfdom-4.0.1-0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:4c4f44270971b3d05c45a4e21b1fb2df7e05a750363ae918f59532bff0bfe0e1", size = 388237, upload-time = "2025-02-12T12:07:08.326Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/2d/8463fc23230612daf4da1e31d3229f47708381f3ae4d1500f0f007ac0f92/cmeel_urdfdom-4.0.1-1-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:f7535158f45992eb2ba79e90d9db1bf9adc3846d9c7ed3e7a8c1c4d5343afa37", size = 301006, upload-time = "2025-02-13T11:42:08.8Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/d5/c8cdf500e49300d85624cbc3ef804107ddcdc9c541b1d3f726bfb58a9fc1/cmeel_urdfdom-4.0.1-1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fef2a01a00d61d41b3d35dd4958bba973e9025c26eea1d3c9880932f4dba89a5", size = 300758, upload-time = "2025-02-13T11:42:10.449Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/b3/2f7bac1544113a7f8e0f6d8b1fab5e75c6a3d27ffbb584b03267251b2165/cmeel_urdfdom-4.0.1-1-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:7a52eb36950ce982014d99a55717ca29985da056e3705f20746f15d3244c1f7a", size = 386043, upload-time = "2025-02-13T11:42:11.923Z" },
-    { url = "https://files.pythonhosted.org/packages/86/03/8bdeb36ba6a3e8125d523ecfc010403049e463fe589f9896858d4bdcaf1e/cmeel_urdfdom-4.0.1-1-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:9f3b9c80b10d7246821ff61c2573f799e3da23d483e6f7367ddcad8a48baf58f", size = 399719, upload-time = "2025-02-13T11:42:14.325Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/ed/43f99e7512460294cd8acc5753ba25f8a20bdf28d62e143eaf3ec7a28bb6/cmeel_urdfdom-4.0.1-1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2de69f47e8312cc09157624802d5bdaad6406443f863fb4b9ec62a19b4de3c72", size = 374073, upload-time = "2025-02-13T11:42:17.907Z" },
-    { url = "https://files.pythonhosted.org/packages/17/c6/2e9bde6d7c02c1cf203ea896f8ce1afd441412f09b44830f1ee4a96d77de/cmeel_urdfdom-4.0.1-1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7708c1402de450fbeab21f7ca264a9a4676ed4c1cdf8d84d840bc5d057aac920", size = 388337, upload-time = "2025-02-13T11:42:19.657Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/40/51ba667135f01631179eee1614557193f8453740f248302d1b8b7f9f693e/cmeel_urdfdom-6.0.0-0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:53d55cebb137a6e4dac6c16fa53f2dc2b7b9b5cda644bd1637a5bb849cd96e52", size = 381501, upload-time = "2026-05-21T12:08:48.758Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/d1/2b49a8c940fa75abc13df9842c14e577e6a82d5854b6d52597ce3bb04894/cmeel_urdfdom-6.0.0-0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0ef424735bd30f4afa4d1b4ddca9b297498c43005ddd775c080e55f62e9e0466", size = 377159, upload-time = "2026-05-21T12:08:50.485Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ac/0efde3a48220b55707bafb6d2e2dcca562f99dcd5c2c15311f7696eeacce/cmeel_urdfdom-6.0.0-0-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:0436f5230f1484c8e583284ef48c7291b230ada3dc5fb2937941f582e72409ec", size = 506000, upload-time = "2026-05-21T12:08:52.273Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d4/dfd617e598100e4e53ae3d228a968facff80bae53038fb18e2dccb1ab03a/cmeel_urdfdom-6.0.0-0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:7ab1be680a8ec866d5422c617b641d1f0e38774061df28b8b426fb26edce6337", size = 530049, upload-time = "2026-05-21T12:08:54.224Z" },
 ]
 
 [[package]]
@@ -1159,7 +1147,7 @@ name = "decord"
 version = "0.6.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "(platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin') or (platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "numpy", marker = "(platform_machine != 'arm64' and sys_platform == 'darwin') or (platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/11/79/936af42edf90a7bd4e41a6cac89c913d4b47fa48a26b042d5129a9242ee3/decord-0.6.0-py3-none-manylinux2010_x86_64.whl", hash = "sha256:51997f20be8958e23b7c4061ba45d0efcd86bffd5fe81c695d0befee0d442976", size = 13602299, upload-time = "2021-06-14T21:30:55.486Z" },
@@ -2800,8 +2788,6 @@ accelerate-dep = [
 all = [
     { name = "accelerate" },
     { name = "av" },
-    { name = "cmeel-tinyxml2" },
-    { name = "cmeel-urdfdom" },
     { name = "contourpy" },
     { name = "datasets" },
     { name = "debugpy" },
@@ -2985,8 +2971,6 @@ hardware = [
 ]
 hilserl = [
     { name = "av" },
-    { name = "cmeel-tinyxml2" },
-    { name = "cmeel-urdfdom" },
     { name = "datasets" },
     { name = "grpcio" },
     { name = "gym-hil" },
@@ -3009,8 +2993,6 @@ intelrealsense = [
     { name = "pyrealsense2-macosx", marker = "sys_platform == 'darwin'" },
 ]
 kinematics = [
-    { name = "cmeel-tinyxml2" },
-    { name = "cmeel-urdfdom" },
     { name = "placo" },
 ]
 lekiwi = [
@@ -3084,8 +3066,6 @@ pi = [
     { name = "transformers" },
 ]
 placo-dep = [
-    { name = "cmeel-tinyxml2" },
-    { name = "cmeel-urdfdom" },
     { name = "placo" },
 ]
 pusht = [
@@ -3206,8 +3186,6 @@ requires-dist = [
     { name = "accelerate", marker = "extra == 'accelerate-dep'", specifier = ">=1.14.0,<2.0.0" },
     { name = "av", marker = "extra == 'av-dep'", specifier = ">=15.0.0,<16.0.0" },
     { name = "cmake", specifier = ">=3.29.0.1,<4.2.0" },
-    { name = "cmeel-tinyxml2", marker = "extra == 'placo-dep'", specifier = "<11" },
-    { name = "cmeel-urdfdom", marker = "extra == 'placo-dep'", specifier = ">=4,<5" },
     { name = "contourpy", marker = "extra == 'matplotlib-dep'", specifier = ">=1.3.0,<2.0.0" },
     { name = "datasets", marker = "extra == 'dataset'", specifier = ">=4.7.0,<5.0.0" },
     { name = "debugpy", marker = "extra == 'dev'", specifier = ">=1.8.1,<1.9.0" },