chore(deps): bump the uv group across 1 directory with 2 updates

Bumps the uv group with 2 updates in the / directory: [setuptools](https://github.com/pypa/setuptools) and [pytest](https://github.com/pytest-dev/pytest).


Updates `setuptools` from 80.10.2 to 83.0.0
- [Release notes](https://github.com/pypa/setuptools/releases)
- [Changelog](https://github.com/pypa/setuptools/blob/main/NEWS.rst)
- [Commits](https://github.com/pypa/setuptools/compare/v80.10.2...v83.0.0)

Updates `pytest` from 8.4.2 to 9.0.3
- [Release notes](https://github.com/pytest-dev/pytest/releases)
- [Changelog](https://github.com/pytest-dev/pytest/blob/main/CHANGELOG.rst)
- [Commits](https://github.com/pytest-dev/pytest/compare/8.4.2...9.0.3)

---
updated-dependencies:
- dependency-name: setuptools
  dependency-version: 83.0.0
  dependency-type: direct:development
  dependency-group: uv
- dependency-name: pytest
  dependency-version: 9.0.3
  dependency-type: direct:production
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>

docker/Dockerfile.internal

@@ -68,16 +68,17 @@ ENV HOME=/home/user_lerobot \
 # issues with MuJoCo and OpenGL drivers.
 RUN uv venv --python python${PYTHON_VERSION}
 
-# Install third-party dependencies separately for layer caching
+# Install Python dependencies for caching
 COPY --chown=user_lerobot:user_lerobot setup.py pyproject.toml uv.lock README.md MANIFEST.in ./
-RUN uv sync --locked --extra all --no-install-project --no-cache
+COPY --chown=user_lerobot:user_lerobot src/ src/
+
+RUN uv sync --locked --extra all --no-cache
 
 RUN chmod +x /lerobot/.venv/lib/python${PYTHON_VERSION}/site-packages/triton/backends/nvidia/bin/ptxas
 
-# Copy the application source code and install the local project
+# Copy the rest of the application source code
 # Make sure to have the git-LFS files for testing
 COPY --chown=user_lerobot:user_lerobot . .
-RUN uv sync --locked --extra all --no-cache
 
 # Set the default command
 CMD ["/bin/bash"]

docker/Dockerfile.user

@@ -60,14 +60,15 @@ ENV HOME=/home/user_lerobot \
 # run other Python projects in the same container without dependency conflicts.
 RUN uv venv
 
-# Install third-party dependencies separately for layer caching
+# Install Python dependencies for caching
 COPY --chown=user_lerobot:user_lerobot setup.py pyproject.toml uv.lock README.md MANIFEST.in ./
-RUN uv sync --locked --extra all --no-install-project --no-cache
+COPY --chown=user_lerobot:user_lerobot src/ src/
 
-# Copy the application code and install the local project
+RUN uv sync --locked --extra all --no-cache
+
+# Copy the rest of the application code
 # Make sure to have the git-LFS files for testing
 COPY --chown=user_lerobot:user_lerobot . .
-RUN uv sync --locked --extra all --no-cache
 
 # Set the default command
 CMD ["/bin/bash"]

pyproject.toml

@@ -14,7 +14,7 @@
 
 [build-system]
 requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
+build-backend = "setuptools*"
 
 [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,<81.0.0",
+    "setuptools>=71.0.0,<84.0.0",
 ]
 
 # Optional dependencies
@@ -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,<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'"]
+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'"]
 video_benchmark = ["scikit-image>=0.23.2,<0.26.0", "pandas>=2.2.2,<2.4.0"]
 
 # Simulation

src/lerobot/envs/libero.py

@@ -384,12 +384,7 @@ class LiberoEnv(gym.Env):
 
     def close(self):
         if self._env is not None:
-            try:
-                self._env.close()
-            finally:
-                # LIBERO deletes its inner env on close, so this wrapper must
-                # be recreated before the next reset.
-                self._env = None
+            self._env.close()
 
 
 def _make_env_fns(

src/lerobot/robots/so_follower/config_so_follower.py

@@ -46,12 +46,6 @@ class SOFollowerConfig:
     position_i_coefficient: int = 0
     position_d_coefficient: int = 32
 
-    # Number of extra attempts when a `sync_read` of the motors fails. Feetech buses can occasionally
-    # return a corrupted status packet ("Incorrect status packet!"), especially when several joints move
-    # at once, which otherwise aborts the control loop. Retries are immediate (no sleep) and only happen on
-    # failure, so the steady-state read cost is unchanged.
-    num_read_retries: int = 2
-
 
 @RobotConfig.register_subclass("so101_follower")
 @RobotConfig.register_subclass("so100_follower")

src/lerobot/robots/so_follower/so_follower.py

@@ -180,7 +180,7 @@ class SOFollower(Robot):
     def get_observation(self) -> RobotObservation:
         # Read arm position
         start = time.perf_counter()
-        obs_dict = self.bus.sync_read("Present_Position", num_retry=self.config.num_read_retries)
+        obs_dict = self.bus.sync_read("Present_Position")
         obs_dict = {f"{motor}.pos": val for motor, val in obs_dict.items()}
         dt_ms = (time.perf_counter() - start) * 1e3
         logger.debug(f"{self} read state: {dt_ms:.1f}ms")
@@ -221,7 +221,7 @@ class SOFollower(Robot):
         # Cap goal position when too far away from present position.
         # /!\ Slower fps expected due to reading from the follower.
         if self.config.max_relative_target is not None:
-            present_pos = self.bus.sync_read("Present_Position", num_retry=self.config.num_read_retries)
+            present_pos = self.bus.sync_read("Present_Position")
             goal_present_pos = {key: (g_pos, present_pos[key]) for key, g_pos in goal_pos.items()}
             goal_pos = ensure_safe_goal_position(goal_present_pos, self.config.max_relative_target)
 

src/lerobot/scripts/augment_dataset_quantile_stats.py

@@ -36,7 +36,6 @@ python src/lerobot/scripts/augment_dataset_quantile_stats.py \
 import argparse
 import concurrent.futures
 import logging
-import os
 from pathlib import Path
 
 import numpy as np
@@ -53,7 +52,6 @@ from lerobot.datasets import (
     get_feature_stats,
     write_stats,
 )
-from lerobot.datasets.compute_stats import sample_indices
 from lerobot.utils.utils import init_logging
 
 
@@ -79,14 +77,12 @@ def has_quantile_stats(stats: dict[str, dict] | None, quantile_list_keys: list[s
     return False
 
 
-def process_single_episode(dataset: LeRobotDataset, episode_idx: int, use_sampling: bool = True) -> dict:
+def process_single_episode(dataset: LeRobotDataset, episode_idx: int) -> dict:
     """Process a single episode and return its statistics.
 
     Args:
         dataset: The LeRobot dataset
         episode_idx: Index of the episode to process
-        use_sampling: If True, sub-sample image/video frames per episode to bound
-            memory. If False, use every frame (exact, higher memory).
 
     Returns:
         Dictionary containing episode statistics
@@ -96,31 +92,16 @@ def process_single_episode(dataset: LeRobotDataset, episode_idx: int, use_sampli
     start_idx = dataset.meta.episodes[episode_idx]["dataset_from_index"]
     end_idx = dataset.meta.episodes[episode_idx]["dataset_to_index"]
 
-    episode_len = end_idx - start_idx
-
-    # Images/video are the memory hog, so sub-sample those frames per episode;
-    # numeric columns are cheap, so read them in full (exact).
-    image_keys = [k for k in dataset.features if dataset.features[k]["dtype"] in ("image", "video")]
-    numeric_keys = [
-        k for k in dataset.features if dataset.features[k]["dtype"] not in ("image", "video", "string")
-    ]
-
     collected_data: dict[str, list] = {}
+    for idx in range(start_idx, end_idx):
+        item = dataset[idx]
+        for key, value in item.items():
+            if key not in dataset.features:
+                continue
 
-    # Numeric features: every frame, read directly from the underlying table.
-    if numeric_keys:
-        numeric_cols = dataset.hf_dataset.select_columns(numeric_keys)[start_idx:end_idx]
-        for key in numeric_keys:
-            collected_data[key] = [torch.as_tensor(v) for v in numeric_cols[key]]
-
-    # Image/video features: decode only a sampled subset of frames.
-    if image_keys:
-        sampled_offsets = sample_indices(episode_len) if use_sampling else list(range(episode_len))
-        for offset in sampled_offsets:
-            item = dataset[start_idx + offset]
-            for key in image_keys:
-                if key in item:
-                    collected_data.setdefault(key, []).append(item[key])
+            if key not in collected_data:
+                collected_data[key] = []
+            collected_data[key].append(value)
 
     ep_stats = {}
     for key, data_list in collected_data.items():
@@ -150,13 +131,11 @@ def process_single_episode(dataset: LeRobotDataset, episode_idx: int, use_sampli
     return ep_stats
 
 
-def compute_quantile_stats_for_dataset(dataset: LeRobotDataset, use_sampling: bool = True) -> dict[str, dict]:
+def compute_quantile_stats_for_dataset(dataset: LeRobotDataset) -> dict[str, dict]:
     """Compute quantile statistics for all episodes in the dataset.
 
     Args:
         dataset: The LeRobot dataset to compute statistics for
-        use_sampling: If True, sub-sample image/video frames per episode to bound
-            memory. If False, use every frame (exact, higher memory).
 
     Returns:
         Dictionary containing aggregated statistics with quantiles
@@ -174,15 +153,15 @@ def compute_quantile_stats_for_dataset(dataset: LeRobotDataset, use_sampling: bo
     if has_videos:
         logging.info("Dataset contains video keys - using sequential processing for thread safety")
         for episode_idx in tqdm(range(dataset.num_episodes), desc="Processing episodes"):
-            ep_stats = process_single_episode(dataset, episode_idx, use_sampling)
+            ep_stats = process_single_episode(dataset, episode_idx)
             episode_stats_list.append(ep_stats)
     else:
         logging.info("Dataset has no video keys - using parallel processing for better performance")
-        max_workers = min(dataset.num_episodes, int(os.environ.get("LEROBOT_STATS_MAX_WORKERS", 16)))
+        max_workers = min(dataset.num_episodes, 16)
 
         with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
             future_to_episode = {
-                executor.submit(process_single_episode, dataset, episode_idx, use_sampling): episode_idx
+                executor.submit(process_single_episode, dataset, episode_idx): episode_idx
                 for episode_idx in range(dataset.num_episodes)
             }
 
@@ -209,7 +188,6 @@ def augment_dataset_with_quantile_stats(
     repo_id: str,
     root: str | Path | None = None,
     overwrite: bool = False,
-    use_sampling: bool = True,
 ) -> None:
     """Augment a dataset with quantile statistics if they are missing.
 
@@ -217,8 +195,6 @@ def augment_dataset_with_quantile_stats(
         repo_id: Repository ID of the dataset
         root: Local root directory for the dataset
         overwrite: Overwrite existing quantile statistics if they already exist
-        use_sampling: If True, sub-sample image/video frames per episode to bound
-            memory. If False, use every frame (exact, higher memory).
     """
     logging.info(f"Loading dataset: {repo_id}")
     dataset = LeRobotDataset(
@@ -232,7 +208,7 @@ def augment_dataset_with_quantile_stats(
 
     logging.info("Dataset does not contain quantile statistics. Computing them now...")
 
-    new_stats = compute_quantile_stats_for_dataset(dataset, use_sampling=use_sampling)
+    new_stats = compute_quantile_stats_for_dataset(dataset)
 
     logging.info("Updating dataset metadata with new quantile statistics")
     dataset.meta.stats = new_stats
@@ -272,14 +248,6 @@ def main():
         action="store_true",
         help="Overwrite existing quantile statistics if they already exist",
     )
-    parser.add_argument(
-        "--no-sampling",
-        action="store_true",
-        help=(
-            "Compute stats over every frame (exact, higher memory). By default, "
-            "image/video frames are sub-sampled per episode to bound memory."
-        ),
-    )
 
     args = parser.parse_args()
     root = Path(args.root) if args.root else None
@@ -290,7 +258,6 @@ def main():
         repo_id=args.repo_id,
         root=root,
         overwrite=args.overwrite,
-        use_sampling=not args.no_sampling,
     )
 
 

src/lerobot/scripts/lerobot_eval.py

@@ -564,7 +564,7 @@ def eval_policy(
         if seeds:
             all_seeds.extend(seeds)
         else:
-            all_seeds.extend([None] * env.num_envs)
+            all_seeds.append(None)
 
         # FIXME: episode_data is either None or it doesn't exist
         if return_episode_data:

src/lerobot/scripts/lerobot_train.py

@@ -22,8 +22,7 @@ import dataclasses
 import logging
 import sys
 import time
-from collections.abc import Iterator
-from contextlib import contextmanager, nullcontext
+from contextlib import nullcontext
 from pprint import pformat
 from typing import TYPE_CHECKING, Any
 
@@ -77,20 +76,6 @@ else:
 from .lerobot_eval import eval_policy_all
 
 
-@contextmanager
-def _make_eval_envs(cfg: TrainPipelineConfig) -> Iterator[dict[str, dict[int, Any]]]:
-    """Create evaluation environments for one run and always dispose of them."""
-    envs = make_env(
-        cfg.env,
-        n_envs=cfg.eval.batch_size,
-        use_async_envs=cfg.eval.use_async_envs,
-    )
-    try:
-        yield envs
-    finally:
-        close_envs(envs)
-
-
 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
@@ -295,6 +280,14 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
     if not is_main_process:
         dataset, eval_dataset = make_train_eval_datasets(cfg)
 
+    # Create environment used for evaluating checkpoints during training on simulation data.
+    # On real-world data, no need to create an environment as evaluations are done outside train.py,
+    # using the eval.py instead, with gym_dora environment and dora-rs.
+    eval_env = None
+    if cfg.env_eval_freq > 0 and cfg.env is not None and is_main_process:
+        logging.info("Creating env")
+        eval_env = make_env(cfg.env, n_envs=cfg.eval.batch_size, use_async_envs=cfg.eval.use_async_envs)
+
     if cfg.is_reward_model_training:
         if is_main_process:
             logging.info("Creating reward model")
@@ -702,7 +695,7 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
             if is_main_process:
                 step_id = get_step_identifier(step, cfg.steps)
                 logging.info(f"Eval policy at step {step}")
-                with _make_eval_envs(cfg) as eval_env, torch.no_grad(), accelerator.autocast():
+                with torch.no_grad(), accelerator.autocast():
                     eval_info = eval_policy_all(
                         envs=eval_env,  # dict[suite][task_id] -> vec_env
                         policy=accelerator.unwrap_model(policy),
@@ -750,6 +743,9 @@ def train(cfg: TrainPipelineConfig, accelerator: "Accelerator | None" = None):
     if is_main_process:
         progbar.close()
 
+    if eval_env:
+        close_envs(eval_env)
+
     is_fsdp = accelerator.distributed_type == DistributedType.FSDP
     model_state_dict = accelerator.get_state_dict(policy) if is_fsdp else None
     if is_main_process:

src/lerobot/teleoperators/so_leader/config_so_leader.py

@@ -29,12 +29,6 @@ class SOLeaderConfig:
     # Whether to use degrees for angles
     use_degrees: bool = True
 
-    # Number of extra attempts when a `sync_read` of the motors fails. Feetech buses can occasionally
-    # return a corrupted status packet ("Incorrect status packet!"), especially when several joints move
-    # at once, which otherwise aborts the teleoperation loop. Retries are immediate (no sleep) and only
-    # happen on failure, so the steady-state read cost is unchanged.
-    num_read_retries: int = 2
-
 
 @TeleoperatorConfig.register_subclass("so101_leader")
 @TeleoperatorConfig.register_subclass("so100_leader")

src/lerobot/teleoperators/so_leader/so_leader.py

@@ -145,7 +145,7 @@ class SOLeader(Teleoperator):
     @check_if_not_connected
     def get_action(self) -> dict[str, float]:
         start = time.perf_counter()
-        action = self.bus.sync_read("Present_Position", num_retry=self.config.num_read_retries)
+        action = self.bus.sync_read("Present_Position")
         action = {f"{motor}.pos": val for motor, val in action.items()}
         dt_ms = (time.perf_counter() - start) * 1e3
         logger.debug(f"{self} read action: {dt_ms:.1f}ms")

src/lerobot/transforms/__init__.py

@@ -13,34 +13,18 @@
 # limitations under the License.
 
 from .transforms import (
-    CoarseDropout,
-    GammaCorrection,
-    GaussianNoise,
-    GaussianPatchBrightness,
     ImageTransformConfig,
     ImageTransforms,
     ImageTransformsConfig,
-    JPEGCompression,
-    MotionBlur,
-    PlanckianJitter,
-    RandomShadow,
     RandomSubsetApply,
     SharpnessJitter,
     make_transform_from_config,
 )
 
 __all__ = [
-    "CoarseDropout",
-    "GammaCorrection",
-    "GaussianNoise",
-    "GaussianPatchBrightness",
     "ImageTransformConfig",
     "ImageTransforms",
     "ImageTransformsConfig",
-    "JPEGCompression",
-    "MotionBlur",
-    "PlanckianJitter",
-    "RandomShadow",
     "RandomSubsetApply",
     "SharpnessJitter",
     "make_transform_from_config",

src/lerobot/transforms/transforms.py

@@ -14,13 +14,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import collections
-import math
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from typing import Any
 
 import torch
-from torchvision.io import decode_image, encode_jpeg
 from torchvision.transforms import v2
 from torchvision.transforms.v2 import (
     Transform,
@@ -146,471 +144,6 @@ class SharpnessJitter(Transform):
         return self._call_kernel(F.adjust_sharpness, inpt, sharpness_factor=sharpness_factor)
 
 
-class GaussianNoise(Transform):
-    """Add Gaussian noise to simulate camera sensor noise.
-
-    Models readout noise from ADC quantization, which increases in low-light conditions.
-    Common in real-robot setups where wrist cameras operate in suboptimal lighting.
-
-    Args:
-        std: Range (min, max) for noise standard deviation in pixel-value scale (0-255).
-    """
-
-    def __init__(self, std: float | Sequence[float] = (5.0, 25.0)) -> None:
-        super().__init__()
-        if isinstance(std, (int, float)):
-            self.std = (0.0, float(std))
-        elif isinstance(std, Sequence) and len(std) == 2:
-            self.std = (float(std[0]), float(std[1]))
-        else:
-            raise TypeError("std must be a number or a sequence with length 2.")
-        if not 0.0 <= self.std[0] <= self.std[1]:
-            raise ValueError(f"std must satisfy 0 <= min <= max, but got {self.std}.")
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        return {
-            "std": torch.empty(1).uniform_(self.std[0], self.std[1]).item(),
-            "seed": torch.randint(0, torch.iinfo(torch.int64).max, ()).item(),
-        }
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if isinstance(inpt, torch.Tensor) and inpt.is_floating_point():
-            generator = torch.Generator(device=inpt.device).manual_seed(params["seed"])
-            noise = torch.randn(inpt.shape, device=inpt.device, dtype=inpt.dtype, generator=generator)
-            return (inpt + noise * (params["std"] / 255.0)).clamp(0.0, 1.0)
-        return inpt
-
-
-class MotionBlur(Transform):
-    """Apply directional motion blur to simulate fast robot or object movement.
-
-    Generates a 1D averaging kernel along a random direction, applied via depthwise convolution.
-
-    Args:
-        kernel_size: An odd kernel size or a range containing at least one odd kernel size.
-    """
-
-    def __init__(self, kernel_size: int | Sequence[int] = (3, 11)) -> None:
-        super().__init__()
-        if isinstance(kernel_size, int):
-            self.kernel_size = (kernel_size, kernel_size)
-        elif isinstance(kernel_size, Sequence) and len(kernel_size) == 2:
-            self.kernel_size = (int(kernel_size[0]), int(kernel_size[1]))
-        else:
-            raise TypeError("kernel_size must be an int or a sequence with length 2.")
-        if not 1 <= self.kernel_size[0] <= self.kernel_size[1]:
-            raise ValueError(f"kernel_size must satisfy 1 <= min <= max, but got {self.kernel_size}.")
-        self._first_odd_kernel_size = self.kernel_size[0] + (self.kernel_size[0] + 1) % 2
-        if self._first_odd_kernel_size > self.kernel_size[1]:
-            raise ValueError(f"kernel_size range must contain an odd value, but got {self.kernel_size}.")
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        num_odd_sizes = (self.kernel_size[1] - self._first_odd_kernel_size) // 2 + 1
-        size_index = int(torch.randint(0, num_odd_sizes, ()).item())
-        ks = self._first_odd_kernel_size + 2 * size_index
-        angle = torch.empty(1).uniform_(0, 360).item()
-        return {"kernel_size": ks, "angle": angle}
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if not isinstance(inpt, torch.Tensor) or not inpt.is_floating_point():
-            return inpt
-        if inpt.ndim < 3:
-            raise ValueError(f"MotionBlur expects [..., C, H, W] input, but got shape {inpt.shape}.")
-
-        kernel_size = params["kernel_size"]
-        radius = kernel_size // 2
-        angle = math.radians(params["angle"])
-        positions = torch.linspace(-radius, radius, kernel_size, device=inpt.device)
-        x_coords = (positions * math.cos(angle)).round().to(torch.long) + radius
-        y_coords = (positions * math.sin(angle)).round().to(torch.long) + radius
-        kernel = torch.zeros((kernel_size, kernel_size), device=inpt.device, dtype=inpt.dtype)
-        kernel[y_coords, x_coords] = 1
-        kernel /= kernel.sum()
-
-        channels, height, width = inpt.shape[-3:]
-        flat_input = inpt.reshape(-1, channels, height, width)
-        depthwise_kernel = kernel.expand(channels, 1, kernel_size, kernel_size)
-        padded = torch.nn.functional.pad(flat_input, (radius,) * 4, mode="replicate")
-        output = torch.nn.functional.conv2d(padded, depthwise_kernel, groups=channels)
-        return output.reshape(inpt.shape).clamp(0.0, 1.0)
-
-
-class JPEGCompression(Transform):
-    """Simulate JPEG compression artifacts (block artifacts, color banding).
-
-    Models quality degradation from video compression in network-streamed camera feeds.
-
-    Args:
-        quality: Range (min, max) for JPEG quality factor (lower = more artifacts).
-    """
-
-    def __init__(self, quality: int | Sequence[int] = (15, 75)) -> None:
-        super().__init__()
-        if isinstance(quality, int):
-            self.quality = (quality, quality)
-        elif isinstance(quality, Sequence) and len(quality) == 2:
-            self.quality = (int(quality[0]), int(quality[1]))
-        else:
-            raise TypeError("quality must be an int or a sequence with length 2.")
-        if not 1 <= self.quality[0] <= self.quality[1] <= 100:
-            raise ValueError(f"quality must satisfy 1 <= min <= max <= 100, but got {self.quality}.")
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        return {"quality": int(torch.randint(self.quality[0], self.quality[1] + 1, (1,)).item())}
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if not isinstance(inpt, torch.Tensor) or not inpt.is_floating_point():
-            return inpt
-        if inpt.ndim < 3:
-            raise ValueError(f"JPEGCompression expects [..., C, H, W] input, but got shape {inpt.shape}.")
-
-        channels, height, width = inpt.shape[-3:]
-        if channels not in (1, 3):
-            raise ValueError(f"JPEGCompression expects 1 or 3 channels, but got {channels}.")
-
-        flat_input = inpt.reshape(-1, channels, height, width)
-        flat_uint8 = (flat_input.clamp(0.0, 1.0) * 255).round().to(torch.uint8).cpu()
-        decoded_frames = [
-            decode_image(encode_jpeg(frame, quality=params["quality"])) for frame in flat_uint8.unbind()
-        ]
-        output = torch.stack(decoded_frames).to(device=inpt.device, dtype=inpt.dtype) / 255.0
-        return output.reshape(inpt.shape)
-
-
-class GaussianPatchBrightness(Transform):
-    """Apply spatially-varying brightness with Gaussian patches.
-
-    Simulates uneven overhead lighting, spotlights, and shadow patches commonly
-    encountered in real robot workspaces with multiple light sources.
-
-    Args:
-        num_patches: Range (min, max) for number of brightness patches.
-        sigma_range: Range for Gaussian sigma as fraction of image size.
-        factor_range: Range for brightness factor (< 1 darkens, > 1 brightens).
-    """
-
-    def __init__(
-        self,
-        num_patches: int | Sequence[int] = (1, 4),
-        sigma_range: Sequence[float] = (0.05, 0.25),
-        factor_range: Sequence[float] = (0.4, 1.6),
-    ) -> None:
-        super().__init__()
-        if isinstance(num_patches, int):
-            self.num_patches = (num_patches, num_patches)
-        elif isinstance(num_patches, Sequence) and len(num_patches) == 2:
-            self.num_patches = (int(num_patches[0]), int(num_patches[1]))
-        else:
-            raise TypeError("num_patches must be an int or a sequence with length 2.")
-        if not 1 <= self.num_patches[0] <= self.num_patches[1]:
-            raise ValueError(f"num_patches must satisfy 1 <= min <= max, but got {self.num_patches}.")
-        if not isinstance(sigma_range, Sequence) or len(sigma_range) != 2:
-            raise TypeError("sigma_range must be a sequence with length 2.")
-        self.sigma_range = (float(sigma_range[0]), float(sigma_range[1]))
-        if not 0.0 < self.sigma_range[0] <= self.sigma_range[1]:
-            raise ValueError(f"sigma_range must satisfy 0 < min <= max, but got {self.sigma_range}.")
-        if not isinstance(factor_range, Sequence) or len(factor_range) != 2:
-            raise TypeError("factor_range must be a sequence with length 2.")
-        self.factor_range = (float(factor_range[0]), float(factor_range[1]))
-        if not 0.0 <= self.factor_range[0] <= self.factor_range[1]:
-            raise ValueError(f"factor_range must satisfy 0 <= min <= max, but got {self.factor_range}.")
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        n = int(torch.randint(self.num_patches[0], self.num_patches[1] + 1, (1,)).item())
-        return {
-            "centers": torch.rand(n, 2).tolist(),
-            "sigmas": torch.empty(n).uniform_(self.sigma_range[0], self.sigma_range[1]).tolist(),
-            "factors": torch.empty(n).uniform_(self.factor_range[0], self.factor_range[1]).tolist(),
-        }
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if not isinstance(inpt, torch.Tensor) or not inpt.is_floating_point():
-            return inpt
-        h, w = inpt.shape[-2:]
-        mask = torch.ones(h, w, device=inpt.device, dtype=inpt.dtype)
-        grid_y = torch.linspace(0, 1, h, device=inpt.device, dtype=inpt.dtype)
-        grid_x = torch.linspace(0, 1, w, device=inpt.device, dtype=inpt.dtype)
-        yy, xx = torch.meshgrid(grid_y, grid_x, indexing="ij")
-        for (cy, cx), sigma, factor in zip(
-            params["centers"], params["sigmas"], params["factors"], strict=True
-        ):
-            gauss = torch.exp(-((yy - cy) ** 2 + (xx - cx) ** 2) / (2 * sigma**2))
-            mask = mask * (1.0 + (factor - 1.0) * gauss)
-        broadcast_shape = (1,) * (inpt.ndim - 2) + (h, w)
-        return (inpt * mask.reshape(broadcast_shape)).clamp(0.0, 1.0)
-
-
-class RandomShadow(Transform):
-    """Add random vertical band shadow with smooth edges.
-
-    Simulates cast shadows from objects or people near the robot workspace.
-    Symmetric: randomly brightens or darkens to prevent BatchNorm stats shift.
-
-    Args:
-        opacity: Range (min, max) for shadow/highlight opacity.
-    """
-
-    def __init__(self, opacity: float | Sequence[float] = (0.3, 0.6)) -> None:
-        super().__init__()
-        if isinstance(opacity, (int, float)):
-            self.opacity = (float(opacity), float(opacity))
-        elif isinstance(opacity, Sequence) and len(opacity) == 2:
-            self.opacity = (float(opacity[0]), float(opacity[1]))
-        else:
-            raise TypeError("opacity must be a number or a sequence with length 2.")
-        if not 0.0 <= self.opacity[0] <= self.opacity[1] <= 1.0:
-            raise ValueError(f"opacity must satisfy 0 <= min <= max <= 1, but got {self.opacity}.")
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        return {
-            "opacity": torch.empty(1).uniform_(self.opacity[0], self.opacity[1]).item(),
-            "start": torch.rand(1).item(),
-            "width": torch.empty(1).uniform_(1 / 3, 2 / 3).item(),
-            "direction": -1.0 if torch.rand(1).item() < 0.5 else 1.0,
-        }
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if not isinstance(inpt, torch.Tensor) or not inpt.is_floating_point():
-            return inpt
-        if inpt.ndim < 3:
-            raise ValueError(f"RandomShadow expects [..., C, H, W] input, but got shape {inpt.shape}.")
-
-        h, w = inpt.shape[-2:]
-        band_width = max(1, min(w, round(params["width"] * w)))
-        x_start = round(params["start"] * (w - band_width))
-        x_end = x_start + band_width
-        mask = torch.ones(h, w, device=inpt.device, dtype=inpt.dtype)
-        mask[:, x_start:x_end] = 1.0 + params["direction"] * params["opacity"]
-
-        smoothing_size = min(8, h, w)
-        if smoothing_size > 1:
-            batched_mask = mask[None, None]
-            small = torch.nn.functional.avg_pool2d(batched_mask, smoothing_size, stride=smoothing_size)
-            mask = torch.nn.functional.interpolate(small, size=(h, w), mode="bilinear", align_corners=False)[
-                0, 0
-            ]
-
-        broadcast_shape = (1,) * (inpt.ndim - 2) + (h, w)
-        return (inpt * mask.reshape(broadcast_shape)).clamp(0.0, 1.0)
-
-
-class CoarseDropout(Transform):
-    """Drop random rectangular patches to simulate partial occlusion.
-
-    Models objects, hands, or cables passing through the camera field of view
-    during robot manipulation.
-
-    Args:
-        max_holes: Maximum number of rectangular patches to drop.
-        max_height_frac: Maximum patch height as fraction of image height.
-        max_width_frac: Maximum patch width as fraction of image width.
-        fill_value: Value to fill dropped regions with.
-    """
-
-    def __init__(
-        self,
-        max_holes: int = 8,
-        max_height_frac: float = 0.07,
-        max_width_frac: float = 0.07,
-        fill_value: float = 0.0,
-    ) -> None:
-        super().__init__()
-        if not isinstance(max_holes, int):
-            raise TypeError("max_holes must be an int.")
-        if max_holes < 1:
-            raise ValueError(f"max_holes must be at least 1, but got {max_holes}.")
-        if not 0.0 < max_height_frac <= 1.0:
-            raise ValueError(f"max_height_frac must be in (0, 1], but got {max_height_frac}.")
-        if not 0.0 < max_width_frac <= 1.0:
-            raise ValueError(f"max_width_frac must be in (0, 1], but got {max_width_frac}.")
-        if not 0.0 <= fill_value <= 1.0:
-            raise ValueError(f"fill_value must be in [0, 1], but got {fill_value}.")
-        self.max_holes = max_holes
-        self.max_height_frac = max_height_frac
-        self.max_width_frac = max_width_frac
-        self.fill_value = fill_value
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        n = int(torch.randint(1, self.max_holes + 1, (1,)).item())
-        sizes = torch.rand(n, 2)
-        sizes[:, 0] *= self.max_height_frac
-        sizes[:, 1] *= self.max_width_frac
-        return {"sizes": sizes.tolist(), "positions": torch.rand(n, 2).tolist()}
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if not isinstance(inpt, torch.Tensor) or not inpt.is_floating_point():
-            return inpt
-        if inpt.ndim < 3:
-            raise ValueError(f"CoarseDropout expects [..., C, H, W] input, but got shape {inpt.shape}.")
-
-        h, w = inpt.shape[-2:]
-        result = inpt.clone()
-        for (height_frac, width_frac), (y_frac, x_frac) in zip(
-            params["sizes"], params["positions"], strict=True
-        ):
-            hole_h = max(1, min(h, round(height_frac * h)))
-            hole_w = max(1, min(w, round(width_frac * w)))
-            y = round(y_frac * (h - hole_h))
-            x = round(x_frac * (w - hole_w))
-            result[..., y : y + hole_h, x : x + hole_w] = self.fill_value
-        return result
-
-
-class GammaCorrection(Transform):
-    """Apply random gamma correction to simulate exposure variation.
-
-    Models different camera auto-exposure settings and sensor response curves.
-    Uses log-symmetric sampling so brightening and darkening are equally likely,
-    preventing BatchNorm statistics shift.
-
-    Args:
-        gamma: Range (min, max) for gamma value. Values < 1 brighten, > 1 darken.
-    """
-
-    def __init__(self, gamma: float | Sequence[float] = (0.5, 2.0)) -> None:
-        super().__init__()
-        if isinstance(gamma, (int, float)):
-            gamma = float(gamma)
-            if gamma <= 0:
-                raise ValueError(f"gamma must be positive, but got {gamma}.")
-            self.gamma = (min(gamma, 1.0 / gamma), max(gamma, 1.0 / gamma))
-        elif isinstance(gamma, Sequence) and len(gamma) == 2:
-            self.gamma = (float(gamma[0]), float(gamma[1]))
-        else:
-            raise TypeError("gamma must be a number or a sequence with length 2.")
-        if not 0.0 < self.gamma[0] <= self.gamma[1]:
-            raise ValueError(f"gamma must satisfy 0 < min <= max, but got {self.gamma}.")
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        log_lo = math.log(self.gamma[0])
-        log_hi = math.log(self.gamma[1])
-        gamma = math.exp(torch.empty(1).uniform_(log_lo, log_hi).item())
-        return {"gamma": gamma}
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if isinstance(inpt, torch.Tensor) and inpt.is_floating_point():
-            return inpt.pow(params["gamma"]).clamp(0.0, 1.0)
-        return inpt
-
-
-# From the paper authors' MIT-licensed reference implementation:
-# https://github.com/TheZino/PlanckianJitter
-_PLANCKIAN_BLACKBODY_COEFFICIENTS = (
-    (0.6743, 0.4029, 0.0013),
-    (0.6281, 0.4241, 0.1665),
-    (0.5919, 0.4372, 0.2513),
-    (0.5623, 0.4457, 0.3154),
-    (0.5376, 0.4515, 0.3672),
-    (0.5163, 0.4555, 0.4103),
-    (0.4979, 0.4584, 0.4468),
-    (0.4816, 0.4604, 0.4782),
-    (0.4672, 0.4619, 0.5053),
-    (0.4542, 0.4630, 0.5289),
-    (0.4426, 0.4638, 0.5497),
-    (0.4320, 0.4644, 0.5681),
-    (0.4223, 0.4648, 0.5844),
-    (0.4135, 0.4651, 0.5990),
-    (0.4054, 0.4653, 0.6121),
-    (0.3980, 0.4654, 0.6239),
-    (0.3911, 0.4655, 0.6346),
-    (0.3847, 0.4656, 0.6444),
-    (0.3787, 0.4656, 0.6532),
-    (0.3732, 0.4656, 0.6613),
-    (0.3680, 0.4655, 0.6688),
-    (0.3632, 0.4655, 0.6756),
-    (0.3586, 0.4655, 0.6820),
-    (0.3544, 0.4654, 0.6878),
-    (0.3503, 0.4653, 0.6933),
-)
-_PLANCKIAN_MIN_TEMPERATURE = 3_000
-_PLANCKIAN_MAX_TEMPERATURE = 15_000
-_PLANCKIAN_TEMPERATURE_STEP = 500
-
-
-class PlanckianJitter(Transform):
-    """Simulate color temperature shift along the Planckian locus.
-
-    Samples one black-body temperature and applies the corresponding correlated red
-    and blue channel scaling while preserving the green channel. Coefficients between
-    the tabulated 500 K intervals are linearly interpolated.
-
-    Reference: Zini et al., "Planckian Jitter", CVPR 2022 Workshop.
-
-    Args:
-        temperature: A fixed color temperature or range in Kelvin. Supported values
-            are between 3000 K and 15000 K.
-    """
-
-    def __init__(self, temperature: int | Sequence[int] = (3_000, 15_000)) -> None:
-        super().__init__()
-        if isinstance(temperature, int):
-            self.temperature = (temperature, temperature)
-        elif isinstance(temperature, Sequence) and len(temperature) == 2:
-            self.temperature = (int(temperature[0]), int(temperature[1]))
-        else:
-            raise TypeError("temperature must be an int or a sequence with length 2.")
-        if not (
-            _PLANCKIAN_MIN_TEMPERATURE
-            <= self.temperature[0]
-            <= self.temperature[1]
-            <= _PLANCKIAN_MAX_TEMPERATURE
-        ):
-            raise ValueError(
-                "temperature must satisfy "
-                f"{_PLANCKIAN_MIN_TEMPERATURE} <= min <= max <= {_PLANCKIAN_MAX_TEMPERATURE}, "
-                f"but got {self.temperature}."
-            )
-
-    def make_params(self, flat_inputs: list[Any]) -> dict[str, Any]:
-        temperature = int(torch.randint(self.temperature[0], self.temperature[1] + 1, ()).item())
-        return {"temperature": temperature}
-
-    def transform(self, inpt: Any, params: dict[str, Any]) -> Any:
-        if not isinstance(inpt, torch.Tensor) or not inpt.is_floating_point():
-            return inpt
-        if inpt.ndim < 3 or inpt.shape[-3] != 3:
-            raise ValueError(f"PlanckianJitter expects [..., 3, H, W] input, but got shape {inpt.shape}.")
-
-        table_position = (params["temperature"] - _PLANCKIAN_MIN_TEMPERATURE) / _PLANCKIAN_TEMPERATURE_STEP
-        left_index = math.floor(table_position)
-        right_index = min(left_index + 1, len(_PLANCKIAN_BLACKBODY_COEFFICIENTS) - 1)
-        interpolation_weight = table_position - left_index
-
-        left = torch.tensor(
-            _PLANCKIAN_BLACKBODY_COEFFICIENTS[left_index],
-            device=inpt.device,
-            dtype=inpt.dtype,
-        )
-        right = torch.tensor(
-            _PLANCKIAN_BLACKBODY_COEFFICIENTS[right_index],
-            device=inpt.device,
-            dtype=inpt.dtype,
-        )
-        coefficients = torch.lerp(left, right, interpolation_weight)
-        scale = torch.stack(
-            (
-                coefficients[0] / coefficients[1],
-                coefficients.new_tensor(1.0),
-                coefficients[2] / coefficients[1],
-            )
-        )
-        broadcast_shape = (1,) * (inpt.ndim - 3) + (3, 1, 1)
-        return (inpt * scale.reshape(broadcast_shape)).clamp(0.0, 1.0)
-
-
-_CUSTOM_TRANSFORMS: dict[str, type[Transform]] = {
-    "SharpnessJitter": SharpnessJitter,
-    "GaussianNoise": GaussianNoise,
-    "MotionBlur": MotionBlur,
-    "JPEGCompression": JPEGCompression,
-    "GaussianPatchBrightness": GaussianPatchBrightness,
-    "RandomShadow": RandomShadow,
-    "CoarseDropout": CoarseDropout,
-    "GammaCorrection": GammaCorrection,
-    "PlanckianJitter": PlanckianJitter,
-}
-
-
 @dataclass
 class ImageTransformConfig:
     """
@@ -683,17 +216,16 @@ class ImageTransformsConfig:
 
 
 def make_transform_from_config(cfg: ImageTransformConfig) -> Transform:
-    if cfg.type in _CUSTOM_TRANSFORMS:
-        return _CUSTOM_TRANSFORMS[cfg.type](**cfg.kwargs)
+    if cfg.type == "SharpnessJitter":
+        return SharpnessJitter(**cfg.kwargs)
 
     transform_cls = getattr(v2, cfg.type, None)
     if isinstance(transform_cls, type) and issubclass(transform_cls, Transform):
         return transform_cls(**cfg.kwargs)
 
-    valid_custom = ", ".join(sorted(_CUSTOM_TRANSFORMS.keys()))
     raise ValueError(
         f"Transform '{cfg.type}' is not valid. It must be a class in "
-        f"torchvision.transforms.v2 or one of: {valid_custom}."
+        f"torchvision.transforms.v2 or 'SharpnessJitter'."
     )
 
 

src/lerobot/utils/utils.py

@@ -133,13 +133,10 @@ def say(text: str, blocking: bool = False):
     else:
         raise RuntimeError("Unsupported operating system for text-to-speech.")
 
-    try:
-        if blocking:
-            subprocess.run(cmd, check=True, timeout=5)
-        else:
-            subprocess.Popen(cmd, creationflags=subprocess.CREATE_NO_WINDOW if system == "Windows" else 0)
-    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
-        logging.warning("Text-to-speech command failed: %s | Error: %s", cmd, e)
+    if blocking:
+        subprocess.run(cmd, check=True)
+    else:
+        subprocess.Popen(cmd, creationflags=subprocess.CREATE_NO_WINDOW if system == "Windows" else 0)
 
 
 def log_say(text: str, play_sounds: bool = True, blocking: bool = False):

tests/datasets/test_augment_quantile_stats.py

@@ -1,104 +0,0 @@
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy as np
-import pytest
-
-pytest.importorskip("datasets", reason="datasets is required (install lerobot[dataset])")
-
-from lerobot.scripts.augment_dataset_quantile_stats import (
-    compute_quantile_stats_for_dataset,
-    has_quantile_stats,
-)
-
-
-def _numeric_keys(dataset):
-    return [k for k, v in dataset.features.items() if v["dtype"] not in ("image", "video", "string")]
-
-
-def _image_keys(dataset):
-    return [k for k, v in dataset.features.items() if v["dtype"] in ("image", "video")]
-
-
-def test_numeric_stats_are_unaffected_by_sampling(tmp_path, lerobot_dataset_factory):
-    """Sampling only touches image/video frames; numeric features are read in
-    full either way, so their stats must be identical with and without sampling."""
-    dataset = lerobot_dataset_factory(
-        root=tmp_path / "ds", total_episodes=2, total_frames=400, use_videos=False
-    )
-
-    exact = compute_quantile_stats_for_dataset(dataset, use_sampling=False)
-    sampled = compute_quantile_stats_for_dataset(dataset, use_sampling=True)
-
-    numeric_keys = _numeric_keys(dataset)
-    assert numeric_keys, "fixture should expose numeric features"
-    for key in numeric_keys:
-        if key not in exact:
-            continue
-        for stat in ("mean", "std", "q01", "q50", "q99"):
-            if stat in exact[key]:
-                np.testing.assert_allclose(
-                    sampled[key][stat],
-                    exact[key][stat],
-                    rtol=1e-6,
-                    atol=1e-6,
-                    err_msg=f"numeric feature '{key}' stat '{stat}' changed under sampling",
-                )
-
-
-def test_image_sampling_reduces_data_but_keeps_stats_close(tmp_path, lerobot_dataset_factory):
-    """For images, sampling should reduce the number of samples considered while
-    keeping the resulting statistics close to the exact ones."""
-    dataset = lerobot_dataset_factory(
-        root=tmp_path / "ds", total_episodes=2, total_frames=400, use_videos=False
-    )
-
-    exact = compute_quantile_stats_for_dataset(dataset, use_sampling=False)
-    sampled = compute_quantile_stats_for_dataset(dataset, use_sampling=True)
-
-    image_keys = _image_keys(dataset)
-    assert image_keys, "fixture should expose at least one image feature"
-    for key in image_keys:
-        # sampling actually looked at fewer pixels
-        assert sampled[key]["count"][0] < exact[key]["count"][0]
-        # but per-channel mean stays close
-        np.testing.assert_allclose(
-            sampled[key]["mean"],
-            exact[key]["mean"],
-            rtol=0.15,
-            err_msg=f"image feature '{key}' mean drifted too far under sampling",
-        )
-
-
-def test_short_episodes_use_all_frames(tmp_path, lerobot_dataset_factory):
-    """With episodes shorter than the sampling floor, sampling is a no-op and
-    must produce exactly the same stats as the exact path."""
-    dataset = lerobot_dataset_factory(
-        root=tmp_path / "ds", total_episodes=2, total_frames=40, use_videos=False
-    )
-
-    exact = compute_quantile_stats_for_dataset(dataset, use_sampling=False)
-    sampled = compute_quantile_stats_for_dataset(dataset, use_sampling=True)
-
-    for key in _image_keys(dataset):
-        assert sampled[key]["count"][0] == exact[key]["count"][0]
-
-
-def test_quantile_stats_present_after_compute(tmp_path, lerobot_dataset_factory):
-    """The computed stats should contain quantile keys for the dataset."""
-    dataset = lerobot_dataset_factory(
-        root=tmp_path / "ds", total_episodes=2, total_frames=200, use_videos=False
-    )
-    stats = compute_quantile_stats_for_dataset(dataset, use_sampling=True)
-    assert has_quantile_stats(stats)

tests/datasets/test_image_transforms.py

@@ -28,17 +28,9 @@ from lerobot.scripts.lerobot_imgtransform_viz import (
     save_each_transform,
 )
 from lerobot.transforms import (
-    CoarseDropout,
-    GammaCorrection,
-    GaussianNoise,
-    GaussianPatchBrightness,
     ImageTransformConfig,
     ImageTransforms,
     ImageTransformsConfig,
-    JPEGCompression,
-    MotionBlur,
-    PlanckianJitter,
-    RandomShadow,
     RandomSubsetApply,
     SharpnessJitter,
     make_transform_from_config,
@@ -463,153 +455,3 @@ def test_save_each_transform(img_tensor_factory, tmp_path):
             assert (transform_dir / file_name).exists(), (
                 f"{file_name} was not found in {transform} directory."
             )
-
-
-# --- Tests for robotics-relevant augmentations ---
-
-ROBOTICS_TRANSFORMS = [
-    ("GaussianNoise", GaussianNoise, {"std": (5.0, 25.0)}),
-    ("MotionBlur", MotionBlur, {"kernel_size": (3, 11)}),
-    ("JPEGCompression", JPEGCompression, {"quality": (15, 75)}),
-    ("GaussianPatchBrightness", GaussianPatchBrightness, {}),
-    ("RandomShadow", RandomShadow, {"opacity": (0.3, 0.6)}),
-    ("CoarseDropout", CoarseDropout, {"max_holes": 8}),
-    ("GammaCorrection", GammaCorrection, {"gamma": (0.5, 2.0)}),
-    ("PlanckianJitter", PlanckianJitter, {"temperature": (3_000, 15_000)}),
-]
-
-
-@pytest.mark.parametrize("name,cls,kwargs", ROBOTICS_TRANSFORMS, ids=[t[0] for t in ROBOTICS_TRANSFORMS])
-def test_robotics_transform_shape_preserved(name, cls, kwargs, img_tensor_factory):
-    img = img_tensor_factory()
-    tf = cls(**kwargs)
-    out = tf(img)
-    assert out.shape == img.shape, f"{name} changed shape: {img.shape} -> {out.shape}"
-
-
-@pytest.mark.parametrize("name,cls,kwargs", ROBOTICS_TRANSFORMS, ids=[t[0] for t in ROBOTICS_TRANSFORMS])
-def test_robotics_transform_output_range(name, cls, kwargs, img_tensor_factory):
-    img = img_tensor_factory()
-    tf = cls(**kwargs)
-    out = tf(img)
-    assert out.min() >= -0.01, f"{name} min below range: {out.min():.4f}"
-    assert out.max() <= 1.01, f"{name} max above range: {out.max():.4f}"
-
-
-@pytest.mark.parametrize("name,cls,kwargs", ROBOTICS_TRANSFORMS, ids=[t[0] for t in ROBOTICS_TRANSFORMS])
-def test_robotics_transform_float_output(name, cls, kwargs, img_tensor_factory):
-    img = img_tensor_factory()
-    tf = cls(**kwargs)
-    out = tf(img)
-    assert out.is_floating_point(), f"{name} output dtype={out.dtype}"
-
-
-@pytest.mark.parametrize("name,cls,kwargs", ROBOTICS_TRANSFORMS, ids=[t[0] for t in ROBOTICS_TRANSFORMS])
-def test_robotics_transform_non_float_passthrough(name, cls, kwargs):
-    int_img = torch.randint(0, 255, (3, 32, 32), dtype=torch.uint8)
-    tf = cls(**kwargs)
-    out = tf(int_img)
-    assert torch.equal(out, int_img), f"{name} modified non-float input"
-
-
-@pytest.mark.parametrize("name,cls,kwargs", ROBOTICS_TRANSFORMS, ids=[t[0] for t in ROBOTICS_TRANSFORMS])
-def test_robotics_transform_via_config(name, cls, kwargs):
-    cfg = ImageTransformConfig(type=name, kwargs=kwargs)
-    tf = make_transform_from_config(cfg)
-    assert isinstance(tf, cls), f"Config produced {type(tf)}, expected {cls}"
-
-
-def test_make_transform_error_message_includes_custom():
-    """Error message should list all registered custom transforms."""
-    with pytest.raises(ValueError, match="GaussianNoise"):
-        make_transform_from_config(ImageTransformConfig(type="NonExistent"))
-
-
-@pytest.mark.parametrize("name,cls,kwargs", ROBOTICS_TRANSFORMS, ids=[t[0] for t in ROBOTICS_TRANSFORMS])
-@pytest.mark.parametrize("shape", [(4, 3, 32, 32), (2, 4, 3, 16, 16)])
-def test_robotics_transform_supports_temporal_batches(name, cls, kwargs, shape):
-    img = torch.rand(shape)
-    out = cls(**kwargs)(img)
-    assert out.shape == img.shape, f"{name} changed shape: {img.shape} -> {out.shape}"
-    assert out.min() >= 0
-    assert out.max() <= 1
-
-
-@pytest.mark.parametrize(
-    "cls,kwargs",
-    [
-        (GaussianNoise, {"std": (25.0, 25.0)}),
-        (MotionBlur, {"kernel_size": 5}),
-        (JPEGCompression, {"quality": 10}),
-        (
-            GaussianPatchBrightness,
-            {"num_patches": 1, "sigma_range": (0.2, 0.2), "factor_range": (0.5, 0.5)},
-        ),
-        (RandomShadow, {"opacity": 0.5}),
-        (CoarseDropout, {"max_holes": 1, "fill_value": 0.0}),
-        (GammaCorrection, {"gamma": (2.0, 2.0)}),
-        (PlanckianJitter, {"temperature": 3_000}),
-    ],
-)
-def test_robotics_transform_is_not_silent_noop(cls, kwargs):
-    img = torch.rand(3, 32, 32)
-    out = cls(**kwargs)(img)
-    assert not torch.equal(out, img)
-
-
-@pytest.mark.parametrize(
-    "transform",
-    [
-        GaussianNoise(std=25),
-        RandomShadow(opacity=0.5),
-        CoarseDropout(max_holes=4),
-    ],
-)
-def test_robotics_transform_random_params_are_reused(transform):
-    img = torch.rand(3, 32, 32)
-    params = transform.make_params([img])
-    torch.testing.assert_close(transform.transform(img, params), transform.transform(img, params))
-
-
-def test_motion_blur_kernel_size_stays_in_configured_range():
-    transform = MotionBlur(kernel_size=(4, 10))
-    sampled_sizes = {transform.make_params([])["kernel_size"] for _ in range(100)}
-    assert sampled_sizes <= {5, 7, 9}
-    assert sampled_sizes
-
-
-def test_gamma_correction_scalar_below_one_defines_symmetric_range():
-    transform = GammaCorrection(gamma=0.5)
-    assert transform.gamma == (0.5, 2.0)
-    assert transform(torch.rand(3, 8, 8)).shape == (3, 8, 8)
-
-
-def test_planckian_jitter_uses_correlated_temperature_coefficients():
-    img = torch.full((2, 3, 8, 8), 0.25)
-    out = PlanckianJitter(temperature=3_000)(img)
-    torch.testing.assert_close(out[:, 1], img[:, 1])
-    assert torch.all(out[:, 0] > out[:, 1])
-    assert torch.all(out[:, 2] < out[:, 1])
-
-
-def test_random_shadow_supports_small_images():
-    img = torch.rand(3, 7, 7)
-    assert RandomShadow()(img).shape == img.shape
-
-
-@pytest.mark.parametrize(
-    "cls,kwargs",
-    [
-        (GaussianNoise, {"std": (-1.0, 1.0)}),
-        (MotionBlur, {"kernel_size": 4}),
-        (JPEGCompression, {"quality": (0, 75)}),
-        (GaussianPatchBrightness, {"sigma_range": (0.0, 0.25)}),
-        (RandomShadow, {"opacity": (0.3, 1.1)}),
-        (CoarseDropout, {"max_holes": 0}),
-        (GammaCorrection, {"gamma": 0.0}),
-        (PlanckianJitter, {"temperature": (2_000, 6_500)}),
-    ],
-)
-def test_robotics_transform_rejects_invalid_config(cls, kwargs):
-    with pytest.raises(ValueError):
-        cls(**kwargs)

tests/motors/test_feetech.py

@@ -294,19 +294,6 @@ def test__sync_read(addr, length, ids_values, mock_motors, dummy_motors):
     assert read_values == ids_values
 
 
-def test__sync_read_retries_after_transient_failure(mock_motors, dummy_motors):
-    addr, length, ids_values = (10, 4, {1: 1337})
-    stub = mock_motors.build_sync_read_stub(addr, length, ids_values, num_invalid_try=1)
-    bus = FeetechMotorsBus(port=mock_motors.port, motors=dummy_motors)
-    bus.connect(handshake=False)
-
-    read_values, read_comm = bus._sync_read(addr, length, list(ids_values), num_retry=1)
-
-    assert read_comm == scs.COMM_SUCCESS
-    assert read_values == ids_values
-    assert mock_motors.stubs[stub].calls == 2
-
-
 @pytest.mark.parametrize("raise_on_error", (True, False))
 def test__sync_read_comm(raise_on_error, mock_motors, dummy_motors):
     addr, length, ids_values = (10, 4, {1: 1337})

tests/policies/test_factory_peft_revision.py

@@ -12,6 +12,7 @@
 # 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
 
@@ -46,23 +47,18 @@ def test_make_policy_keeps_peft_adapter_and_base_revisions_separate(monkeypatch)
     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)
-    require_package = MagicMock()
-    monkeypatch.setattr(policy_factory, "require_package", require_package)
-    monkeypatch.setattr(
-        policy_factory,
-        "PeftConfig",
-        SimpleNamespace(from_pretrained=peft_config_from_pretrained),
-    )
-    monkeypatch.setattr(
-        policy_factory,
-        "PeftModel",
-        SimpleNamespace(from_pretrained=peft_model_from_pretrained),
+    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
-    require_package.assert_called_once_with("peft", extra="peft")
     peft_config_from_pretrained.assert_called_once_with(
         "user/adapter",
         revision="adapter-sha",

tests/robots/test_so100_follower.py

@@ -49,7 +49,7 @@ def _make_bus_mock() -> MagicMock:
 
 
 @pytest.fixture
-def follower(tmp_path):
+def follower():
     bus_mock = _make_bus_mock()
 
     def _bus_side_effect(*_args, **kwargs):
@@ -71,7 +71,7 @@ def follower(tmp_path):
         ),
         patch.object(SO100Follower, "configure", lambda self: None),
     ):
-        cfg = SO100FollowerConfig(port="/dev/null", calibration_dir=tmp_path)
+        cfg = SO100FollowerConfig(port="/dev/null")
         robot = SO100Follower(cfg)
         yield robot
         if robot.is_connected:
@@ -99,27 +99,6 @@ def test_get_observation(follower):
         assert obs[f"{motor}.pos"] == idx
 
 
-def test_get_observation_uses_read_retries(follower):
-    # Feetech buses can intermittently fail a sync_read; the follower should forward the configured
-    # retry count so transient failures don't abort the control loop (see #3131).
-    follower.config.num_read_retries = 7
-    follower.connect()
-    follower.get_observation()
-
-    follower.bus.sync_read.assert_called_once_with("Present_Position", num_retry=7)
-
-
-def test_send_action_uses_read_retries(follower):
-    follower.config.max_relative_target = 10.0
-    follower.config.num_read_retries = 7
-    follower.connect()
-
-    action = {f"{motor}.pos": value * 10 for value, motor in enumerate(follower.bus.motors, 1)}
-    follower.send_action(action)
-
-    follower.bus.sync_read.assert_called_once_with("Present_Position", num_retry=7)
-
-
 def test_send_action(follower):
     follower.connect()
 

uv.lock

@@ -402,10 +402,10 @@ name = "bddl"
 version = "1.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "jupytext" },
-    { name = "networkx" },
-    { name = "numpy" },
-    { name = "pytest" },
+    { name = "jupytext", marker = "sys_platform == 'linux'" },
+    { name = "networkx", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pytest", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5c/37/0211f82891a9f14efcfd2b2096f8d9e4351398ad637fdd1ee59cfc580b0e/bddl-1.0.1.tar.gz", hash = "sha256:1fa4e6e5050b93888ff6fd8455c39bfb29d3864ce06b4c37c0f781f513a2ae26", size = 164809, upload-time = "2022-03-08T01:48:23.564Z" }
 
@@ -1010,7 +1010,7 @@ name = "cuda-bindings"
 version = "12.9.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cuda-pathfinder" },
+    { name = "cuda-pathfinder", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/32/45/557d4ed1fa54f0c7db8aee083229f624990d69f7d00f55477eed5c7e169a/cuda_bindings-12.9.7-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0666d3c082ef8f4b2d670950589373550e9f3bf564d635dd883f24a0b40402ff", size = 7071026, upload-time = "2026-05-27T18:44:13.356Z" },
@@ -1043,37 +1043,37 @@ wheels = [
 
 [package.optional-dependencies]
 cublas = [
-    { name = "nvidia-cublas-cu12" },
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux'" },
 ]
 cudart = [
-    { name = "nvidia-cuda-runtime-cu12" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "sys_platform == 'linux'" },
 ]
 cufft = [
-    { name = "nvidia-cufft-cu12" },
+    { name = "nvidia-cufft-cu12", marker = "sys_platform == 'linux'" },
 ]
 cufile = [
-    { name = "nvidia-cufile-cu12" },
+    { name = "nvidia-cufile-cu12", marker = "sys_platform == 'linux'" },
 ]
 cupti = [
-    { name = "nvidia-cuda-cupti-cu12" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "sys_platform == 'linux'" },
 ]
 curand = [
-    { name = "nvidia-curand-cu12" },
+    { name = "nvidia-curand-cu12", marker = "sys_platform == 'linux'" },
 ]
 cusolver = [
-    { name = "nvidia-cusolver-cu12" },
+    { name = "nvidia-cusolver-cu12", marker = "sys_platform == 'linux'" },
 ]
 cusparse = [
-    { name = "nvidia-cusparse-cu12" },
+    { name = "nvidia-cusparse-cu12", marker = "sys_platform == 'linux'" },
 ]
 nvjitlink = [
-    { name = "nvidia-nvjitlink-cu12" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
 ]
 nvrtc = [
-    { name = "nvidia-cuda-nvrtc-cu12" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "sys_platform == 'linux'" },
 ]
 nvtx = [
-    { name = "nvidia-nvtx-cu12" },
+    { name = "nvidia-nvtx-cu12", marker = "sys_platform == 'linux'" },
 ]
 
 [[package]]
@@ -1145,7 +1145,7 @@ name = "decord"
 version = "0.6.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { 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" },
@@ -1283,10 +1283,10 @@ resolution-markers = [
     "python_full_version == '3.14.*' and sys_platform == 'win32'",
 ]
 dependencies = [
-    { name = "absl-py" },
-    { name = "attrs" },
-    { name = "numpy" },
-    { name = "wrapt" },
+    { name = "absl-py", marker = "python_full_version >= '3.14'" },
+    { name = "attrs", marker = "python_full_version >= '3.14'" },
+    { name = "numpy", marker = "python_full_version >= '3.14'" },
+    { name = "wrapt", marker = "python_full_version >= '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a6/83/ce29720ccf934c6cfa9b9c95ebbe96558386e66886626066632b5e44afed/dm_tree-0.1.9.tar.gz", hash = "sha256:a4c7db3d3935a5a2d5e4b383fc26c6b0cd6f78c6d4605d3e7b518800ecd5342b", size = 35623, upload-time = "2025-01-30T20:45:37.13Z" }
 wheels = [
@@ -1324,10 +1324,10 @@ resolution-markers = [
     "python_full_version < '3.13' and sys_platform == 'win32'",
 ]
 dependencies = [
-    { name = "absl-py" },
-    { name = "attrs" },
-    { name = "numpy" },
-    { name = "wrapt" },
+    { name = "absl-py", marker = "python_full_version < '3.14'" },
+    { name = "attrs", marker = "python_full_version < '3.14'" },
+    { name = "numpy", marker = "python_full_version < '3.14'" },
+    { name = "wrapt", marker = "python_full_version < '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5a/66/a3ec619d22b6baffa5ab853e8dc6ec9d0c837127948af59bb15b988d7312/dm_tree-0.1.10.tar.gz", hash = "sha256:22f37b599e01cc3402a17f79c257a802aebd8d326de05b54657650845956208a", size = 35748, upload-time = "2026-03-31T17:35:39.03Z" }
 wheels = [
@@ -1912,7 +1912,7 @@ name = "h5py"
 version = "3.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/db/33/acd0ce6863b6c0d7735007df01815403f5589a21ff8c2e1ee2587a38f548/h5py-3.16.0.tar.gz", hash = "sha256:a0dbaad796840ccaa67a4c144a0d0c8080073c34c76d5a6941d6818678ef2738", size = 446526, upload-time = "2026-03-06T13:49:08.07Z" }
 wheels = [
@@ -1956,23 +1956,23 @@ name = "hf-libero"
 version = "0.1.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "bddl" },
-    { name = "cloudpickle" },
-    { name = "easydict" },
-    { name = "einops" },
-    { name = "future" },
-    { name = "gymnasium" },
-    { name = "hf-egl-probe" },
-    { name = "hydra-core" },
-    { name = "matplotlib" },
-    { name = "mujoco" },
-    { name = "numpy" },
-    { name = "opencv-python" },
-    { name = "robomimic" },
-    { name = "robosuite" },
-    { name = "thop" },
-    { name = "transformers" },
-    { name = "wandb" },
+    { name = "bddl", marker = "sys_platform == 'linux'" },
+    { name = "cloudpickle", marker = "sys_platform == 'linux'" },
+    { name = "easydict", marker = "sys_platform == 'linux'" },
+    { name = "einops", marker = "sys_platform == 'linux'" },
+    { name = "future", marker = "sys_platform == 'linux'" },
+    { name = "gymnasium", marker = "sys_platform == 'linux'" },
+    { name = "hf-egl-probe", marker = "sys_platform == 'linux'" },
+    { name = "hydra-core", marker = "sys_platform == 'linux'" },
+    { name = "matplotlib", marker = "sys_platform == 'linux'" },
+    { name = "mujoco", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "opencv-python", marker = "sys_platform == 'linux'" },
+    { name = "robomimic", marker = "sys_platform == 'linux'" },
+    { name = "robosuite", marker = "sys_platform == 'linux'" },
+    { name = "thop", marker = "sys_platform == 'linux'" },
+    { name = "transformers", marker = "sys_platform == 'linux'" },
+    { name = "wandb", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/af/aa/4e9eb8715e0bff9cb6553db563a35d253393097d446f82bd53575e8b253d/hf_libero-0.1.4.tar.gz", hash = "sha256:c058d67ad5a2b589529c14d614282ef4cca3a7763dafa134f58a6c9039657e34", size = 2961319, upload-time = "2026-06-10T09:56:13.994Z" }
 wheels = [
@@ -2123,9 +2123,9 @@ name = "hydra-core"
 version = "1.3.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "antlr4-python3-runtime" },
-    { name = "omegaconf" },
-    { name = "packaging" },
+    { name = "antlr4-python3-runtime", marker = "sys_platform == 'linux'" },
+    { name = "omegaconf", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/10/dd/220f0e91743136725352497e98540772a01fc7c3ab96ff16c3c74424e984/hydra_core-1.3.4.tar.gz", hash = "sha256:ad0f7b05a0242255a8984d5a4ed2f6847f7b783ed727368a2c0155ec52d6c34c", size = 3263348, upload-time = "2026-07-04T16:25:38.891Z" }
 wheels = [
@@ -2678,11 +2678,11 @@ name = "jupytext"
 version = "1.19.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markdown-it-py" },
-    { name = "mdit-py-plugins" },
-    { name = "nbformat" },
-    { name = "packaging" },
-    { name = "pyyaml" },
+    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
+    { name = "mdit-py-plugins", marker = "sys_platform == 'linux'" },
+    { name = "nbformat", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a1/ca/473f8ebb101553fb2ea6ab1d34324d6677844c968947ac050c759d539f2c/jupytext-1.19.5.tar.gz", hash = "sha256:605026446d605aa54fd7f7fc69df6ae51c7a46053d4cebf05afdc64d66de3df0", size = 4600916, upload-time = "2026-07-21T22:00:29.198Z" }
 wheels = [
@@ -3472,7 +3472,7 @@ requires-dist = [
     { name = "pyrealsense2", marker = "sys_platform != 'darwin' and extra == 'intelrealsense'", specifier = ">=2.55.1.6486,<2.57.0" },
     { name = "pyrealsense2-macosx", marker = "sys_platform == 'darwin' and extra == 'intelrealsense'", specifier = ">=2.54,<2.57.0" },
     { name = "pyserial", marker = "extra == 'pyserial-dep'", specifier = ">=3.5,<4.0" },
-    { name = "pytest", marker = "extra == 'test'", specifier = ">=8.1.0,<9.0.0" },
+    { name = "pytest", marker = "extra == 'test'", specifier = ">=8.1.0,<10.0.0" },
     { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=5.0.0,<8.0.0" },
     { name = "pytest-timeout", marker = "extra == 'test'", specifier = ">=2.4.0,<3.0.0" },
     { name = "python-can", marker = "extra == 'can-dep'", specifier = ">=4.2.0,<5.0.0" },
@@ -3486,7 +3486,7 @@ requires-dist = [
     { name = "scikit-image", marker = "extra == 'video-benchmark'", specifier = ">=0.23.2,<0.26.0" },
     { name = "scipy", marker = "extra == 'all'", specifier = ">=1.14.0,<2.0.0" },
     { name = "scipy", marker = "extra == 'scipy-dep'", specifier = ">=1.14.0,<2.0.0" },
-    { name = "setuptools", specifier = ">=71.0.0,<81.0.0" },
+    { name = "setuptools", specifier = ">=71.0.0,<84.0.0" },
     { name = "teleop", marker = "extra == 'phone'", specifier = ">=0.1.0,<0.2.0" },
     { name = "termcolor", specifier = ">=2.4.0,<4.0.0" },
     { name = "timm", marker = "extra == 'timm-dep'", specifier = ">=1.0.0,<1.1.0" },
@@ -3817,7 +3817,7 @@ name = "mdit-py-plugins"
 version = "0.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markdown-it-py" },
+    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" }
 wheels = [
@@ -4296,8 +4296,8 @@ name = "numba"
 version = "0.66.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "llvmlite" },
-    { name = "numpy" },
+    { name = "llvmlite", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ae/a0/570e3dc53e5602b49108f62a13e529f1eec8bfc7ef37d49c825924dcf546/numba-0.66.0.tar.gz", hash = "sha256:b900e63a0e26c05ea9a6d5a3a5a0a177cb64c5011887bf43edb8c3ed2c38d363", size = 2806181, upload-time = "2026-07-01T23:12:46.36Z" }
 wheels = [
@@ -4390,7 +4390,7 @@ name = "nvidia-cudnn-cu12"
 version = "9.19.0.56"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12" },
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/09/b8/277c51962ee46fa3e5b203ac5f76107c650f781d6891e681e28e6f3e9fe6/nvidia_cudnn_cu12-9.19.0.56-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:08caaf27fe556aca82a3ee3b5aa49a77e7de0cfcb7ff4e5c29da426387a8267e", size = 656910700, upload-time = "2026-02-03T20:40:25.508Z" },
@@ -4402,7 +4402,7 @@ name = "nvidia-cufft-cu12"
 version = "11.3.3.83"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" },
@@ -4432,9 +4432,9 @@ name = "nvidia-cusolver-cu12"
 version = "11.7.3.90"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12" },
-    { name = "nvidia-cusparse-cu12" },
-    { name = "nvidia-nvjitlink-cu12" },
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparse-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" },
@@ -4446,7 +4446,7 @@ name = "nvidia-cusparse-cu12"
 version = "12.5.8.93"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" },
@@ -4503,8 +4503,8 @@ name = "omegaconf"
 version = "2.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "antlr4-python3-runtime" },
-    { name = "pyyaml" },
+    { name = "antlr4-python3-runtime", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ce/3d/e4b57b8d9008c6ebe0d5eff901f91d5700cf7bdb8c8863df817463a7fd5e/omegaconf-2.3.1.tar.gz", hash = "sha256:e5e7de64aeebeddaf8e6d3f7a783b32ac2a01c0fbd9c878012caecb891a1f42a", size = 3298472, upload-time = "2026-06-11T05:05:12.885Z" }
 wheels = [
@@ -4743,7 +4743,7 @@ name = "pexpect"
 version = "4.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ptyprocess" },
+    { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
 wheels = [
@@ -5317,10 +5317,10 @@ name = "pyobjc-framework-applicationservices"
 version = "12.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyobjc-core" },
-    { name = "pyobjc-framework-cocoa" },
-    { name = "pyobjc-framework-coretext" },
-    { name = "pyobjc-framework-quartz" },
+    { name = "pyobjc-core", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pyobjc-framework-cocoa", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pyobjc-framework-coretext", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pyobjc-framework-quartz", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5e/4d/0ebdd8144aba94b8fe9828ccee5616a4bf53d1f8bc51cff55f3cce86d695/pyobjc_framework_applicationservices-12.2.1.tar.gz", hash = "sha256:048ea663c9ac75c44a15dc7d5b8d78cbb4c97bf1c76e83835e8d5498e184001f", size = 109342, upload-time = "2026-06-19T16:19:46.149Z" }
 wheels = [
@@ -5338,7 +5338,7 @@ name = "pyobjc-framework-cocoa"
 version = "12.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyobjc-core" },
+    { name = "pyobjc-core", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/51/34/fbe38a204643aa4e1b91391cdce07a34da565a69171ebcad08de7438a556/pyobjc_framework_cocoa-12.2.1.tar.gz", hash = "sha256:b94b37fe5730e5ae1fb0052912cd174e6ec329b0bfba4a012ae5db1014b5864b", size = 3125751, upload-time = "2026-06-19T16:20:05.159Z" }
 wheels = [
@@ -5356,9 +5356,9 @@ name = "pyobjc-framework-coretext"
 version = "12.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyobjc-core" },
-    { name = "pyobjc-framework-cocoa" },
-    { name = "pyobjc-framework-quartz" },
+    { name = "pyobjc-core", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pyobjc-framework-cocoa", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pyobjc-framework-quartz", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5a/9c/4c7f452059dc1d3845b8e627b9113c247a997b9b07518e848c2ab7ff3149/pyobjc_framework_coretext-12.2.1.tar.gz", hash = "sha256:af740e784d7c592c34025ec7165f4f6c1a69b5a2d9075f06e41e4f77c212aed2", size = 97349, upload-time = "2026-06-19T16:20:22.508Z" }
 wheels = [
@@ -5376,8 +5376,8 @@ name = "pyobjc-framework-quartz"
 version = "12.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pyobjc-core" },
-    { name = "pyobjc-framework-cocoa" },
+    { name = "pyobjc-core", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
+    { name = "pyobjc-framework-cocoa", marker = "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3b/f6/2a8b84dbf1fe7c04dd96ea73d991678d4e09a909f51971ecc51629bb2ab4/pyobjc_framework_quartz-12.2.1.tar.gz", hash = "sha256:b3b8b6f71e66147f8ff9e6213864cc8527e3a0b1ee90835b93ce221f4802d9b0", size = 3215521, upload-time = "2026-06-19T16:21:30.199Z" }
 wheels = [
@@ -5454,7 +5454,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "8.4.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -5463,9 +5463,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]
@@ -5952,18 +5952,18 @@ name = "robomimic"
 version = "0.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "egl-probe" },
-    { name = "h5py" },
-    { name = "imageio" },
-    { name = "imageio-ffmpeg" },
-    { name = "numpy" },
-    { name = "psutil" },
-    { name = "tensorboard" },
-    { name = "tensorboardx" },
-    { name = "termcolor" },
-    { name = "torch", version = "2.11.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" } },
-    { name = "torchvision", version = "0.26.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" } },
-    { name = "tqdm" },
+    { name = "egl-probe", marker = "sys_platform == 'linux'" },
+    { name = "h5py", marker = "sys_platform == 'linux'" },
+    { name = "imageio", marker = "sys_platform == 'linux'" },
+    { name = "imageio-ffmpeg", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "psutil", marker = "sys_platform == 'linux'" },
+    { name = "tensorboard", marker = "sys_platform == 'linux'" },
+    { name = "tensorboardx", marker = "sys_platform == 'linux'" },
+    { name = "termcolor", marker = "sys_platform == 'linux'" },
+    { name = "torch", version = "2.11.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux'" },
+    { name = "torchvision", version = "0.26.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3d/c3/44b1d1ea4bcb4bbed43d19e09505f4142714451ded74020d4f679cdc89fb/robomimic-0.2.0.tar.gz", hash = "sha256:ee3bb5cf9c3e1feead6b57b43c5db738fd0a8e0c015fdf6419808af8fffdc463", size = 192919, upload-time = "2021-12-17T19:00:33.279Z" }
 
@@ -5972,12 +5972,12 @@ name = "robosuite"
 version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "mujoco" },
-    { name = "numba" },
-    { name = "numpy" },
-    { name = "opencv-python" },
-    { name = "pillow" },
-    { name = "scipy" },
+    { name = "mujoco", marker = "sys_platform == 'linux'" },
+    { name = "numba", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "opencv-python", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "scipy", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/25/a1/9dd07a9a5e09c6aa032faf531da985808b34437cbf6c8f358fe8f7c47118/robosuite-1.4.0.tar.gz", hash = "sha256:a8a6233d7458dbd91bf00a86cab15aa1c178bd9d1b28d515db2cf3d152cb48e6", size = 192182147, upload-time = "2022-12-01T07:31:55.791Z" }
 wheels = [
@@ -6398,16 +6398,16 @@ name = "tensorboard"
 version = "2.20.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "absl-py" },
-    { name = "grpcio" },
-    { name = "markdown" },
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "pillow" },
-    { name = "protobuf" },
-    { name = "setuptools" },
-    { name = "tensorboard-data-server" },
-    { name = "werkzeug" },
+    { name = "absl-py", marker = "sys_platform == 'linux'" },
+    { name = "grpcio", marker = "sys_platform == 'linux'" },
+    { name = "markdown", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "protobuf", marker = "sys_platform == 'linux'" },
+    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "tensorboard-data-server", marker = "sys_platform == 'linux'" },
+    { name = "werkzeug", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/9c/d9/a5db55f88f258ac669a92858b70a714bbbd5acd993820b41ec4a96a4d77f/tensorboard-2.20.0-py3-none-any.whl", hash = "sha256:9dc9f978cb84c0723acf9a345d96c184f0293d18f166bb8d59ee098e6cfaaba6", size = 5525680, upload-time = "2025-07-17T19:20:49.638Z" },
@@ -6427,9 +6427,9 @@ name = "tensorboardx"
 version = "2.6.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "protobuf" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "protobuf", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/48/a9/fc520ea91ab1f3ba51cbf3fe24f2b6364ed3b49046969e0868d46d6da372/tensorboardx-2.6.5.tar.gz", hash = "sha256:ca176db3997ee8c07d2eb77381225956a3fd1c10c91beafab1f17069adc47017", size = 4770195, upload-time = "2026-04-03T15:40:23.803Z" }
 wheels = [
@@ -6464,7 +6464,7 @@ name = "thop"
 version = "0.1.1.post2209072238"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "torch", version = "2.11.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" } },
+    { name = "torch", version = "2.11.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/bb/0f/72beeab4ff5221dc47127c80f8834b4bcd0cb36f6ba91c0b1d04a1233403/thop-0.1.1.post2209072238-py3-none-any.whl", hash = "sha256:01473c225231927d2ad718351f78ebf7cffe6af3bed464c4f1ba1ef0f7cdda27", size = 15443, upload-time = "2022-09-07T14:38:37.211Z" },
@@ -6570,13 +6570,13 @@ resolution-markers = [
     "python_full_version < '3.13' and sys_platform == 'win32'",
 ]
 dependencies = [
-    { name = "filelock" },
-    { name = "fsspec" },
-    { name = "jinja2" },
-    { name = "networkx" },
-    { name = "setuptools" },
-    { name = "sympy" },
-    { name = "typing-extensions" },
+    { name = "filelock", marker = "sys_platform != 'linux'" },
+    { name = "fsspec", marker = "sys_platform != 'linux'" },
+    { name = "jinja2", marker = "sys_platform != 'linux'" },
+    { name = "networkx", marker = "sys_platform != 'linux'" },
+    { name = "setuptools", marker = "sys_platform != 'linux'" },
+    { name = "sympy", marker = "sys_platform != 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform != 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/6f/8b/69e3008d78e5cee2b30183340cc425081b78afc5eff3d080daab0adda9aa/torch-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b5866312ee6e52ea625cd211dcb97d6a2cdc1131a5f15cc0d87eec948f6dd34", size = 80606338, upload-time = "2026-03-23T18:11:34.781Z" },
@@ -6610,20 +6610,20 @@ resolution-markers = [
     "python_full_version < '3.13' and platform_machine != 'AMD64' and platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'x86_64' and sys_platform == 'linux'",
 ]
 dependencies = [
-    { name = "cuda-bindings" },
-    { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"] },
-    { name = "filelock" },
-    { name = "fsspec" },
-    { name = "jinja2" },
-    { name = "networkx" },
-    { name = "nvidia-cudnn-cu12" },
-    { name = "nvidia-cusparselt-cu12" },
-    { name = "nvidia-nccl-cu12" },
-    { name = "nvidia-nvshmem-cu12" },
-    { name = "setuptools" },
-    { name = "sympy" },
-    { name = "triton" },
-    { name = "typing-extensions" },
+    { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
+    { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" },
+    { name = "filelock", marker = "sys_platform == 'linux'" },
+    { name = "fsspec", marker = "sys_platform == 'linux'" },
+    { name = "jinja2", marker = "sys_platform == 'linux'" },
+    { name = "networkx", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparselt-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvshmem-cu12", marker = "sys_platform == 'linux'" },
+    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "sympy", marker = "sys_platform == 'linux'" },
+    { name = "triton", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.11.0%2Bcu128-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:9c8f38efee365cb9d334de8a83ce52fc7e5fc9e5a7b0853285efa1b69e00b0f2", upload-time = "2026-04-27T17:41:30Z" },
@@ -6694,9 +6694,9 @@ resolution-markers = [
     "python_full_version < '3.13' and sys_platform == 'win32'",
 ]
 dependencies = [
-    { name = "numpy" },
-    { name = "pillow" },
-    { name = "torch", version = "2.11.0", source = { registry = "https://pypi.org/simple" } },
+    { name = "numpy", marker = "sys_platform != 'linux'" },
+    { name = "pillow", marker = "sys_platform != 'linux'" },
+    { name = "torch", version = "2.11.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'linux'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/ae/e7/56b47cc3b132aea90ccce22bcb8975dec688b002150012acc842846039d0/torchvision-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c409e1c3fdebec7a3834465086dbda8bf7680eff79abf7fd2f10c6b59520a7a4", size = 1863502, upload-time = "2026-03-23T18:12:57.326Z" },
@@ -6730,9 +6730,9 @@ resolution-markers = [
     "python_full_version < '3.13' and platform_machine != 'AMD64' and platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'x86_64' and sys_platform == 'linux'",
 ]
 dependencies = [
-    { name = "numpy" },
-    { name = "pillow" },
-    { name = "torch", version = "2.11.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" } },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "torch", version = "2.11.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "sys_platform == 'linux'" },
 ]
 wheels = [
     { url = "https://download-r2.pytorch.org/whl/cu128/torchvision-0.26.0%2Bcu128-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:63e35234aed13b6edda37056f417b5c281249669db631e706811917af36b21d7", upload-time = "2026-04-09T23:21:35Z" },
@@ -7222,7 +7222,7 @@ name = "werkzeug"
 version = "3.1.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "markupsafe" },
+    { name = "markupsafe", marker = "sys_platform == 'linux'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/dd/b2/381be8cfdee792dd117872481b6e378f85c957dd7c5bca38897b08f765fd/werkzeug-3.1.8.tar.gz", hash = "sha256:9bad61a4268dac112f1c5cd4630a56ede601b6ed420300677a869083d70a4c44", size = 875852, upload-time = "2026-04-02T18:49:14.268Z" }
 wheels = [