refactor(pipeline): enforce ProcessorStep inheritance for pipeline steps (#1862)

- Updated the DataProcessorPipeline to require that all steps inherit from ProcessorStep, enhancing type safety and clarity.
- Adjusted tests to utilize a MockTokenizerProcessorStep that adheres to the ProcessorStep interface, ensuring consistent behavior across tests.
- Refactored various mock step classes in tests to inherit from ProcessorStep for improved consistency and maintainability.

docs/source/hilserl.mdx

@@ -143,27 +143,27 @@ HIL-SERL uses a modular processor pipeline architecture that processes robot obs
 
 The environment processor (`env_processor`) handles incoming observations and environment state:
 
-1. **VanillaObservationProcessor**: Converts raw robot observations into standardized format
-2. **JointVelocityProcessor** (optional): Adds joint velocity information to observations
-3. **MotorCurrentProcessor** (optional): Adds motor current readings to observations
+1. **VanillaObservationProcessorStep**: Converts raw robot observations into standardized format
+2. **JointVelocityProcessorStep** (optional): Adds joint velocity information to observations
+3. **MotorCurrentProcessorStep** (optional): Adds motor current readings to observations
 4. **ForwardKinematicsJointsToEE** (optional): Computes end-effector pose from joint positions
-5. **ImageCropResizeProcessor** (optional): Crops and resizes camera images
-6. **TimeLimitProcessor** (optional): Enforces episode time limits
-7. **GripperPenaltyProcessor** (optional): Applies penalties for inappropriate gripper usage
-8. **RewardClassifierProcessor** (optional): Automated reward detection using vision models
-9. **ToBatchProcessor**: Converts data to batch format for neural network processing
-10. **DeviceProcessor**: Moves data to the specified compute device (CPU/GPU)
+5. **ImageCropResizeProcessorStep** (optional): Crops and resizes camera images
+6. **TimeLimitProcessorStep** (optional): Enforces episode time limits
+7. **GripperPenaltyProcessorStep** (optional): Applies penalties for inappropriate gripper usage
+8. **RewardClassifierProcessorStep** (optional): Automated reward detection using vision models
+9. **AddBatchDimensionProcessorStep**: Converts data to batch format for neural network processing
+10. **DeviceProcessorStep**: Moves data to the specified compute device (CPU/GPU)
 
 #### Action Processor Pipeline
 
 The action processor (`action_processor`) handles outgoing actions and human interventions:
 
-1. **AddTeleopActionAsComplimentaryData**: Captures teleoperator actions for logging
-2. **AddTeleopEventsAsInfo**: Records intervention events and episode control signals
+1. **AddTeleopActionAsComplimentaryDataStep**: Captures teleoperator actions for logging
+2. **AddTeleopEventsAsInfoStep**: Records intervention events and episode control signals
 3. **AddRobotObservationAsComplimentaryData**: Stores raw robot state for processing
-4. **InterventionActionProcessor**: Handles human interventions and episode termination
+4. **InterventionActionProcessorStep**: Handles human interventions and episode termination
 5. **Inverse Kinematics Pipeline** (when enabled):
-   - **MapDeltaActionToRobotAction**: Converts delta actions to robot action format
+   - **MapDeltaActionToRobotActionStep**: Converts delta actions to robot action format
    - **EEReferenceAndDelta**: Computes end-effector reference and delta movements
    - **EEBoundsAndSafety**: Enforces workspace safety bounds
    - **InverseKinematicsEEToJoints**: Converts end-effector actions to joint targets

examples/phone_to_so100/evaluate.py

@@ -17,15 +17,15 @@
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features
-from lerobot.datasets.utils import merge_features
+from lerobot.datasets.utils import combine_feature_dicts
 from lerobot.model.kinematics import RobotKinematics
 from lerobot.policies.act.modeling_act import ACTPolicy
 from lerobot.policies.factory import make_pre_post_processors
+from lerobot.processor import RobotProcessorPipeline
 from lerobot.processor.converters import (
-    to_output_robot_action,
-    to_transition_robot_observation,
+    observation_to_transition,
+    transition_to_robot_action,
 )
-from lerobot.processor.pipeline import RobotProcessor
 from lerobot.record import record_loop
 from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
 from lerobot.robots.so100_follower.robot_kinematic_processor import (
@@ -65,7 +65,7 @@ kinematics_solver = RobotKinematics(
 )
 
 # Build pipeline to convert ee pose action to joint action
-robot_ee_to_joints = RobotProcessor(
+robot_ee_to_joints_processor = RobotProcessorPipeline(
     steps=[
         AddRobotObservationAsComplimentaryData(robot=robot),
         InverseKinematicsEEToJoints(
@@ -75,21 +75,21 @@ robot_ee_to_joints = RobotProcessor(
         ),
     ],
     to_transition=lambda tr: tr,
-    to_output=to_output_robot_action,
+    to_output=transition_to_robot_action,
 )
 
 # Build pipeline to convert joint observation to ee pose observation
-robot_joints_to_ee_pose = RobotProcessor(
+robot_joints_to_ee_pose_processor = RobotProcessorPipeline(
     steps=[
         ForwardKinematicsJointsToEE(kinematics=kinematics_solver, motor_names=list(robot.bus.motors.keys()))
     ],
-    to_transition=to_transition_robot_observation,
+    to_transition=observation_to_transition,
     to_output=lambda tr: tr,
 )
 
 # Build dataset action and gripper features
 action_ee_and_gripper = aggregate_pipeline_dataset_features(
-    pipeline=robot_ee_to_joints,
+    pipeline=robot_ee_to_joints_processor,
     initial_features={},
     use_videos=True,
     patterns=["action.ee", "action.gripper.pos", "observation.state.gripper.pos"],
@@ -97,13 +97,13 @@ action_ee_and_gripper = aggregate_pipeline_dataset_features(
 
 # Build dataset observation features
 obs_ee = aggregate_pipeline_dataset_features(
-    pipeline=robot_joints_to_ee_pose,
+    pipeline=robot_joints_to_ee_pose_processor,
     initial_features=robot.observation_features,
     use_videos=True,
     patterns=["observation.state.ee"],
 )  # Get all ee observation features
 
-dataset_features = merge_features(obs_ee, action_ee_and_gripper)
+dataset_features = combine_feature_dicts(obs_ee, action_ee_and_gripper)
 
 print("All dataset features: ", dataset_features)
 
@@ -147,8 +147,8 @@ for episode_idx in range(NUM_EPISODES):
         control_time_s=EPISODE_TIME_SEC,
         single_task=TASK_DESCRIPTION,
         display_data=True,
-        robot_action_processor=robot_ee_to_joints,
-        robot_observation_processor=robot_joints_to_ee_pose,
+        robot_action_processor=robot_ee_to_joints_processor,
+        robot_observation_processor=robot_joints_to_ee_pose_processor,
     )
     dataset.save_episode()
 

examples/phone_to_so100/record.py

@@ -18,14 +18,14 @@
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features
-from lerobot.datasets.utils import merge_features
+from lerobot.datasets.utils import combine_feature_dicts
 from lerobot.model.kinematics import RobotKinematics
+from lerobot.processor import RobotProcessorPipeline
 from lerobot.processor.converters import (
-    to_output_robot_action,
-    to_transition_robot_observation,
-    to_transition_teleop_action,
+    action_to_transition,
+    observation_to_transition,
+    transition_to_robot_action,
 )
-from lerobot.processor.pipeline import RobotProcessor
 from lerobot.record import record_loop
 from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
 from lerobot.robots.so100_follower.robot_kinematic_processor import (
@@ -73,7 +73,7 @@ kinematics_solver = RobotKinematics(
 )
 
 # Build pipeline to convert phone action to ee pose action
-phone_to_robot_ee_pose = RobotProcessor(
+phone_to_robot_ee_pose_processor = RobotProcessorPipeline(
     steps=[
         MapPhoneActionToRobotAction(platform=teleop_config.phone_os),
         AddRobotObservationAsComplimentaryData(robot=robot),
@@ -88,12 +88,12 @@ phone_to_robot_ee_pose = RobotProcessor(
             max_ee_twist_step_rad=0.50,
         ),
     ],
-    to_transition=to_transition_teleop_action,
+    to_transition=action_to_transition,
     to_output=lambda tr: tr,
 )
 
 # Build pipeline to convert ee pose action to joint action
-robot_ee_to_joints = RobotProcessor(
+robot_ee_to_joints_processor = RobotProcessorPipeline(
     steps=[
         InverseKinematicsEEToJoints(
             kinematics=kinematics_solver,
@@ -106,21 +106,21 @@ robot_ee_to_joints = RobotProcessor(
         ),
     ],
     to_transition=lambda tr: tr,
-    to_output=to_output_robot_action,
+    to_output=transition_to_robot_action,
 )
 
 # Build pipeline to convert joint observation to ee pose observation
-robot_joints_to_ee_pose = RobotProcessor(
+robot_joints_to_ee_pose = RobotProcessorPipeline(
     steps=[
         ForwardKinematicsJointsToEE(kinematics=kinematics_solver, motor_names=list(robot.bus.motors.keys()))
     ],
-    to_transition=to_transition_robot_observation,
+    to_transition=observation_to_transition,
     to_output=lambda tr: tr,
 )
 
 # Build dataset ee action features
 action_ee = aggregate_pipeline_dataset_features(
-    pipeline=phone_to_robot_ee_pose,
+    pipeline=phone_to_robot_ee_pose_processor,
     initial_features=phone.action_features,
     use_videos=True,
     patterns=["action.ee"],
@@ -128,7 +128,7 @@ action_ee = aggregate_pipeline_dataset_features(
 
 # Get gripper pos action features
 gripper = aggregate_pipeline_dataset_features(
-    pipeline=robot_ee_to_joints,
+    pipeline=robot_ee_to_joints_processor,
     initial_features={},
     use_videos=True,
     patterns=["action.gripper.pos", "observation.state.gripper.pos"],
@@ -142,7 +142,7 @@ observation_ee = aggregate_pipeline_dataset_features(
     patterns=["observation.state.ee"],
 )
 
-dataset_features = merge_features(action_ee, gripper, observation_ee)
+dataset_features = combine_feature_dicts(action_ee, gripper, observation_ee)
 
 print("All dataset features: ", dataset_features)
 
@@ -177,8 +177,8 @@ while episode_idx < NUM_EPISODES and not events["stop_recording"]:
         control_time_s=EPISODE_TIME_SEC,
         single_task=TASK_DESCRIPTION,
         display_data=True,
-        teleop_action_processor=phone_to_robot_ee_pose,
-        robot_action_processor=robot_ee_to_joints,
+        teleop_action_processor=phone_to_robot_ee_pose_processor,
+        robot_action_processor=robot_ee_to_joints_processor,
         robot_observation_processor=robot_joints_to_ee_pose,
     )
 
@@ -193,8 +193,8 @@ while episode_idx < NUM_EPISODES and not events["stop_recording"]:
             control_time_s=RESET_TIME_SEC,
             single_task=TASK_DESCRIPTION,
             display_data=True,
-            teleop_action_processor=phone_to_robot_ee_pose,
-            robot_action_processor=robot_ee_to_joints,
+            teleop_action_processor=phone_to_robot_ee_pose_processor,
+            robot_action_processor=robot_ee_to_joints_processor,
             robot_observation_processor=robot_joints_to_ee_pose,
         )
 

examples/phone_to_so100/replay.py

@@ -19,8 +19,8 @@ import time
 
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.model.kinematics import RobotKinematics
-from lerobot.processor.converters import to_output_robot_action, to_transition_teleop_action
-from lerobot.processor.pipeline import RobotProcessor
+from lerobot.processor import RobotProcessorPipeline
+from lerobot.processor.converters import action_to_transition, transition_to_robot_action
 from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
 from lerobot.robots.so100_follower.robot_kinematic_processor import (
     AddRobotObservationAsComplimentaryData,
@@ -50,7 +50,7 @@ kinematics_solver = RobotKinematics(
 )
 
 # Build pipeline to convert ee pose action to joint action
-robot_ee_to_joints = RobotProcessor(
+robot_ee_to_joints_processor = RobotProcessorPipeline(
     steps=[
         AddRobotObservationAsComplimentaryData(robot=robot),
         InverseKinematicsEEToJoints(
@@ -59,11 +59,11 @@ robot_ee_to_joints = RobotProcessor(
             initial_guess_current_joints=False,  # Because replay is open loop
         ),
     ],
-    to_transition=to_transition_teleop_action,
-    to_output=to_output_robot_action,
+    to_transition=action_to_transition,
+    to_output=transition_to_robot_action,
 )
 
-robot_ee_to_joints.reset()
+robot_ee_to_joints_processor.reset()
 
 log_say(f"Replaying episode {EPISODE_IDX}")
 for idx in range(dataset.num_frames):
@@ -73,7 +73,7 @@ for idx in range(dataset.num_frames):
         name: float(actions[idx]["action"][i]) for i, name in enumerate(dataset.features["action"]["names"])
     }
 
-    joint_action = robot_ee_to_joints(ee_action)
+    joint_action = robot_ee_to_joints_processor(ee_action)
     action_sent = robot.send_action(joint_action)
 
     busy_wait(1.0 / dataset.fps - (time.perf_counter() - t0))

examples/phone_to_so100/teleoperate.py

@@ -16,8 +16,8 @@
 import time
 
 from lerobot.model.kinematics import RobotKinematics
-from lerobot.processor import RobotProcessor
-from lerobot.processor.converters import to_output_robot_action, to_transition_teleop_action
+from lerobot.processor import RobotProcessorPipeline
+from lerobot.processor.converters import action_to_transition, transition_to_robot_action
 from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
 from lerobot.robots.so100_follower.robot_kinematic_processor import (
     AddRobotObservationAsComplimentaryData,
@@ -49,7 +49,7 @@ kinematics_solver = RobotKinematics(
 )
 
 # Build pipeline to convert phone action to ee pose action to joint action
-phone_to_robot_joints = RobotProcessor(
+phone_to_robot_joints_processor = RobotProcessorPipeline(
     steps=[
         MapPhoneActionToRobotAction(platform=teleop_config.phone_os),
         AddRobotObservationAsComplimentaryData(robot=robot),
@@ -72,8 +72,8 @@ phone_to_robot_joints = RobotProcessor(
             speed_factor=20.0,
         ),
     ],
-    to_transition=to_transition_teleop_action,
-    to_output=to_output_robot_action,
+    to_transition=action_to_transition,
+    to_output=transition_to_robot_action,
 )
 
 robot.connect()
@@ -85,7 +85,7 @@ while True:
     phone_obs = teleop_device.get_action()
 
     # Phone -> EE pose -> Joints transition
-    joint_action = phone_to_robot_joints(phone_obs)
+    joint_action = phone_to_robot_joints_processor(phone_obs)
 
     if joint_action:
         robot.send_action(joint_action)

src/lerobot/datasets/pipeline_features.py

@@ -17,11 +17,11 @@ from typing import Any
 
 from lerobot.constants import ACTION, OBS_IMAGES, OBS_STATE
 from lerobot.datasets.utils import hw_to_dataset_features
-from lerobot.processor.pipeline import RobotProcessor
+from lerobot.processor import DataProcessorPipeline
 
 
 def aggregate_pipeline_dataset_features(
-    pipeline: RobotProcessor,
+    pipeline: DataProcessorPipeline,
     initial_features: dict[str, Any],
     *,
     use_videos: bool = True,

src/lerobot/datasets/utils.py

@@ -470,7 +470,7 @@ def dataset_to_policy_features(features: dict[str, dict]) -> dict[str, PolicyFea
     return policy_features
 
 
-def merge_features(*dicts: dict) -> dict:
+def combine_feature_dicts(*dicts: dict) -> dict:
     """
     Merge LeRobot grouped feature dicts.
 

src/lerobot/policies/act/processor_act.py

@@ -18,13 +18,13 @@ import torch
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.act.configuration_act import ACTConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    RenameProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -33,36 +33,36 @@ def make_act_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
 
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/policies/diffusion/processor_diffusion.py

@@ -19,13 +19,13 @@ import torch
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.diffusion.configuration_diffusion import DiffusionConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    RenameProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -34,35 +34,35 @@ def make_diffusion_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/policies/factory.py

@@ -38,7 +38,7 @@ from lerobot.policies.sac.reward_model.configuration_classifier import RewardCla
 from lerobot.policies.smolvla.configuration_smolvla import SmolVLAConfig
 from lerobot.policies.tdmpc.configuration_tdmpc import TDMPCConfig
 from lerobot.policies.vqbet.configuration_vqbet import VQBeTConfig
-from lerobot.processor.pipeline import ProcessorKwargs, RobotProcessor
+from lerobot.processor import PolicyProcessorPipeline, ProcessorKwargs
 
 
 def get_policy_class(name: str) -> type[PreTrainedPolicy]:
@@ -122,7 +122,7 @@ def make_pre_post_processors(
     policy_cfg: PreTrainedConfig,
     pretrained_path: str | None = None,
     **kwargs: Unpack[ProcessorConfigKwargs],
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     """Make a processor instance for a given policy type.
 
     This function creates the appropriate processor configuration based on the policy type.
@@ -146,14 +146,14 @@ def make_pre_post_processors(
         postprocessor_kwargs = kwargs.get("postprocessor_kwargs", {})
 
         return (
-            RobotProcessor.from_pretrained(
+            PolicyProcessorPipeline.from_pretrained(
                 pretrained_model_name_or_path=pretrained_path,
                 config_filename=kwargs.get("preprocessor_config_filename", "robot_preprocessor.json"),
                 overrides=kwargs.get("preprocessor_overrides", {}),
                 to_transition=preprocessor_kwargs.get("to_transition"),
                 to_output=preprocessor_kwargs.get("to_output"),
             ),
-            RobotProcessor.from_pretrained(
+            PolicyProcessorPipeline.from_pretrained(
                 pretrained_model_name_or_path=pretrained_path,
                 config_filename=kwargs.get("postprocessor_config_filename", "robot_postprocessor.json"),
                 overrides=kwargs.get("postprocessor_overrides", {}),

src/lerobot/policies/pi0/processor_pi0.py

@@ -17,27 +17,26 @@
 
 import torch
 
+from lerobot.configs.types import PolicyFeature
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.pi0.configuration_pi0 import PI0Config
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    ComplementaryDataProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RobotProcessor,
-    ToBatchProcessor,
-    TokenizerProcessor,
-    UnnormalizerProcessor,
-)
-from lerobot.processor.pipeline import (
-    ComplementaryDataProcessor,
     ProcessorStep,
     ProcessorStepRegistry,
+    RenameProcessorStep,
+    TokenizerProcessorStep,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.rename_processor import RenameProcessor
 
 
 @ProcessorStepRegistry.register(name="pi0_new_line_processor")
-class Pi0NewLineProcessor(ComplementaryDataProcessor):
+class Pi0NewLineProcessor(ComplementaryDataProcessorStep):
     """Add a new line to the end of the task if it doesn't have one.
     This is required for the PaliGemma tokenizer.
     """
@@ -64,13 +63,16 @@ class Pi0NewLineProcessor(ComplementaryDataProcessor):
 
         return new_complementary_data
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 def make_pi0_pre_post_processors(
     config: PI0Config,
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
@@ -78,37 +80,37 @@ def make_pi0_pre_post_processors(
 
     # Add remaining processors
     input_steps: list[ProcessorStep] = [
-        RenameProcessor(rename_map={}),  # To mimic the same processor as pretrained one
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),  # To mimic the same processor as pretrained one
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
+        AddBatchDimensionProcessorStep(),
         Pi0NewLineProcessor(),  # Add newlines before tokenization for PaliGemma
-        TokenizerProcessor(
+        TokenizerProcessorStep(
             tokenizer_name="google/paligemma-3b-pt-224",
             max_length=config.tokenizer_max_length,
             padding_side="right",
             padding="max_length",
         ),
-        DeviceProcessor(device=config.device),
+        DeviceProcessorStep(device=config.device),
     ]
 
     output_steps: list[ProcessorStep] = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
 
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/policies/pi0fast/processor_pi0fast.py

@@ -19,13 +19,13 @@ import torch
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.pi0.configuration_pi0 import PI0Config
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    RenameProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -34,35 +34,35 @@ def make_pi0fast_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),  # To mimic the same processor as pretrained one
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),  # To mimic the same processor as pretrained one
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/policies/sac/processor_sac.py

@@ -20,13 +20,13 @@ import torch
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.sac.configuration_sac import SACConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    RenameProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -35,35 +35,35 @@ def make_sac_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/policies/sac/reward_model/processor_classifier.py

@@ -17,11 +17,11 @@ import torch
 
 from lerobot.policies.sac.reward_model.configuration_classifier import RewardClassifierConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    IdentityProcessor,
-    NormalizerProcessor,
+    DeviceProcessorStep,
+    IdentityProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RobotProcessor,
 )
 
 
@@ -30,30 +30,30 @@ def make_classifier_processor(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        NormalizerProcessor(
+        NormalizerProcessorStep(
             features=config.input_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
-        NormalizerProcessor(
+        NormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
-        DeviceProcessor(device=config.device),
+        DeviceProcessorStep(device=config.device),
     ]
-    output_steps = [DeviceProcessor(device="cpu"), IdentityProcessor()]
+    output_steps = [DeviceProcessorStep(device="cpu"), IdentityProcessorStep()]
 
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name="classifier_preprocessor",
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name="classifier_postprocessor",
             **postprocessor_kwargs,

src/lerobot/policies/smolvla/processor_smolvla.py

@@ -16,21 +16,20 @@
 
 import torch
 
+from lerobot.configs.types import PolicyFeature
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.smolvla.configuration_smolvla import SmolVLAConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    ComplementaryDataProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    TokenizerProcessor,
-    UnnormalizerProcessor,
-)
-from lerobot.processor.pipeline import (
-    ComplementaryDataProcessor,
     ProcessorStepRegistry,
+    RenameProcessorStep,
+    TokenizerProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -39,42 +38,42 @@ def make_smolvla_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),  # To mimic the same processor as pretrained one
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),  # To mimic the same processor as pretrained one
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
+        AddBatchDimensionProcessorStep(),
         SmolVLANewLineProcessor(),
-        TokenizerProcessor(
+        TokenizerProcessorStep(
             tokenizer_name=config.vlm_model_name,
             padding=config.pad_language_to,
             padding_side="right",
             max_length=config.tokenizer_max_length,
         ),
-        DeviceProcessor(device=config.device),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,
@@ -83,7 +82,7 @@ def make_smolvla_pre_post_processors(
 
 
 @ProcessorStepRegistry.register(name="smolvla_new_line_processor")
-class SmolVLANewLineProcessor(ComplementaryDataProcessor):
+class SmolVLANewLineProcessor(ComplementaryDataProcessorStep):
     """Add a new line to the end of the task if it doesn't have one."""
 
     def complementary_data(self, complementary_data):
@@ -107,3 +106,6 @@ class SmolVLANewLineProcessor(ComplementaryDataProcessor):
         # If task is neither string nor list of strings, leave unchanged
 
         return new_complementary_data
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features

src/lerobot/policies/tdmpc/processor_tdmpc.py

@@ -19,13 +19,13 @@ import torch
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.tdmpc.configuration_tdmpc import TDMPCConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    RenameProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -34,35 +34,35 @@ def make_tdmpc_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/policies/vqbet/processor_vqbet.py

@@ -20,13 +20,13 @@ import torch
 from lerobot.constants import POSTPROCESSOR_DEFAULT_NAME, PREPROCESSOR_DEFAULT_NAME
 from lerobot.policies.vqbet.configuration_vqbet import VQBeTConfig
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    RenameProcessorStep,
+    UnnormalizerProcessorStep,
 )
 
 
@@ -35,35 +35,35 @@ def make_vqbet_pre_post_processors(
     dataset_stats: dict[str, dict[str, torch.Tensor]] | None = None,
     preprocessor_kwargs: ProcessorKwargs | None = None,
     postprocessor_kwargs: ProcessorKwargs | None = None,
-) -> tuple[RobotProcessor, RobotProcessor]:
+) -> tuple[PolicyProcessorPipeline, PolicyProcessorPipeline]:
     if preprocessor_kwargs is None:
         preprocessor_kwargs = {}
     if postprocessor_kwargs is None:
         postprocessor_kwargs = {}
 
     input_steps = [
-        RenameProcessor(rename_map={}),  # Let the possibility to the user to rename the keys
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),  # Let the possibility to the user to rename the keys
+        NormalizerProcessorStep(
             features={**config.input_features, **config.output_features},
             norm_map=config.normalization_mapping,
             stats=dataset_stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=config.device),
     ]
     output_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(
             features=config.output_features, norm_map=config.normalization_mapping, stats=dataset_stats
         ),
     ]
     return (
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=input_steps,
             name=PREPROCESSOR_DEFAULT_NAME,
             **preprocessor_kwargs,
         ),
-        RobotProcessor(
+        PolicyProcessorPipeline(
             steps=output_steps,
             name=POSTPROCESSOR_DEFAULT_NAME,
             **postprocessor_kwargs,

src/lerobot/processor/__init__.py

@@ -14,74 +14,90 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .batch_processor import ToBatchProcessor
-from .delta_action_processor import MapDeltaActionToRobotAction, MapTensorToDeltaActionDict
-from .device_processor import DeviceProcessor
-from .gym_action_processor import Numpy2TorchActionProcessor, Torch2NumpyActionProcessor
-from .hil_processor import (
-    AddTeleopActionAsComplimentaryData,
-    AddTeleopEventsAsInfo,
-    GripperPenaltyProcessor,
-    ImageCropResizeProcessor,
-    InterventionActionProcessor,
-    RewardClassifierProcessor,
-    TimeLimitProcessor,
+from .batch_processor import AddBatchDimensionProcessorStep
+from .converters import (
+    batch_to_transition,
+    create_transition,
+    merge_transitions,
+    transition_to_batch,
+    transition_to_dataset_frame,
 )
-from .joint_observations_processor import JointVelocityProcessor, MotorCurrentProcessor
-from .normalize_processor import NormalizerProcessor, UnnormalizerProcessor, hotswap_stats
-from .observation_processor import VanillaObservationProcessor
+from .core import EnvTransition, TransitionKey
+from .delta_action_processor import MapDeltaActionToRobotActionStep, MapTensorToDeltaActionDictStep
+from .device_processor import DeviceProcessorStep
+from .gym_action_processor import Numpy2TorchActionProcessorStep, Torch2NumpyActionProcessorStep
+from .hil_processor import (
+    AddTeleopActionAsComplimentaryDataStep,
+    AddTeleopEventsAsInfoStep,
+    GripperPenaltyProcessorStep,
+    ImageCropResizeProcessorStep,
+    InterventionActionProcessorStep,
+    RewardClassifierProcessorStep,
+    TimeLimitProcessorStep,
+)
+from .joint_observations_processor import JointVelocityProcessorStep, MotorCurrentProcessorStep
+from .normalize_processor import NormalizerProcessorStep, UnnormalizerProcessorStep, hotswap_stats
+from .observation_processor import VanillaObservationProcessorStep
 from .pipeline import (
-    ActionProcessor,
-    DoneProcessor,
-    EnvTransition,
-    IdentityProcessor,
-    InfoProcessor,
-    ObservationProcessor,
+    ActionProcessorStep,
+    ComplementaryDataProcessorStep,
+    DataProcessorPipeline,
+    DoneProcessorStep,
+    IdentityProcessorStep,
+    InfoProcessorStep,
+    ObservationProcessorStep,
+    PolicyProcessorPipeline,
     ProcessorKwargs,
     ProcessorStep,
     ProcessorStepRegistry,
-    RewardProcessor,
-    RobotProcessor,
-    TransitionKey,
-    TruncatedProcessor,
+    RewardProcessorStep,
+    RobotProcessorPipeline,
+    TruncatedProcessorStep,
 )
-from .rename_processor import RenameProcessor
-from .tokenizer_processor import TokenizerProcessor
+from .rename_processor import RenameProcessorStep
+from .tokenizer_processor import TokenizerProcessorStep
 
 __all__ = [
-    "ActionProcessor",
-    "AddTeleopActionAsComplimentaryData",
-    "AddTeleopEventsAsInfo",
-    "DeviceProcessor",
-    "DoneProcessor",
-    "MapDeltaActionToRobotAction",
-    "MapTensorToDeltaActionDict",
+    "ActionProcessorStep",
+    "AddTeleopActionAsComplimentaryDataStep",
+    "AddTeleopEventsAsInfoStep",
+    "ComplementaryDataProcessorStep",
+    "batch_to_transition",
+    "create_transition",
+    "DeviceProcessorStep",
+    "DoneProcessorStep",
     "EnvTransition",
-    "GripperPenaltyProcessor",
-    "IdentityProcessor",
-    "ImageCropResizeProcessor",
-    "InfoProcessor",
-    "InterventionActionProcessor",
-    "JointVelocityProcessor",
-    "MapDeltaActionToRobotAction",
-    "MotorCurrentProcessor",
-    "NormalizerProcessor",
-    "UnnormalizerProcessor",
+    "GripperPenaltyProcessorStep",
     "hotswap_stats",
-    "ObservationProcessor",
+    "IdentityProcessorStep",
+    "ImageCropResizeProcessorStep",
+    "InfoProcessorStep",
+    "InterventionActionProcessorStep",
+    "JointVelocityProcessorStep",
+    "MapDeltaActionToRobotActionStep",
+    "MapTensorToDeltaActionDictStep",
+    "merge_transitions",
+    "MotorCurrentProcessorStep",
+    "NormalizerProcessorStep",
+    "Numpy2TorchActionProcessorStep",
+    "ObservationProcessorStep",
+    "PolicyProcessorPipeline",
     "ProcessorKwargs",
     "ProcessorStep",
     "ProcessorStepRegistry",
-    "RenameProcessor",
-    "RewardClassifierProcessor",
-    "RewardProcessor",
-    "RobotProcessor",
-    "ToBatchProcessor",
-    "TokenizerProcessor",
-    "TimeLimitProcessor",
-    "Numpy2TorchActionProcessor",
-    "Torch2NumpyActionProcessor",
+    "RenameProcessorStep",
+    "RewardClassifierProcessorStep",
+    "RewardProcessorStep",
+    "DataProcessorPipeline",
+    "TimeLimitProcessorStep",
+    "AddBatchDimensionProcessorStep",
+    "RobotProcessorPipeline",
+    "TokenizerProcessorStep",
+    "Torch2NumpyActionProcessorStep",
+    "transition_to_batch",
+    "transition_to_dataset_frame",
     "TransitionKey",
-    "TruncatedProcessor",
-    "VanillaObservationProcessor",
+    "TruncatedProcessorStep",
+    "UnnormalizerProcessorStep",
+    "VanillaObservationProcessorStep",
 ]

src/lerobot/processor/batch_processor.py

@@ -15,12 +15,14 @@ from dataclasses import dataclass, field
 
 from torch import Tensor
 
+from lerobot.configs.types import PolicyFeature
 from lerobot.constants import OBS_ENV_STATE, OBS_IMAGE, OBS_IMAGES, OBS_STATE
-from lerobot.processor.pipeline import (
-    ActionProcessor,
-    ComplementaryDataProcessor,
-    EnvTransition,
-    ObservationProcessor,
+
+from .core import EnvTransition
+from .pipeline import (
+    ActionProcessorStep,
+    ComplementaryDataProcessorStep,
+    ObservationProcessorStep,
     ProcessorStep,
     ProcessorStepRegistry,
 )
@@ -28,7 +30,7 @@ from lerobot.processor.pipeline import (
 
 @dataclass
 @ProcessorStepRegistry.register(name="to_batch_processor_action")
-class ToBatchProcessorAction(ActionProcessor):
+class AddBatchDimensionActionStep(ActionProcessorStep):
     """Process action component in-place, adding batch dimension if needed."""
 
     def action(self, action):
@@ -37,10 +39,13 @@ class ToBatchProcessorAction(ActionProcessor):
 
         return action.unsqueeze(0)
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register(name="to_batch_processor_observation")
-class ToBatchProcessorObservation(ObservationProcessor):
+class AddBatchDimensionObservationStep(ObservationProcessorStep):
     """Process observation component in-place, adding batch dimensions where needed."""
 
     def observation(self, observation):
@@ -63,10 +68,13 @@ class ToBatchProcessorObservation(ObservationProcessor):
                 observation[key] = value.unsqueeze(0)
         return observation
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register(name="to_batch_processor_complementary_data")
-class ToBatchProcessorComplementaryData(ComplementaryDataProcessor):
+class AddBatchDimensionComplementaryDataStep(ComplementaryDataProcessorStep):
     """Process complementary data in-place, handling task field batching."""
 
     def complementary_data(self, complementary_data):
@@ -89,10 +97,13 @@ class ToBatchProcessorComplementaryData(ComplementaryDataProcessor):
                 complementary_data["task_index"] = task_index_value.unsqueeze(0)
         return complementary_data
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register(name="to_batch_processor")
-class ToBatchProcessor(ProcessorStep):
+class AddBatchDimensionProcessorStep(ProcessorStep):
     """Processor that adds batch dimensions to observations and actions when needed.
 
     This processor ensures that observations and actions have proper batch dimensions for model processing:
@@ -127,12 +138,14 @@ class ToBatchProcessor(ProcessorStep):
         ```
     """
 
-    to_batch_action_processor: ToBatchProcessorAction = field(default_factory=ToBatchProcessorAction)
-    to_batch_observation_processor: ToBatchProcessorObservation = field(
-        default_factory=ToBatchProcessorObservation
+    to_batch_action_processor: AddBatchDimensionActionStep = field(
+        default_factory=AddBatchDimensionActionStep
     )
-    to_batch_complementary_data_processor: ToBatchProcessorComplementaryData = field(
-        default_factory=ToBatchProcessorComplementaryData
+    to_batch_observation_processor: AddBatchDimensionObservationStep = field(
+        default_factory=AddBatchDimensionObservationStep
+    )
+    to_batch_complementary_data_processor: AddBatchDimensionComplementaryDataStep = field(
+        default_factory=AddBatchDimensionComplementaryDataStep
     )
 
     def __call__(self, transition: EnvTransition) -> EnvTransition:
@@ -140,3 +153,7 @@ class ToBatchProcessor(ProcessorStep):
         transition = self.to_batch_observation_processor(transition)
         transition = self.to_batch_complementary_data_processor(transition)
         return transition
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        # NOTE: We ignore the batch dimension when transforming features
+        return features

src/lerobot/processor/converters.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable, Sequence
+from collections.abc import Sequence
 from copy import deepcopy
 from functools import singledispatch
 from typing import Any
@@ -27,7 +27,7 @@ from scipy.spatial.transform import Rotation
 
 from lerobot.constants import ACTION, DONE, OBS_IMAGES, OBS_STATE, REWARD, TRUNCATED
 
-from .pipeline import EnvTransition, TransitionKey
+from .core import EnvTransition, TransitionKey
 
 
 @singledispatch
@@ -139,7 +139,8 @@ def _(value: dict, *, device=None, **kwargs) -> dict:
     return result
 
 
-def _from_tensor(x: Any):
+def _from_tensor(x: torch.Tensor | Any) -> np.ndarray | float | int | Any:
+    """Convert tensor to numpy/scalar if needed."""
     if isinstance(x, torch.Tensor):
         return x.item() if x.numel() == 1 else x.detach().cpu().numpy()
     return x
@@ -159,21 +160,80 @@ def _split_obs_to_state_and_images(obs: dict[str, Any]) -> tuple[dict[str, Any],
     return state, images
 
 
-def make_obs_act_transition(
-    *, obs: dict[str, Any] | None = None, act: dict[str, Any] | None = None
+# ============================================================================
+# Private Helper Functions (Common Logic)
+# ============================================================================
+
+
+def _extract_complementary_data(batch: dict[str, Any]) -> dict[str, Any]:
+    """Extract complementary data (pad flags, task, index, task_index)."""
+    pad_keys = {k: v for k, v in batch.items() if "_is_pad" in k}
+    task_key = {"task": batch["task"]} if "task" in batch else {}
+    index_key = {"index": batch["index"]} if "index" in batch else {}
+    task_index_key = {"task_index": batch["task_index"]} if "task_index" in batch else {}
+
+    return {**pad_keys, **task_key, **index_key, **task_index_key}
+
+
+def _merge_transitions(base: EnvTransition, other: EnvTransition) -> EnvTransition:
+    """Merge two transitions, with other taking precedence."""
+    out = deepcopy(base)
+
+    for key in (
+        TransitionKey.OBSERVATION,
+        TransitionKey.ACTION,
+        TransitionKey.INFO,
+        TransitionKey.COMPLEMENTARY_DATA,
+    ):
+        if other.get(key):
+            out.setdefault(key, {}).update(deepcopy(other[key]))
+
+    for k in (TransitionKey.REWARD, TransitionKey.DONE, TransitionKey.TRUNCATED):
+        if k in other:
+            out[k] = other[k]
+    return out
+
+
+# ============================================================================
+# Core Conversion Functions
+# ============================================================================
+
+
+def create_transition(
+    observation: dict[str, Any] | None = None,
+    action: dict[str, Any] | None = None,
+    reward: float = 0.0,
+    done: bool = False,
+    truncated: bool = False,
+    info: dict[str, Any] | None = None,
+    complementary_data: dict[str, Any] | None = None,
 ) -> EnvTransition:
+    """Create an EnvTransition with sensible defaults.
+
+    Args:
+        observation: Observation dictionary.
+        action: Action dictionary.
+        reward: Scalar reward value.
+        done: Episode termination flag.
+        truncated: Episode truncation flag.
+        info: Additional info dictionary.
+        complementary_data: Complementary data dictionary.
+
+    Returns:
+        Complete EnvTransition dictionary.
+    """
     return {
-        TransitionKey.OBSERVATION: {} if obs is None else obs,
-        TransitionKey.ACTION: {} if act is None else act,
-        TransitionKey.INFO: {},
-        TransitionKey.COMPLEMENTARY_DATA: {},
-        TransitionKey.REWARD: None,
-        TransitionKey.DONE: None,
-        TransitionKey.TRUNCATED: None,
+        TransitionKey.OBSERVATION: observation,
+        TransitionKey.ACTION: action,
+        TransitionKey.REWARD: reward,
+        TransitionKey.DONE: done,
+        TransitionKey.TRUNCATED: truncated,
+        TransitionKey.INFO: info if info is not None else {},
+        TransitionKey.COMPLEMENTARY_DATA: complementary_data if complementary_data is not None else {},
     }
 
 
-def to_transition_teleop_action(action: dict[str, Any]) -> EnvTransition:
+def action_to_transition(action: dict[str, Any]) -> EnvTransition:  # action_to_transition
     """
     Convert a raw teleop action dict into an EnvTransition under the ACTION TransitionKey.
     """
@@ -187,11 +247,11 @@ def to_transition_teleop_action(action: dict[str, Any]) -> EnvTransition:
         arr = np.array(v) if np.isscalar(v) else v
         act_dict[f"{ACTION}.{k}"] = to_tensor(arr)
 
-    return make_obs_act_transition(act=act_dict)
+    return create_transition(observation={}, action=act_dict)
 
 
 # TODO(Adil, Pepijn): Overtime we can maybe add these converters to pipeline.py itself
-def to_transition_robot_observation(observation: dict[str, Any]) -> EnvTransition:
+def observation_to_transition(observation: dict[str, Any]) -> EnvTransition:
     """
     Convert a raw robot observation dict into an EnvTransition under the OBSERVATION TransitionKey.
     """
@@ -205,10 +265,10 @@ def to_transition_robot_observation(observation: dict[str, Any]) -> EnvTransitio
     for cam, img in images.items():
         obs_dict[f"{OBS_IMAGES}.{cam}"] = img
 
-    return make_obs_act_transition(obs=obs_dict)
+    return create_transition(observation=obs_dict, action={})
 
 
-def to_output_robot_action(transition: EnvTransition) -> dict[str, Any]:
+def transition_to_robot_action(transition: EnvTransition) -> dict[str, Any]:
     """
     Converts a EnvTransition under the ACTION TransitionKey to a dict with keys ending in '.pos' for raw robot actions.
     """
@@ -226,69 +286,61 @@ def to_output_robot_action(transition: EnvTransition) -> dict[str, Any]:
     return out
 
 
-def to_dataset_frame(
-    transitions_or_transition: EnvTransition | Iterable[EnvTransition], features: dict[str, dict]
-) -> dict[str, any]:
-    """
-    Converts a single EnvTransition or an iterable of them into a flat,
-    dataset-friendly dictionary for training or evaluation, according to
-    the provided `features` spec.
+def merge_transitions(transitions: Sequence[EnvTransition] | EnvTransition) -> EnvTransition:
+    """Merge multiple transitions or return single transition.
 
     Args:
-        transitions_or_transition: Either a single EnvTransition dict
-            or an iterable of them (which will be merged).
-        features (dict[str, dict]):
-            A feature specification dictionary:
-              - 'action': dict with 'names': list of action feature names
-              - 'observation.state': dict with 'names': list of state feature names
-              - keys starting with 'observation.images.' are passed through
+        transitions: Either a single transition or iterable of transitions.
 
     Returns:
-        batch (dict[str, any]): Flat dictionary containing:
-          - numpy arrays for "observation.state" and "action"
-          - any image tensors defined in features
-          - next.{reward,done,truncated}
-          - info dict
-          - *_is_pad flags and task from complementary_data
+        Merged EnvTransition.
+    """
+
+    if not isinstance(transitions, Sequence):  # Single transition
+        return transitions
+
+    items = list(transitions)
+    if not items:
+        raise ValueError("merge_transitions() requires a non-empty sequence of transitions")
+
+    result = items[0]
+    for t in items[1:]:
+        result = _merge_transitions(result, t)
+    return result
+
+
+def transition_to_dataset_frame(
+    transitions_or_transition: EnvTransition | Sequence[EnvTransition], features: dict[str, dict]
+) -> dict[str, Any]:
+    """Convert a single EnvTransition or an iterable of them into a flat, dataset-friendly dictionary for training or evaluation.
+
+    Processes transitions according to the provided feature specification and returns
+    data in the format expected by machine learning models and datasets.
+
+    Args:
+        transitions_or_transition: Either a single EnvTransition dict or an iterable of them
+            (which will be merged using merge_transitions).
+        features: Feature specification dictionary with the following structure:
+            - 'action': dict with 'names': list of action feature names
+            - 'observation.state': dict with 'names': list of state feature names
+            - keys starting with 'observation.images.' are passed through as-is
+
+    Returns:
+        Flat dictionary containing:
+        - numpy arrays for "observation.state" and "action" (vectorized from feature names)
+        - any image tensors defined in features (passed through unchanged)
+        - next.{reward,done,truncated} scalar values
+        - info dict
+        - *_is_pad flags and task from complementary_data
     """
     action_names = features.get(ACTION, {}).get("names", [])
     obs_state_names = features.get(OBS_STATE, {}).get("names", [])
     image_keys = [k for k in features if k.startswith(OBS_IMAGES)]
 
-    def _merge(base: EnvTransition, other: EnvTransition) -> EnvTransition:
-        out = deepcopy(base)
-        for key in (
-            TransitionKey.OBSERVATION,
-            TransitionKey.ACTION,
-            TransitionKey.INFO,
-            TransitionKey.COMPLEMENTARY_DATA,
-        ):
-            if other.get(key):
-                out.setdefault(key, {}).update(deepcopy(other[key]))
-        for k in (TransitionKey.REWARD, TransitionKey.DONE, TransitionKey.TRUNCATED):
-            if k in other:
-                out[k] = other[k]
-        return out
-
-    def _ensure_transition(obj) -> EnvTransition:
-        # single transition
-        if isinstance(obj, dict) and any(isinstance(k, TransitionKey) for k in obj):
-            return obj
-        # iterable of transitions
-        if isinstance(obj, Iterable):
-            items = list(obj)
-            if not items:
-                return {}
-            acc = items[0]
-            for t in items[1:]:
-                acc = _merge(acc, t)
-            return acc
-        raise TypeError("Expected EnvTransition or iterable of them")
-
-    tr = _ensure_transition(transitions_or_transition)
+    tr = merge_transitions(transitions_or_transition)
     obs = tr.get(TransitionKey.OBSERVATION, {}) or {}
     act = tr.get(TransitionKey.ACTION, {}) or {}
-    batch: dict[str, any] = {}
+    batch: dict[str, Any] = {}
 
     # Images passthrough
     for k in image_keys:
@@ -305,12 +357,28 @@ def to_dataset_frame(
         vals = [_from_tensor(act.get(f"{ACTION}.{n}", 0.0)) for n in action_names]
         batch[ACTION] = np.asarray(vals, dtype=np.float32)
 
+    # Add transition metadata
     if tr.get(TransitionKey.REWARD) is not None:
-        batch[REWARD] = _from_tensor(tr[TransitionKey.REWARD])
+        reward_val = _from_tensor(tr[TransitionKey.REWARD])
+        # Check if features expect array format, otherwise keep as scalar
+        if REWARD in features and features[REWARD].get("shape") == (1,):
+            batch[REWARD] = np.array([reward_val], dtype=np.float32)
+        else:
+            batch[REWARD] = reward_val
+
     if tr.get(TransitionKey.DONE) is not None:
-        batch[DONE] = _from_tensor(tr[TransitionKey.DONE])
+        done_val = _from_tensor(tr[TransitionKey.DONE])
+        if DONE in features and features[DONE].get("shape") == (1,):
+            batch[DONE] = np.array([done_val], dtype=bool)
+        else:
+            batch[DONE] = done_val
+
     if tr.get(TransitionKey.TRUNCATED) is not None:
-        batch[TRUNCATED] = _from_tensor(tr[TransitionKey.TRUNCATED])
+        truncated_val = _from_tensor(tr[TransitionKey.TRUNCATED])
+        if TRUNCATED in features and features[TRUNCATED].get("shape") == (1,):
+            batch[TRUNCATED] = np.array([truncated_val], dtype=bool)
+        else:
+            batch[TRUNCATED] = truncated_val
 
     # Complementary data flags and task
     comp = tr.get(TransitionKey.COMPLEMENTARY_DATA) or {}
@@ -324,3 +392,90 @@ def to_dataset_frame(
             batch["task"] = comp["task"]
 
     return batch
+
+
+def batch_to_transition(batch: dict[str, Any]) -> EnvTransition:
+    """Convert a batch dict coming from LeRobot replay/dataset code into an EnvTransition dictionary.
+
+    The function maps well known keys to the EnvTransition structure. Missing keys are
+    filled with sane defaults (None or 0.0/False).
+
+    Keys recognised (case-sensitive):
+    * "observation.*" (keys starting with "observation." are grouped into observation dict)
+    * "action"
+    * "next.reward"
+    * "next.done"
+    * "next.truncated"
+    * "info"
+    * "_is_pad" patterns (padding flags)
+    * "task", "index", "task_index" (complementary data)
+
+    Additional keys are ignored so that existing dataloaders can carry extra
+    metadata without breaking the processor.
+
+    Args:
+        batch: Batch dictionary from datasets or dataloaders containing the above keys.
+
+    Returns:
+        EnvTransition dictionary with properly structured transition data.
+    """
+
+    # Validate input type
+    if not isinstance(batch, dict):
+        raise ValueError(f"EnvTransition must be a dictionary. Got {type(batch).__name__}")
+
+    # Extract observation keys
+    observation_keys = {k: v for k, v in batch.items() if k.startswith("observation.")}
+    complementary_data = _extract_complementary_data(batch)
+
+    return create_transition(
+        observation=observation_keys if observation_keys else None,
+        action=batch.get("action"),
+        reward=batch.get("next.reward", 0.0),
+        done=batch.get("next.done", False),
+        truncated=batch.get("next.truncated", False),
+        info=batch.get("info", {}),
+        complementary_data=complementary_data if complementary_data else None,
+    )
+
+
+def transition_to_batch(transition: EnvTransition) -> dict[str, Any]:
+    """Inverse of batch_to_transition. Returns a dict with canonical field names used throughout LeRobot.
+
+    Converts an EnvTransition back to the batch format expected by datasets, dataloaders,
+    and other LeRobot components.
+
+    Output format:
+    * "action": Action data from transition
+    * "next.reward": Reward value (defaults to 0.0)
+    * "next.done": Done flag (defaults to False)
+    * "next.truncated": Truncated flag (defaults to False)
+    * "info": Info dictionary (defaults to {})
+    * Flattened observation keys (e.g., "observation.state", "observation.images.cam1")
+    * Complementary data fields ("task", "index", "task_index", padding flags)
+
+    Args:
+        transition: EnvTransition dictionary to convert.
+
+    Returns:
+        Batch dictionary with canonical LeRobot field names suitable for dataloaders.
+    """
+    batch = {
+        "action": transition.get(TransitionKey.ACTION),
+        "next.reward": transition.get(TransitionKey.REWARD, 0.0),
+        "next.done": transition.get(TransitionKey.DONE, False),
+        "next.truncated": transition.get(TransitionKey.TRUNCATED, False),
+        "info": transition.get(TransitionKey.INFO, {}),
+    }
+
+    # Add complementary data
+    comp_data = transition.get(TransitionKey.COMPLEMENTARY_DATA, {})
+    if comp_data:
+        batch.update(comp_data)
+
+    # Flatten observation dict
+    observation = transition.get(TransitionKey.OBSERVATION)
+    if isinstance(observation, dict):
+        batch.update(observation)
+
+    return batch

src/lerobot/processor/core.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+# 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.
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, TypedDict
+
+import torch
+
+
+class TransitionKey(str, Enum):
+    """Keys for accessing EnvTransition dictionary components."""
+
+    # TODO(Steven): Use consts
+    OBSERVATION = "observation"
+    ACTION = "action"
+    REWARD = "reward"
+    DONE = "done"
+    TRUNCATED = "truncated"
+    INFO = "info"
+    COMPLEMENTARY_DATA = "complementary_data"
+
+
+EnvTransition = TypedDict(
+    "EnvTransition",
+    {
+        TransitionKey.OBSERVATION.value: dict[str, Any] | None,
+        TransitionKey.ACTION.value: Any | torch.Tensor | None,
+        TransitionKey.REWARD.value: float | torch.Tensor | None,
+        TransitionKey.DONE.value: bool | torch.Tensor | None,
+        TransitionKey.TRUNCATED.value: bool | torch.Tensor | None,
+        TransitionKey.INFO.value: dict[str, Any] | None,
+        TransitionKey.COMPLEMENTARY_DATA.value: dict[str, Any] | None,
+    },
+)

src/lerobot/processor/delta_action_processor.py

@@ -19,36 +19,46 @@ from dataclasses import dataclass
 from torch import Tensor
 
 from lerobot.configs.types import FeatureType, PolicyFeature
-from lerobot.processor.pipeline import ActionProcessor, ProcessorStepRegistry
+from lerobot.constants import ACTION
+
+from .pipeline import ActionProcessorStep, ProcessorStepRegistry
 
 
 @ProcessorStepRegistry.register("map_tensor_to_delta_action_dict")
 @dataclass
-class MapTensorToDeltaActionDict(ActionProcessor):
+class MapTensorToDeltaActionDictStep(ActionProcessorStep):
     """
     Map a tensor to a delta action dictionary.
     """
 
+    use_gripper: bool = True
+
     def action(self, action: Tensor) -> dict:
-        if isinstance(action, dict):
-            return action
         if action.dim() > 1:
             action = action.squeeze(0)
 
         # TODO (maractingi): add rotation
         delta_action = {
-            "action.delta_x": action[0],
-            "action.delta_y": action[1],
-            "action.delta_z": action[2],
+            f"{ACTION}.delta_x": action[0],
+            f"{ACTION}.delta_y": action[1],
+            f"{ACTION}.delta_z": action[2],
         }
-        if action.shape[0] > 3:
-            delta_action["action.gripper"] = action[3]
+        if self.use_gripper:
+            delta_action[f"{ACTION}.gripper"] = action[3]
         return delta_action
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        features[f"{ACTION}.delta_x"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.delta_y"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.delta_z"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        if self.use_gripper:
+            features[f"{ACTION}.gripper"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        return features
+
 
 @ProcessorStepRegistry.register("map_delta_action_to_robot_action")
 @dataclass
-class MapDeltaActionToRobotAction(ActionProcessor):
+class MapDeltaActionToRobotActionStep(ActionProcessorStep):
     """
     Map delta actions from teleoperators (gamepad, keyboard) to robot target actions
     for use with inverse kinematics processors.
@@ -82,10 +92,10 @@ class MapDeltaActionToRobotAction(ActionProcessor):
     def action(self, action: dict) -> dict:
         # NOTE (maractingi): Action can be a dict from the teleop_devices or a tensor from the policy
         # TODO (maractingi): changing this target_xyz naming convention from the teleop_devices
-        delta_x = action.pop("action.delta_x", 0.0)
-        delta_y = action.pop("action.delta_y", 0.0)
-        delta_z = action.pop("action.delta_z", 0.0)
-        gripper = action.pop("action.gripper", 1.0)  # Default to "stay" (1.0)
+        delta_x = action.pop(f"{ACTION}.delta_x", 0.0)
+        delta_y = action.pop(f"{ACTION}.delta_y", 0.0)
+        delta_z = action.pop(f"{ACTION}.delta_z", 0.0)
+        gripper = action.pop(f"{ACTION}.gripper", 1.0)  # Default to "stay" (1.0)
 
         # Determine if the teleoperator is actively providing input
         # Consider enabled if any significant movement delta is detected
@@ -105,31 +115,31 @@ class MapDeltaActionToRobotAction(ActionProcessor):
 
         # Update action with robot target format
         action = {
-            "action.enabled": enabled,
-            "action.target_x": scaled_delta_x,
-            "action.target_y": scaled_delta_y,
-            "action.target_z": scaled_delta_z,
-            "action.target_wx": target_wx,
-            "action.target_wy": target_wy,
-            "action.target_wz": target_wz,
-            "action.gripper": float(gripper),
+            f"{ACTION}.enabled": enabled,
+            f"{ACTION}.target_x": scaled_delta_x,
+            f"{ACTION}.target_y": scaled_delta_y,
+            f"{ACTION}.target_z": scaled_delta_z,
+            f"{ACTION}.target_wx": target_wx,
+            f"{ACTION}.target_wy": target_wy,
+            f"{ACTION}.target_wz": target_wz,
+            f"{ACTION}.gripper": float(gripper),
         }
 
         return action
 
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
         """Transform features to match output format."""
-        # Update features to reflect the new action format
-        features.update(
-            {
-                "action.enabled": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.target_x": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.target_y": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.target_z": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.target_wx": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.target_wy": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.target_wz": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-                "action.gripper": PolicyFeature(type=FeatureType.ACTION, shape=(1,)),
-            }
-        )
+        features.pop(f"{ACTION}.delta_x", None)
+        features.pop(f"{ACTION}.delta_y", None)
+        features.pop(f"{ACTION}.delta_z", None)
+        features.pop(f"{ACTION}.gripper", None)
+
+        features[f"{ACTION}.enabled"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_x"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_y"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_z"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_wx"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_wy"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_wz"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.gripper"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
         return features

src/lerobot/processor/device_processor.py

@@ -18,13 +18,16 @@ from typing import Any
 
 import torch
 
-from lerobot.processor.pipeline import EnvTransition, ProcessorStep, ProcessorStepRegistry, TransitionKey
+from lerobot.configs.types import PolicyFeature
 from lerobot.utils.utils import get_safe_torch_device
 
+from .core import EnvTransition, TransitionKey
+from .pipeline import ProcessorStep, ProcessorStepRegistry
+
 
 @ProcessorStepRegistry.register("device_processor")
 @dataclass
-class DeviceProcessor(ProcessorStep):
+class DeviceProcessorStep(ProcessorStep):
     """Processes transitions by moving tensors to the specified device and optionally converting float dtypes.
 
     This processor ensures that all tensors in the transition are moved to the
@@ -47,8 +50,8 @@ class DeviceProcessor(ProcessorStep):
     }
 
     def __post_init__(self):
-        self._device: torch.device = get_safe_torch_device(self.device)
-        self.device = self._device.type  # cuda might have changed to cuda:1
+        self.tensor_device: torch.device = get_safe_torch_device(self.device)
+        self.device = self.tensor_device.type  # cuda might have changed to cuda:1
         self.non_blocking = "cuda" in str(self.device)
 
         # Validate and convert float_dtype string to torch dtype
@@ -70,7 +73,7 @@ class DeviceProcessor(ProcessorStep):
         Otherwise, it moves to the configured device.
         """
         # Determine target device
-        if tensor.is_cuda and self._device.type == "cuda":
+        if tensor.is_cuda and self.tensor_device.type == "cuda":
             # Both tensor and target are on GPU - preserve tensor's GPU placement
             # This handles multi-GPU scenarios where Accelerate has already placed
             # tensors on the correct GPU for each process
@@ -78,7 +81,7 @@ class DeviceProcessor(ProcessorStep):
         else:
             # Either tensor is on CPU, or we're configured for CPU
             # In both cases, use the configured device
-            target_device = self._device
+            target_device = self.tensor_device
 
         # Only move if necessary
         if tensor.device != target_device:
@@ -126,3 +129,6 @@ class DeviceProcessor(ProcessorStep):
     def get_config(self) -> dict[str, Any]:
         """Return configuration for serialization."""
         return {"device": self.device, "float_dtype": self.float_dtype}
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features

src/lerobot/processor/gym_action_processor.py

@@ -16,13 +16,15 @@ from dataclasses import dataclass
 import numpy as np
 import torch
 
-from lerobot.processor.converters import to_tensor
-from lerobot.processor.pipeline import ActionProcessor, ProcessorStepRegistry
+from lerobot.configs.types import PolicyFeature
+
+from .converters import to_tensor
+from .pipeline import ActionProcessorStep, ProcessorStepRegistry
 
 
 @ProcessorStepRegistry.register("torch2numpy_action_processor")
 @dataclass
-class Torch2NumpyActionProcessor(ActionProcessor):
+class Torch2NumpyActionProcessorStep(ActionProcessorStep):
     """Convert PyTorch tensor actions to NumPy arrays."""
 
     squeeze_batch_dim: bool = True
@@ -48,10 +50,13 @@ class Torch2NumpyActionProcessor(ActionProcessor):
 
         return numpy_action
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @ProcessorStepRegistry.register("numpy2torch_action_processor")
 @dataclass
-class Numpy2TorchActionProcessor(ActionProcessor):
+class Numpy2TorchActionProcessorStep(ActionProcessorStep):
     """Convert NumPy array action to PyTorch tensor."""
 
     def action(self, action: np.ndarray) -> torch.Tensor:
@@ -62,3 +67,6 @@ class Numpy2TorchActionProcessor(ActionProcessor):
             )
         torch_action = to_tensor(action, dtype=None)  # Preserve original dtype
         return torch_action
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features

src/lerobot/processor/hil_processor.py

@@ -9,19 +9,19 @@ import torchvision.transforms.functional as F  # noqa: N812
 
 from lerobot.configs.types import PolicyFeature
 from lerobot.constants import ACTION
-from lerobot.processor.pipeline import (
-    ComplementaryDataProcessor,
-    EnvTransition,
-    InfoProcessor,
-    ObservationProcessor,
-    ProcessorStep,
-    ProcessorStepRegistry,
-    TransitionKey,
-    TruncatedProcessor,
-)
 from lerobot.teleoperators.teleoperator import Teleoperator
 from lerobot.teleoperators.utils import TeleopEvents
 
+from .core import EnvTransition, TransitionKey
+from .pipeline import (
+    ComplementaryDataProcessorStep,
+    InfoProcessorStep,
+    ObservationProcessorStep,
+    ProcessorStep,
+    ProcessorStepRegistry,
+    TruncatedProcessorStep,
+)
+
 GRIPPER_KEY = "gripper"
 DISCRETE_PENALTY_KEY = "discrete_penalty"
 TELEOP_ACTION_KEY = "teleop_action"
@@ -29,7 +29,7 @@ TELEOP_ACTION_KEY = "teleop_action"
 
 @ProcessorStepRegistry.register("add_teleop_action_as_complementary_data")
 @dataclass
-class AddTeleopActionAsComplimentaryData(ComplementaryDataProcessor):
+class AddTeleopActionAsComplimentaryDataStep(ComplementaryDataProcessorStep):
     """Add teleoperator action to transition complementary data."""
 
     teleop_device: Teleoperator
@@ -39,10 +39,13 @@ class AddTeleopActionAsComplimentaryData(ComplementaryDataProcessor):
         new_complementary_data[TELEOP_ACTION_KEY] = self.teleop_device.get_action()
         return new_complementary_data
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @ProcessorStepRegistry.register("add_teleop_action_as_info")
 @dataclass
-class AddTeleopEventsAsInfo(InfoProcessor):
+class AddTeleopEventsAsInfoStep(InfoProcessorStep):
     """Add teleoperator control events to transition info."""
 
     teleop_device: Teleoperator
@@ -53,10 +56,13 @@ class AddTeleopEventsAsInfo(InfoProcessor):
         new_info.update(teleop_events)
         return new_info
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @ProcessorStepRegistry.register("image_crop_resize_processor")
 @dataclass
-class ImageCropResizeProcessor(ObservationProcessor):
+class ImageCropResizeProcessorStep(ObservationProcessorStep):
     """Crop and resize image observations."""
 
     crop_params_dict: dict[str, tuple[int, int, int, int]] | None = None
@@ -106,7 +112,7 @@ class ImageCropResizeProcessor(ObservationProcessor):
 
 @dataclass
 @ProcessorStepRegistry.register("time_limit_processor")
-class TimeLimitProcessor(TruncatedProcessor):
+class TimeLimitProcessorStep(TruncatedProcessorStep):
     """Track episode steps and enforce time limits."""
 
     max_episode_steps: int
@@ -127,10 +133,13 @@ class TimeLimitProcessor(TruncatedProcessor):
     def reset(self) -> None:
         self.current_step = 0
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register("gripper_penalty_processor")
-class GripperPenaltyProcessor(ComplementaryDataProcessor):
+class GripperPenaltyProcessorStep(ComplementaryDataProcessorStep):
     """Apply penalty for inappropriate gripper usage."""
 
     penalty: float = -0.01
@@ -173,10 +182,13 @@ class GripperPenaltyProcessor(ComplementaryDataProcessor):
         """Reset the processor state."""
         self.last_gripper_state = None
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register("intervention_action_processor")
-class InterventionActionProcessor(ProcessorStep):
+class InterventionActionProcessorStep(ProcessorStep):
     """Handle human intervention actions and episode termination."""
 
     use_gripper: bool = False
@@ -243,10 +255,13 @@ class InterventionActionProcessor(ProcessorStep):
             "terminate_on_success": self.terminate_on_success,
         }
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register("reward_classifier_processor")
-class RewardClassifierProcessor(ProcessorStep):
+class RewardClassifierProcessorStep(ProcessorStep):
     """Apply reward classification to image observations."""
 
     pretrained_path: str | None = None
@@ -267,15 +282,16 @@ class RewardClassifierProcessor(ProcessorStep):
             self.reward_classifier.eval()
 
     def __call__(self, transition: EnvTransition) -> EnvTransition:
-        observation = transition.get(TransitionKey.OBSERVATION)
+        new_transition = transition.copy()
+        observation = new_transition.get(TransitionKey.OBSERVATION)
         if observation is None or self.reward_classifier is None:
-            return transition
+            return new_transition
 
         # Extract images from observation
         images = {key: value for key, value in observation.items() if "image" in key}
 
         if not images:
-            return transition
+            return new_transition
 
         # Run reward classifier
         start_time = time.perf_counter()
@@ -285,8 +301,8 @@ class RewardClassifierProcessor(ProcessorStep):
         classifier_frequency = 1 / (time.perf_counter() - start_time)
 
         # Calculate reward and termination
-        reward = transition.get(TransitionKey.REWARD, 0.0)
-        terminated = transition.get(TransitionKey.DONE, False)
+        reward = new_transition.get(TransitionKey.REWARD, 0.0)
+        terminated = new_transition.get(TransitionKey.DONE, False)
 
         if math.isclose(success, 1, abs_tol=1e-2):
             reward = self.success_reward
@@ -294,7 +310,6 @@ class RewardClassifierProcessor(ProcessorStep):
                 terminated = True
 
         # Update transition
-        new_transition = transition.copy()
         new_transition[TransitionKey.REWARD] = reward
         new_transition[TransitionKey.DONE] = terminated
 
@@ -312,3 +327,6 @@ class RewardClassifierProcessor(ProcessorStep):
             "success_reward": self.success_reward,
             "terminate_on_success": self.terminate_on_success,
         }
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features

src/lerobot/processor/joint_observations_processor.py

@@ -4,8 +4,9 @@ from typing import Any
 import torch
 
 from lerobot.configs.types import PolicyFeature
+from lerobot.constants import OBS_STATE
 from lerobot.processor.pipeline import (
-    ObservationProcessor,
+    ObservationProcessorStep,
     ProcessorStepRegistry,
 )
 from lerobot.robots import Robot
@@ -13,7 +14,7 @@ from lerobot.robots import Robot
 
 @dataclass
 @ProcessorStepRegistry.register("joint_velocity_processor")
-class JointVelocityProcessor(ObservationProcessor):
+class JointVelocityProcessorStep(ObservationProcessorStep):
     """Add joint velocity information to observations."""
 
     dt: float = 0.1
@@ -22,10 +23,10 @@ class JointVelocityProcessor(ObservationProcessor):
 
     def observation(self, observation: dict) -> dict:
         # Get current joint positions (assuming they're in observation.state)
-        current_positions = observation.get("observation.state")
+        current_positions = observation.get(OBS_STATE)
         if current_positions is None:
             # TODO(steven): if we get here, then the transform_features method will not hold
-            return observation
+            raise ValueError(f"{OBS_STATE} is not in observation")
 
         # Initialize last joint positions if not already set
         if self.last_joint_positions is None:
@@ -42,7 +43,7 @@ class JointVelocityProcessor(ObservationProcessor):
 
         # Create new observation dict
         new_observation = dict(observation)
-        new_observation["observation.state"] = extended_state
+        new_observation[OBS_STATE] = extended_state
 
         return new_observation
 
@@ -55,18 +56,18 @@ class JointVelocityProcessor(ObservationProcessor):
         self.last_joint_positions = None
 
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
-        if "observation.state" in features:
-            original_feature = features["observation.state"]
+        if OBS_STATE in features:
+            original_feature = features[OBS_STATE]
             # Double the shape to account for positions + velocities
             new_shape = (original_feature.shape[0] * 2,) + original_feature.shape[1:]
 
-            features["observation.state"] = PolicyFeature(type=original_feature.type, shape=new_shape)
+            features[OBS_STATE] = PolicyFeature(type=original_feature.type, shape=new_shape)
         return features
 
 
 @dataclass
 @ProcessorStepRegistry.register("current_processor")
-class MotorCurrentProcessor(ObservationProcessor):
+class MotorCurrentProcessorStep(ObservationProcessorStep):
     """Add motor current information to observations."""
 
     robot: Robot | None = None
@@ -74,14 +75,15 @@ class MotorCurrentProcessor(ObservationProcessor):
     def observation(self, observation: dict) -> dict:
         # Get current values from robot state
         if self.robot is None:
-            return observation
+            raise ValueError("Robot is not set")
+
         present_current_dict = self.robot.bus.sync_read("Present_Current")  # type: ignore[attr-defined]
         motor_currents = torch.tensor(
             [present_current_dict[name] for name in self.robot.bus.motors],  # type: ignore[attr-defined]
             dtype=torch.float32,
         ).unsqueeze(0)
 
-        current_state = observation.get("observation.state")
+        current_state = observation.get(OBS_STATE)
         if current_state is None:
             return observation
 
@@ -89,15 +91,13 @@ class MotorCurrentProcessor(ObservationProcessor):
 
         # Create new observation dict
         new_observation = dict(observation)
-        new_observation["observation.state"] = extended_state
+        new_observation[OBS_STATE] = extended_state
 
         return new_observation
 
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
-        if "observation.state" in features and self.robot is not None:
-            from lerobot.configs.types import PolicyFeature
-
-            original_feature = features["observation.state"]
+        if OBS_STATE in features and self.robot is not None:
+            original_feature = features[OBS_STATE]
             # Add motor current dimensions to the original state shape
             num_motors = 0
             if hasattr(self.robot, "bus") and hasattr(self.robot.bus, "motors"):  # type: ignore[attr-defined]
@@ -105,5 +105,5 @@ class MotorCurrentProcessor(ObservationProcessor):
 
             if num_motors > 0:
                 new_shape = (original_feature.shape[0] + num_motors,) + original_feature.shape[1:]
-                features["observation.state"] = PolicyFeature(type=original_feature.type, shape=new_shape)
+                features[OBS_STATE] = PolicyFeature(type=original_feature.type, shape=new_shape)
         return features

src/lerobot/processor/migrate_policy_normalization.py

@@ -46,11 +46,12 @@ from huggingface_hub import hf_hub_download
 from safetensors.torch import load_file as load_safetensors
 
 from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
-from lerobot.processor.batch_processor import ToBatchProcessor
-from lerobot.processor.device_processor import DeviceProcessor
-from lerobot.processor.normalize_processor import NormalizerProcessor, UnnormalizerProcessor
-from lerobot.processor.pipeline import RobotProcessor
-from lerobot.processor.rename_processor import RenameProcessor
+
+from .batch_processor import AddBatchDimensionProcessorStep
+from .device_processor import DeviceProcessorStep
+from .normalize_processor import NormalizerProcessorStep, UnnormalizerProcessorStep
+from .pipeline import PolicyProcessorPipeline
+from .rename_processor import RenameProcessorStep
 
 # Policy type to class mapping
 POLICY_CLASSES = {
@@ -403,8 +404,8 @@ def main():
     # Now create preprocessor and postprocessor with cleaned_config available
     print("Creating preprocessor and postprocessor...")
     # The pattern from existing processor factories:
-    # - Preprocessor has two NormalizerProcessors: one for input_features, one for output_features
-    # - Postprocessor has one UnnormalizerProcessor for output_features only
+    # - Preprocessor has two NormalizerProcessorSteps: one for input_features, one for output_features
+    # - Postprocessor has one UnnormalizerProcessorStep for output_features only
 
     # Get features from cleaned_config (now they're PolicyFeature objects)
     input_features = cleaned_config.get("input_features", {})
@@ -412,23 +413,23 @@ def main():
 
     # Create preprocessor with two normalizers (following the pattern from processor factories)
     preprocessor_steps = [
-        RenameProcessor(rename_map={}),
-        NormalizerProcessor(
+        RenameProcessorStep(rename_map={}),
+        NormalizerProcessorStep(
             features={**input_features, **output_features},
             norm_map=norm_map,
             stats=stats,
         ),
-        ToBatchProcessor(),
-        DeviceProcessor(device=policy_config.device),
+        AddBatchDimensionProcessorStep(),
+        DeviceProcessorStep(device=policy_config.device),
     ]
-    preprocessor = RobotProcessor(steps=preprocessor_steps, name="robot_preprocessor")
+    preprocessor = PolicyProcessorPipeline(steps=preprocessor_steps, name="robot_preprocessor")
 
     # Create postprocessor with unnormalizer for outputs only
     postprocessor_steps = [
-        DeviceProcessor(device="cpu"),
-        UnnormalizerProcessor(features=output_features, norm_map=norm_map, stats=stats),
+        DeviceProcessorStep(device="cpu"),
+        UnnormalizerProcessorStep(features=output_features, norm_map=norm_map, stats=stats),
     ]
-    postprocessor = RobotProcessor(steps=postprocessor_steps, name="robot_postprocessor")
+    postprocessor = PolicyProcessorPipeline(steps=postprocessor_steps, name="robot_postprocessor")
 
     # Determine hub repo ID if pushing to hub
     if args.push_to_hub:

src/lerobot/processor/normalize_processor.py

@@ -9,14 +9,10 @@ from torch import Tensor
 
 from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.processor.converters import to_tensor
-from lerobot.processor.pipeline import (
-    EnvTransition,
-    ProcessorStep,
-    ProcessorStepRegistry,
-    RobotProcessor,
-    TransitionKey,
-)
+
+from .converters import to_tensor
+from .core import EnvTransition, TransitionKey
+from .pipeline import PolicyProcessorPipeline, ProcessorStep, ProcessorStepRegistry
 
 
 @dataclass
@@ -165,7 +161,7 @@ class _NormalizationMixin:
 
 @dataclass
 @ProcessorStepRegistry.register(name="normalizer_processor")
-class NormalizerProcessor(_NormalizationMixin, ProcessorStep):
+class NormalizerProcessorStep(_NormalizationMixin, ProcessorStep):
     """
     A processor that applies normalization to observations and actions in a transition.
 
@@ -184,7 +180,7 @@ class NormalizerProcessor(_NormalizationMixin, ProcessorStep):
         normalize_observation_keys: set[str] | None = None,
         eps: float = 1e-8,
         device: torch.device | str | None = None,
-    ) -> NormalizerProcessor:
+    ) -> NormalizerProcessorStep:
         return cls(
             features=features,
             norm_map=norm_map,
@@ -211,10 +207,13 @@ class NormalizerProcessor(_NormalizationMixin, ProcessorStep):
 
         return new_transition
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
+
 
 @dataclass
 @ProcessorStepRegistry.register(name="unnormalizer_processor")
-class UnnormalizerProcessor(_NormalizationMixin, ProcessorStep):
+class UnnormalizerProcessorStep(_NormalizationMixin, ProcessorStep):
     """
     A processor that applies unnormalization (the inverse of normalization) to
     observations and actions in a transition.
@@ -231,7 +230,7 @@ class UnnormalizerProcessor(_NormalizationMixin, ProcessorStep):
         norm_map: dict[FeatureType, NormalizationMode],
         *,
         device: torch.device | str | None = None,
-    ) -> UnnormalizerProcessor:
+    ) -> UnnormalizerProcessorStep:
         return cls(features=features, norm_map=norm_map, stats=dataset.meta.stats, device=device)
 
     def __call__(self, transition: EnvTransition) -> EnvTransition:
@@ -249,17 +248,22 @@ class UnnormalizerProcessor(_NormalizationMixin, ProcessorStep):
 
         return new_transition
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features
 
-def hotswap_stats(robot_processor: RobotProcessor, stats: dict[str, dict[str, Any]]) -> RobotProcessor:
+
+def hotswap_stats(
+    policy_processor: PolicyProcessorPipeline, stats: dict[str, dict[str, Any]]
+) -> PolicyProcessorPipeline:
     """
-    Replaces normalization statistics in a RobotProcessor pipeline.
+    Replaces normalization statistics in a PolicyProcessor pipeline.
 
-    This function creates a deep copy of the provided `RobotProcessor` and updates the
-    statistics of any `NormalizerProcessor` or `UnnormalizerProcessor` steps within it.
+    This function creates a deep copy of the provided `PolicyProcessorPipeline` and updates the
+    statistics of any `NormalizerProcessorStep` or `UnnormalizerProcessorStep` steps within it.
     It's useful for adapting a trained policy to a new environment or dataset with
     different data distributions.
     """
-    rp = deepcopy(robot_processor)
+    rp = deepcopy(policy_processor)
     for step in rp.steps:
         if isinstance(step, _NormalizationMixin):
             step.stats = stats

src/lerobot/processor/observation_processor.py

@@ -22,12 +22,13 @@ from torch import Tensor
 
 from lerobot.configs.types import PolicyFeature
 from lerobot.constants import OBS_ENV_STATE, OBS_IMAGE, OBS_IMAGES, OBS_STATE
-from lerobot.processor.pipeline import ObservationProcessor, ProcessorStepRegistry
+
+from .pipeline import ObservationProcessorStep, ProcessorStepRegistry
 
 
 @dataclass
 @ProcessorStepRegistry.register(name="observation_processor")
-class VanillaObservationProcessor(ObservationProcessor):
+class VanillaObservationProcessorStep(ObservationProcessorStep):
     """
     Processes environment observations into the LeRobot format by handling both images and states.
 

src/lerobot/processor/pipeline.py

@@ -22,48 +22,22 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Sequence
 from copy import deepcopy
 from dataclasses import dataclass, field
-from enum import Enum
 from pathlib import Path
-from typing import Any, Generic, TypedDict, TypeVar, cast
+from typing import Any, Generic, TypeAlias, TypedDict, TypeVar, cast
 
 import torch
 from huggingface_hub import ModelHubMixin, hf_hub_download
-from huggingface_hub.errors import HfHubHTTPError
 from safetensors.torch import load_file, save_file
 
 from lerobot.configs.types import PolicyFeature
 
+from .converters import batch_to_transition, create_transition, transition_to_batch
+from .core import EnvTransition, TransitionKey
+
 # Type variable for generic processor output type
 TOutput = TypeVar("TOutput")
 
 
-class TransitionKey(str, Enum):
-    """Keys for accessing EnvTransition dictionary components."""
-
-    # TODO(Steven): Use consts
-    OBSERVATION = "observation"
-    ACTION = "action"
-    REWARD = "reward"
-    DONE = "done"
-    TRUNCATED = "truncated"
-    INFO = "info"
-    COMPLEMENTARY_DATA = "complementary_data"
-
-
-EnvTransition = TypedDict(
-    "EnvTransition",
-    {
-        TransitionKey.OBSERVATION.value: dict[str, Any] | None,
-        TransitionKey.ACTION.value: Any | torch.Tensor | None,
-        TransitionKey.REWARD.value: float | torch.Tensor | None,
-        TransitionKey.DONE.value: bool | torch.Tensor | None,
-        TransitionKey.TRUNCATED.value: bool | torch.Tensor | None,
-        TransitionKey.INFO.value: dict[str, Any] | None,
-        TransitionKey.COMPLEMENTARY_DATA.value: dict[str, Any] | None,
-    },
-)
-
-
 class ProcessorStepRegistry:
     """Registry for processor steps that enables saving/loading by name instead of module path."""
 
@@ -142,7 +116,7 @@ class ProcessorStep(ABC):
     A step is any callable accepting a full `EnvTransition` dict and
     returning a (possibly modified) dict of the same structure. Implementers
     are encouraged—but not required—to expose the optional helper methods
-    listed below. When present, these hooks let `RobotProcessor`
+    listed below. When present, these hooks let `DataProcessorPipeline`
     automatically serialise the step's configuration and learnable state using
     a safe-to-share JSON + SafeTensors format.
 
@@ -194,107 +168,20 @@ class ProcessorStep(ABC):
     def reset(self) -> None:
         return None
 
-    # TODO(Steven): Consider making this abstract so it is more explicit
+    @abstractmethod
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
         return features
 
 
-def _default_batch_to_transition(batch: dict[str, Any]) -> EnvTransition:  # noqa: D401
-    """Convert a *batch* dict coming from Learobot replay/dataset code into an
-    ``EnvTransition`` dictionary.
-
-    The function maps well known keys to the EnvTransition structure. Missing keys are
-    filled with sane defaults (``None`` or ``0.0``/``False``).
-
-    Keys recognised (case-sensitive):
-
-    * "observation.*" (keys starting with "observation." are grouped into observation dict)
-    * "action"
-    * "next.reward"
-    * "next.done"
-    * "next.truncated"
-    * "info"
-
-    Additional keys are ignored so that existing dataloaders can carry extra
-    metadata without breaking the processor.
-    """
-
-    # Validate input type
-    if not isinstance(batch, dict):
-        raise ValueError(f"EnvTransition must be a dictionary. Got {type(batch).__name__}")
-
-    # Extract observation keys
-    observation_keys = {k: v for k, v in batch.items() if k.startswith("observation.")}
-    observation = observation_keys if observation_keys else None
-
-    # Extract padding, task, index, and task_index keys for complementary data
-    pad_keys = {k: v for k, v in batch.items() if "_is_pad" in k}
-    task_key = {"task": batch["task"]} if "task" in batch else {}
-    index_key = {"index": batch["index"]} if "index" in batch else {}
-    task_index_key = {"task_index": batch["task_index"]} if "task_index" in batch else {}
-    complementary_data = (
-        {**pad_keys, **task_key, **index_key, **task_index_key}
-        if pad_keys or task_key or index_key or task_index_key
-        else {}
-    )
-
-    transition: EnvTransition = {
-        TransitionKey.OBSERVATION: observation,
-        TransitionKey.ACTION: batch.get("action"),
-        TransitionKey.REWARD: batch.get("next.reward", 0.0),
-        TransitionKey.DONE: batch.get("next.done", False),
-        TransitionKey.TRUNCATED: batch.get("next.truncated", False),
-        TransitionKey.INFO: batch.get("info", {}),
-        TransitionKey.COMPLEMENTARY_DATA: complementary_data,
-    }
-    return transition
-
-
-def _default_transition_to_batch(transition: EnvTransition) -> dict[str, Any]:  # noqa: D401
-    """Inverse of :pyfunc:`_default_batch_to_transition`. Returns a dict with
-    the canonical field names used throughout *LeRobot*.
-    """
-
-    batch = {
-        "action": transition.get(TransitionKey.ACTION),
-        "next.reward": transition.get(TransitionKey.REWARD, 0.0),
-        "next.done": transition.get(TransitionKey.DONE, False),
-        "next.truncated": transition.get(TransitionKey.TRUNCATED, False),
-        "info": transition.get(TransitionKey.INFO, {}),
-    }
-
-    # Add padding, task, index, and task_index data from complementary_data
-    complementary_data = transition.get(TransitionKey.COMPLEMENTARY_DATA)
-    if complementary_data:
-        pad_data = {k: v for k, v in complementary_data.items() if "_is_pad" in k}
-        batch.update(pad_data)
-
-        if "task" in complementary_data:
-            batch["task"] = complementary_data["task"]
-
-        if "index" in complementary_data:
-            batch["index"] = complementary_data["index"]
-
-        if "task_index" in complementary_data:
-            batch["task_index"] = complementary_data["task_index"]
-
-    # Handle observation - flatten dict to observation.* keys if it's a dict
-    observation = transition.get(TransitionKey.OBSERVATION)
-    if isinstance(observation, dict):
-        batch.update(observation)
-
-    return batch
-
-
 class ProcessorKwargs(TypedDict, total=False):
-    """Keyword arguments for RobotProcessor constructor."""
+    """Keyword arguments for DataProcessorPipeline constructor."""
 
     to_transition: Callable[[dict[str, Any]], EnvTransition] | None
     to_output: Callable[[EnvTransition], Any] | None
 
 
 @dataclass
-class RobotProcessor(ModelHubMixin, Generic[TOutput]):
+class DataProcessorPipeline(ModelHubMixin, Generic[TOutput]):
     """
     Composable, debuggable post-processing processor for robot transitions.
 
@@ -308,7 +195,7 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
     Args:
         steps: Ordered list of processing steps executed on every call. Defaults to empty list.
         name: Human-readable identifier that is persisted inside the JSON config.
-            Defaults to "RobotProcessor".
+            Defaults to "DataProcessorPipeline".
         to_transition: Function to convert batch dict to EnvTransition dict.
             Defaults to _default_batch_to_transition.
         to_output: Function to convert EnvTransition dict to the desired output format of type TOutput.
@@ -322,18 +209,20 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
     Type Safety Examples:
         ```python
         # Default behavior - returns batch dict
-        processor: RobotProcessor[dict[str, Any]] = RobotProcessor(steps=[some_step1, some_step2])
+        processor: DataProcessorPipeline[dict[str, Any]] = DataProcessorPipeline(
+            steps=[some_step1, some_step2]
+        )
         result: dict[str, Any] = processor(batch_data)  # Type checker knows this is a dict
 
         # For EnvTransition output, explicitly specify identity function
-        transition_processor: RobotProcessor[EnvTransition] = RobotProcessor(
+        transition_processor: DataProcessorPipeline[EnvTransition] = DataProcessorPipeline(
             steps=[some_step1, some_step2],
             to_output=lambda x: x,  # Identity function
         )
         result: EnvTransition = transition_processor(batch_data)  # Type checker knows this is EnvTransition
 
         # For custom output types
-        processor: RobotProcessor[str] = RobotProcessor(
+        processor: DataProcessorPipeline[str] = DataProcessorPipeline(
             steps=[custom_step], to_output=lambda t: f"Processed {len(t)} keys"
         )
         result: str = processor(batch_data)  # Type checker knows this is str
@@ -355,17 +244,15 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
     """
 
     steps: Sequence[ProcessorStep] = field(default_factory=list)
-    name: str = "RobotProcessor"
+    name: str = "DataProcessorPipeline"
 
-    to_transition: Callable[[dict[str, Any]], EnvTransition] = field(
-        default_factory=lambda: _default_batch_to_transition, repr=False
-    )
+    to_transition: Callable[[dict[str, Any]], EnvTransition] = field(default=batch_to_transition, repr=False)
     to_output: Callable[[EnvTransition], TOutput] = field(
         # Cast is necessary here: Working around Python type-checker limitation.
         # _default_transition_to_batch returns dict[str, Any], but we need it to be TOutput
         # for the generic to work. When no explicit type is given, TOutput defaults to dict[str, Any],
         # making this cast safe.
-        default_factory=lambda: cast(Callable[[EnvTransition], TOutput], _default_transition_to_batch),
+        default_factory=lambda: cast(Callable[[EnvTransition], TOutput], transition_to_batch),
         repr=False,
     )
 
@@ -390,6 +277,12 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
         # Always convert input through to_transition
         transition = self.to_transition(data)
 
+        transformed_transition = self._forward(transition)
+
+        # Always use to_output for consistent typing
+        return self.to_output(transformed_transition)
+
+    def _forward(self, transition: EnvTransition) -> EnvTransition:
         # Process through all steps
         for idx, processor_step in enumerate(self.steps):
             # Apply before hooks
@@ -402,9 +295,7 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
             # Apply after hooks
             for hook in self.after_step_hooks:
                 hook(idx, transition)
-
-        # Always use to_output for consistent typing
-        return self.to_output(transition)
+        return transition
 
     def step_through(self, data: dict[str, Any]) -> Iterable[EnvTransition]:
         """Yield the intermediate results after each processor step.
@@ -529,7 +420,7 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
         to_transition: Callable[[dict[str, Any]], EnvTransition] | None = None,
         to_output: Callable[[EnvTransition], TOutput] | None = None,
         **kwargs,
-    ) -> RobotProcessor[TOutput]:
+    ) -> DataProcessorPipeline[TOutput]:
         """Load a serialized processor from source (local path or Hugging Face Hub identifier).
 
         Args:
@@ -537,7 +428,7 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
                 (e.g., "username/processor-name").
             config_filename: Optional specific config filename to load. If not provided, will:
                 - For local paths: look for any .json file in the directory (error if multiple found)
-                - For HF Hub: try common names ("processor.json", "preprocessor.json", "postprocessor.json")
+                - For HF Hub: REQUIRED - you must specify the exact config filename
             overrides: Optional dictionary mapping step names to configuration overrides.
                 Keys must match exact step class names (for unregistered steps) or registry names
                 (for registered steps). Values are dictionaries containing parameter overrides
@@ -550,7 +441,7 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
                 Use identity function (lambda x: x) for EnvTransition output.
 
         Returns:
-            A RobotProcessor[TOutput] instance loaded from the saved configuration.
+            A DataProcessorPipeline[TOutput] instance loaded from the saved configuration.
 
         Raises:
             ImportError: If a processor step class cannot be loaded or imported.
@@ -560,13 +451,13 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
         Examples:
             Basic loading:
             ```python
-            processor = RobotProcessor.from_pretrained("path/to/processor")
+            processor = DataProcessorPipeline.from_pretrained("path/to/processor")
             ```
 
-            Loading specific config file:
+            Loading from HF Hub (config_filename required):
             ```python
-            processor = RobotProcessor.from_pretrained(
-                "username/multi-processor-repo", config_filename="preprocessor.json"
+            processor = DataProcessorPipeline.from_pretrained(
+                "username/processor-repo", config_filename="processor.json"
             )
             ```
 
@@ -575,14 +466,14 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
             import gym
 
             env = gym.make("CartPole-v1")
-            processor = RobotProcessor.from_pretrained(
+            processor = DataProcessorPipeline.from_pretrained(
                 "username/cartpole-processor", overrides={"ActionRepeatStep": {"env": env}}
             )
             ```
 
             Multiple overrides:
             ```python
-            processor = RobotProcessor.from_pretrained(
+            processor = DataProcessorPipeline.from_pretrained(
                 "path/to/processor",
                 overrides={
                     "CustomStep": {"param1": "new_value"},
@@ -594,7 +485,19 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
         # Use the local variable name 'source' for clarity
         source = str(pretrained_model_name_or_path)
 
-        if Path(source).is_dir():
+        # Check if it's a local path (either exists or looks like a filesystem path)
+        # Hub repositories are typically in the format "username/repo-name" (exactly one slash)
+        # Local paths are absolute paths, relative paths, or have more complex path structure
+        is_local_path = (
+            Path(source).is_dir()
+            or Path(source).is_absolute()
+            or source.startswith("./")
+            or source.startswith("../")
+            or source.count("/") > 1  # More than one slash suggests local path, not Hub repo
+            or "\\" in source  # Windows-style paths are definitely local
+        )
+
+        if is_local_path:
             # Local path - use it directly
             base_path = Path(source)
 
@@ -613,57 +516,26 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
             with open(base_path / config_filename) as file_pointer:
                 loaded_config: dict[str, Any] = json.load(file_pointer)
         else:
-            # Hugging Face Hub - download all required files
+            # Hugging Face Hub - download specific config file
             if config_filename is None:
-                # Try common config names
-                common_names = [
-                    "robot_processor.json",
-                    "robot_preprocessor.json",
-                    "robot_postprocessor.json",
-                ]
-                config_path = None
-                for name in common_names:
-                    try:
-                        config_path = hf_hub_download(
-                            source,
-                            name,
-                            repo_type="model",
-                            force_download=force_download,
-                            resume_download=resume_download,
-                            proxies=proxies,
-                            token=token,
-                            cache_dir=cache_dir,
-                            local_files_only=local_files_only,
-                            revision=revision,
-                        )
-                        config_filename = name
-                        break
-                    except (FileNotFoundError, OSError, HfHubHTTPError):
-                        # FileNotFoundError: local file issues
-                        # OSError: network/system errors
-                        # HfHubHTTPError: file not found on Hub (404) or other HTTP errors
-                        continue
-
-                if config_path is None:
-                    raise FileNotFoundError(
-                        f"No processor configuration file found in {source}. "
-                        f"Tried: {common_names}. Please specify the config_filename parameter."
-                    )
-            else:
-                # Download specific config file
-                config_path = hf_hub_download(
-                    source,
-                    config_filename,
-                    repo_type="model",
-                    force_download=force_download,
-                    resume_download=resume_download,
-                    proxies=proxies,
-                    token=token,
-                    cache_dir=cache_dir,
-                    local_files_only=local_files_only,
-                    revision=revision,
+                raise ValueError(
+                    f"For Hugging Face Hub repositories ({source}), you must specify the config_filename parameter. "
+                    f"Example: DataProcessorPipeline.from_pretrained('{source}', config_filename='processor.json')"
                 )
 
+            config_path = hf_hub_download(
+                source,
+                config_filename,
+                repo_type="model",
+                force_download=force_download,
+                resume_download=resume_download,
+                proxies=proxies,
+                token=token,
+                cache_dir=cache_dir,
+                local_files_only=local_files_only,
+                revision=revision,
+            )
+
             with open(config_path) as file_pointer:
                 loaded_config = json.load(file_pointer)
 
@@ -766,25 +638,25 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
 
         return cls(
             steps=steps,
-            name=loaded_config.get("name", "RobotProcessor"),
-            to_transition=to_transition or _default_batch_to_transition,
+            name=loaded_config.get("name", "DataProcessorPipeline"),
+            to_transition=to_transition or batch_to_transition,
             # Cast is necessary here: Same type-checker limitation as above.
             # When to_output is None, we use the default which returns dict[str, Any].
             # The cast ensures type consistency with the generic TOutput parameter.
-            to_output=to_output or cast(Callable[[EnvTransition], TOutput], _default_transition_to_batch),
+            to_output=to_output or cast(Callable[[EnvTransition], TOutput], transition_to_batch),
         )
 
     def __len__(self) -> int:
         """Return the number of steps in the processor."""
         return len(self.steps)
 
-    def __getitem__(self, idx: int | slice) -> ProcessorStep | RobotProcessor[TOutput]:
+    def __getitem__(self, idx: int | slice) -> ProcessorStep | DataProcessorPipeline[TOutput]:
         """Indexing helper exposing underlying steps.
         * ``int`` – returns the idx-th ProcessorStep.
-        * ``slice`` – returns a new RobotProcessor with the sliced steps.
+        * ``slice`` – returns a new DataProcessorPipeline with the sliced steps.
         """
         if isinstance(idx, slice):
-            return RobotProcessor(
+            return DataProcessorPipeline(
                 steps=self.steps[idx],
                 name=self.name,
                 to_transition=self.to_transition,
@@ -855,15 +727,12 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
 
         parts = [f"name='{self.name}'", steps_repr]
 
-        return f"RobotProcessor({', '.join(parts)})"
+        return f"DataProcessorPipeline({', '.join(parts)})"
 
     def __post_init__(self):
         for i, step in enumerate(self.steps):
-            if not callable(step):
-                # TODO(steven): This should instead check isinstance(step, ProcessorStep), test need to be updated
-                raise TypeError(
-                    f"Step {i} ({type(step).__name__}) must define __call__(transition) -> EnvTransition"
-                )
+            if not isinstance(step, ProcessorStep):
+                raise TypeError(f"Step {i} ({type(step).__name__}) must inherit from ProcessorStep")
 
     def transform_features(self, initial_features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
         """
@@ -877,8 +746,47 @@ class RobotProcessor(ModelHubMixin, Generic[TOutput]):
             features = out
         return features
 
+    def process_observation(self, observation: dict[str, Any]) -> dict[str, Any]:
+        transition: EnvTransition = create_transition(observation=observation)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.OBSERVATION]
 
-class ObservationProcessor(ProcessorStep, ABC):
+    def process_action(self, action: Any | torch.Tensor) -> Any | torch.Tensor:
+        transition: EnvTransition = create_transition(action=action)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.ACTION]
+
+    def process_reward(self, reward: float | torch.Tensor) -> float | torch.Tensor:
+        transition: EnvTransition = create_transition(reward=reward)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.REWARD]
+
+    def process_done(self, done: bool | torch.Tensor) -> bool | torch.Tensor:
+        transition: EnvTransition = create_transition(done=done)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.DONE]
+
+    def process_truncated(self, truncated: bool | torch.Tensor) -> bool | torch.Tensor:
+        transition: EnvTransition = create_transition(truncated=truncated)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.TRUNCATED]
+
+    def process_info(self, info: dict[str, Any]) -> dict[str, Any]:
+        transition: EnvTransition = create_transition(info=info)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.INFO]
+
+    def process_complementary_data(self, complementary_data: dict[str, Any]) -> dict[str, Any]:
+        transition: EnvTransition = create_transition(complementary_data=complementary_data)
+        transformed_transition = self._forward(transition)
+        return transformed_transition[TransitionKey.COMPLEMENTARY_DATA]
+
+
+RobotProcessorPipeline: TypeAlias = DataProcessorPipeline
+PolicyProcessorPipeline: TypeAlias = DataProcessorPipeline
+
+
+class ObservationProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the observation component of a transition.
 
     Subclasses should override the `observation` method to implement custom observation processing.
@@ -924,7 +832,7 @@ class ObservationProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class ActionProcessor(ProcessorStep, ABC):
+class ActionProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the action component of a transition.
 
     Subclasses should override the `action` method to implement custom action processing.
@@ -971,7 +879,7 @@ class ActionProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class RewardProcessor(ProcessorStep, ABC):
+class RewardProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the reward component of a transition.
 
     Subclasses should override the `reward` method to implement custom reward processing.
@@ -1017,7 +925,7 @@ class RewardProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class DoneProcessor(ProcessorStep, ABC):
+class DoneProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the done flag of a transition.
 
     Subclasses should override the `done` method to implement custom done flag processing.
@@ -1068,7 +976,7 @@ class DoneProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class TruncatedProcessor(ProcessorStep, ABC):
+class TruncatedProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the truncated flag of a transition.
 
     Subclasses should override the `truncated` method to implement custom truncated flag processing.
@@ -1115,7 +1023,7 @@ class TruncatedProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class InfoProcessor(ProcessorStep, ABC):
+class InfoProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the info dictionary of a transition.
 
     Subclasses should override the `info` method to implement custom info processing.
@@ -1167,7 +1075,7 @@ class InfoProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class ComplementaryDataProcessor(ProcessorStep, ABC):
+class ComplementaryDataProcessorStep(ProcessorStep, ABC):
     """Base class for processors that modify only the complementary data of a transition.
 
     Subclasses should override the `complementary_data` method to implement custom complementary data processing.
@@ -1200,8 +1108,11 @@ class ComplementaryDataProcessor(ProcessorStep, ABC):
         return new_transition
 
 
-class IdentityProcessor(ProcessorStep):
+class IdentityProcessorStep(ProcessorStep):
     """Identity processor that does nothing."""
 
     def __call__(self, transition: EnvTransition) -> EnvTransition:
         return transition
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features

src/lerobot/processor/rename_processor.py

@@ -18,15 +18,13 @@ from dataclasses import dataclass, field
 from typing import Any
 
 from lerobot.configs.types import PolicyFeature
-from lerobot.processor.pipeline import (
-    ObservationProcessor,
-    ProcessorStepRegistry,
-)
+
+from .pipeline import ObservationProcessorStep, ProcessorStepRegistry
 
 
 @dataclass
 @ProcessorStepRegistry.register(name="rename_processor")
-class RenameProcessor(ObservationProcessor):
+class RenameProcessorStep(ObservationProcessorStep):
     """Rename processor that renames keys in the observation."""
 
     rename_map: dict[str, str] = field(default_factory=dict)

src/lerobot/processor/tokenizer_processor.py

@@ -11,14 +11,11 @@ import torch
 
 from lerobot.configs.types import FeatureType, PolicyFeature
 from lerobot.constants import OBS_LANGUAGE_ATTENTION_MASK, OBS_LANGUAGE_TOKENS
-from lerobot.processor.pipeline import (
-    EnvTransition,
-    ObservationProcessor,
-    ProcessorStepRegistry,
-    TransitionKey,
-)
 from lerobot.utils.import_utils import _transformers_available
 
+from .core import EnvTransition, TransitionKey
+from .pipeline import ObservationProcessorStep, ProcessorStepRegistry
+
 if TYPE_CHECKING or _transformers_available:
     from transformers import AutoTokenizer
 else:
@@ -27,7 +24,7 @@ else:
 
 @dataclass
 @ProcessorStepRegistry.register(name="tokenizer_processor")
-class TokenizerProcessor(ObservationProcessor):
+class TokenizerProcessorStep(ObservationProcessorStep):
     """Tokenizes text tasks in complementary data using a huggingface tokenizer.
 
     This processor handles tokenization of task strings found in the complementary_data
@@ -51,7 +48,7 @@ class TokenizerProcessor(ObservationProcessor):
     Examples:
         Using tokenizer name (auto-loaded):
         ```python
-        processor = TokenizerProcessor(tokenizer_name="bert-base-uncased", max_length=128)
+        processor = TokenizerProcessorStep(tokenizer_name="bert-base-uncased", max_length=128)
         ```
 
         Using custom tokenizer object:
@@ -59,7 +56,7 @@ class TokenizerProcessor(ObservationProcessor):
         from transformers import AutoTokenizer
 
         custom_tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
-        processor = TokenizerProcessor(tokenizer=custom_tokenizer, max_length=128)
+        processor = TokenizerProcessorStep(tokenizer=custom_tokenizer, max_length=128)
         ```
     """
 
@@ -72,23 +69,23 @@ class TokenizerProcessor(ObservationProcessor):
     truncation: bool = True
 
     # Internal tokenizer instance (not serialized)
-    _tokenizer: Any = field(default=None, init=False, repr=False)
+    input_tokenizer: Any = field(default=None, init=False, repr=False)
 
     def __post_init__(self):
         """Initialize the tokenizer from the provided tokenizer or tokenizer name."""
         if not _transformers_available:
             raise ImportError(
                 "The 'transformers' library is not installed. "
-                "Please install it with `pip install 'lerobot[transformers-dep]'` to use TokenizerProcessor."
+                "Please install it with `pip install 'lerobot[transformers-dep]'` to use TokenizerProcessorStep."
             )
 
         if self.tokenizer is not None:
             # Use provided tokenizer object directly
-            self._tokenizer = self.tokenizer
+            self.input_tokenizer = self.tokenizer
         elif self.tokenizer_name is not None:
             if AutoTokenizer is None:
                 raise ImportError("AutoTokenizer is not available")
-            self._tokenizer = AutoTokenizer.from_pretrained(self.tokenizer_name)
+            self.input_tokenizer = AutoTokenizer.from_pretrained(self.tokenizer_name)
         else:
             raise ValueError(
                 "Either 'tokenizer' or 'tokenizer_name' must be provided. "
@@ -196,7 +193,7 @@ class TokenizerProcessor(ObservationProcessor):
         Returns:
             Dictionary containing tokenized output with keys like 'input_ids', 'attention_mask'.
         """
-        return self._tokenizer(
+        return self.input_tokenizer(
             text,
             max_length=self.max_length,
             truncation=self.truncation,

src/lerobot/record.py

@@ -76,14 +76,18 @@ from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.datasets.video_utils import VideoEncodingManager
 from lerobot.policies.factory import make_policy, make_pre_post_processors
 from lerobot.policies.pretrained import PreTrainedPolicy
-from lerobot.processor import RobotProcessor
-from lerobot.processor.converters import (
-    to_dataset_frame,
-    to_output_robot_action,
-    to_transition_robot_observation,
-    to_transition_teleop_action,
+from lerobot.processor import (
+    IdentityProcessorStep,
+    PolicyProcessorPipeline,
+    RobotProcessorPipeline,
+    TransitionKey,
+)
+from lerobot.processor.converters import (
+    action_to_transition,
+    observation_to_transition,
+    transition_to_dataset_frame,
+    transition_to_robot_action,
 )
-from lerobot.processor.pipeline import IdentityProcessor, TransitionKey
 from lerobot.processor.rename_processor import rename_stats
 from lerobot.robots import (  # noqa: F401
     Robot,
@@ -236,23 +240,25 @@ def record_loop(
     dataset: LeRobotDataset | None = None,
     teleop: Teleoperator | list[Teleoperator] | None = None,
     policy: PreTrainedPolicy | None = None,
-    preprocessor: RobotProcessor | None = None,
-    postprocessor: RobotProcessor | None = None,
+    preprocessor: PolicyProcessorPipeline | None = None,
+    postprocessor: PolicyProcessorPipeline | None = None,
     control_time_s: int | None = None,
-    teleop_action_processor: RobotProcessor | None = None,  # runs after teleop
-    robot_action_processor: RobotProcessor | None = None,  # runs before robot
-    robot_observation_processor: RobotProcessor | None = None,  # runs after robot
+    teleop_action_processor: RobotProcessorPipeline | None = None,  # runs after teleop
+    robot_action_processor: RobotProcessorPipeline | None = None,  # runs before robot
+    robot_observation_processor: RobotProcessorPipeline | None = None,  # runs after robot
     single_task: str | None = None,
     display_data: bool = False,
 ):
-    teleop_action_processor = teleop_action_processor or RobotProcessor(
-        steps=[IdentityProcessor()], to_transition=to_transition_teleop_action, to_output=lambda tr: tr
+    teleop_action_processor = teleop_action_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()], to_transition=action_to_transition, to_output=lambda tr: tr
     )
-    robot_action_processor = robot_action_processor or RobotProcessor(
-        steps=[IdentityProcessor()], to_transition=lambda tr: tr, to_output=to_output_robot_action
+    robot_action_processor = robot_action_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()], to_transition=lambda tr: tr, to_output=transition_to_robot_action
     )
-    robot_observation_processor = robot_observation_processor or RobotProcessor(
-        steps=[IdentityProcessor()], to_transition=to_transition_robot_observation, to_output=lambda tr: tr
+    robot_observation_processor = robot_observation_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()],
+        to_transition=observation_to_transition,
+        to_output=lambda tr: tr,
     )
 
     if dataset is not None and dataset.fps != fps:
@@ -308,7 +314,7 @@ def record_loop(
         # Get action from either policy or teleop
         if policy is not None and preprocessor is not None and postprocessor is not None:
             if dataset is not None:
-                observation_frame = to_dataset_frame(
+                observation_frame = transition_to_dataset_frame(
                     obs_transition, dataset.features
                 )  # Convert the observation to the dataset format
 
@@ -366,7 +372,7 @@ def record_loop(
 
         # Write to dataset
         if dataset is not None:
-            # If to_dataset_frame is provided, use it to merge the transitions.
+            # If transition_to_dataset_frame is provided, use it to merge the transitions.
             merged = []
             if obs_transition is not None:  # The observation from the robot
                 merged.append(obs_transition)
@@ -374,7 +380,7 @@ def record_loop(
                 merged.append(teleop_transition)
             if policy_transition is not None:  # The action from policy
                 merged.append(policy_transition)
-            frame = to_dataset_frame(
+            frame = transition_to_dataset_frame(
                 merged if len(merged) > 1 else merged[0], dataset.features
             )  # Convert the observation to the dataset format
             dataset.add_frame(frame, task=single_task)
@@ -400,7 +406,15 @@ def record(cfg: RecordConfig) -> LeRobotDataset:
 
     action_features = hw_to_dataset_features(robot.action_features, "action", cfg.dataset.video)
     obs_features = hw_to_dataset_features(robot.observation_features, "observation", cfg.dataset.video)
-    dataset_features = {**action_features, **obs_features}
+
+    # Add next.* features that are generated during recording
+    transition_features = {
+        "next.reward": {"dtype": "float32", "shape": (1,), "names": None},
+        "next.done": {"dtype": "bool", "shape": (1,), "names": None},
+        "next.truncated": {"dtype": "bool", "shape": (1,), "names": None},
+    }
+
+    dataset_features = {**action_features, **obs_features, **transition_features}
 
     if cfg.resume:
         dataset = LeRobotDataset(

src/lerobot/replay.py

@@ -47,9 +47,8 @@ from pprint import pformat
 
 from lerobot.configs import parser
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.processor import RobotProcessor
-from lerobot.processor.converters import to_output_robot_action, to_transition_teleop_action
-from lerobot.processor.pipeline import IdentityProcessor
+from lerobot.processor import IdentityProcessorStep, RobotProcessorPipeline
+from lerobot.processor.converters import action_to_transition, transition_to_robot_action
 from lerobot.robots import (  # noqa: F401
     Robot,
     RobotConfig,
@@ -86,7 +85,7 @@ class ReplayConfig:
     # Use vocal synthesis to read events.
     play_sounds: bool = True
     # Optional processor for actions before sending to robot
-    robot_action_processor: RobotProcessor | None = None
+    robot_action_processor: RobotProcessorPipeline | None = None
 
 
 @parser.wrap()
@@ -95,10 +94,10 @@ def replay(cfg: ReplayConfig):
     logging.info(pformat(asdict(cfg)))
 
     # Initialize robot action processor with default if not provided
-    robot_action_processor = cfg.robot_action_processor or RobotProcessor(
-        steps=[IdentityProcessor()],
-        to_transition=to_transition_teleop_action,
-        to_output=to_output_robot_action,  # type: ignore[arg-type]
+    robot_action_processor = cfg.robot_action_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()],
+        to_transition=action_to_transition,
+        to_output=transition_to_robot_action,  # type: ignore[arg-type]
     )
 
     # Reset processor

src/lerobot/robots/so100_follower/robot_kinematic_processor.py

@@ -22,11 +22,11 @@ from scipy.spatial.transform import Rotation
 from lerobot.configs.types import FeatureType, PolicyFeature
 from lerobot.constants import ACTION, OBS_STATE
 from lerobot.model.kinematics import RobotKinematics
-from lerobot.processor.pipeline import (
-    ActionProcessor,
-    ComplementaryDataProcessor,
+from lerobot.processor import (
+    ActionProcessorStep,
+    ComplementaryDataProcessorStep,
     EnvTransition,
-    ObservationProcessor,
+    ObservationProcessorStep,
     ProcessorStep,
     ProcessorStepRegistry,
     TransitionKey,
@@ -36,7 +36,7 @@ from lerobot.robots.robot import Robot
 
 @ProcessorStepRegistry.register("ee_reference_and_delta")
 @dataclass
-class EEReferenceAndDelta(ActionProcessor):
+class EEReferenceAndDelta(ActionProcessorStep):
     """
     Compute the desired end-effector pose from the target pose and the current pose.
 
@@ -148,18 +148,18 @@ class EEReferenceAndDelta(ActionProcessor):
         features.pop(f"{ACTION}.target_wy", None)
         features.pop(f"{ACTION}.target_wz", None)
 
-        features[f"{ACTION}.ee.x"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features[f"{ACTION}.ee.y"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features[f"{ACTION}.ee.z"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features[f"{ACTION}.ee.wx"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features[f"{ACTION}.ee.wy"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features[f"{ACTION}.ee.wz"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
+        features[f"{ACTION}.ee.x"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.ee.y"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.ee.z"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.ee.wx"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.ee.wy"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.ee.wz"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
         return features
 
 
 @ProcessorStepRegistry.register("ee_bounds_and_safety")
 @dataclass
-class EEBoundsAndSafety(ActionProcessor):
+class EEBoundsAndSafety(ActionProcessorStep):
     """
     Clip the end-effector pose to the bounds and check for jumps.
 
@@ -189,7 +189,9 @@ class EEBoundsAndSafety(ActionProcessor):
         wz = act.get(f"{ACTION}.ee.wz", None)
 
         if None in (x, y, z, wx, wy, wz):
-            return act
+            raise ValueError(
+                "Missing required end-effector pose components: x, y, z, wx, wy, wz must all be present in action"
+            )
 
         pos = np.array([x, y, z], dtype=float)
         twist = np.array([wx, wy, wz], dtype=float)
@@ -220,6 +222,11 @@ class EEBoundsAndSafety(ActionProcessor):
         self._last_pos = None
         self._last_twist = None
 
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        # check if features as f"{ACTION}.ee.{x,y,z,wx,wy,wz}"
+
+        return features
+
 
 @ProcessorStepRegistry.register("inverse_kinematics_ee_to_joints")
 @dataclass
@@ -248,8 +255,9 @@ class InverseKinematicsEEToJoints(ProcessorStep):
     initial_guess_current_joints: bool = True
 
     def __call__(self, transition: EnvTransition) -> EnvTransition:
-        act = transition.get(TransitionKey.ACTION) or {}
-        comp = transition.get(TransitionKey.COMPLEMENTARY_DATA) or {}
+        new_transition = transition.copy()
+        act = new_transition.get(TransitionKey.ACTION) or {}
+        comp = new_transition.get(TransitionKey.COMPLEMENTARY_DATA) or {}
 
         x = act.get(f"{ACTION}.ee.x", None)
         y = act.get(f"{ACTION}.ee.y", None)
@@ -259,7 +267,7 @@ class InverseKinematicsEEToJoints(ProcessorStep):
         wz = act.get(f"{ACTION}.ee.wz", None)
 
         if None in (x, y, z, wx, wy, wz):
-            return transition
+            return new_transition
 
         # Get joint positions from complimentary data
         raw = comp.get("raw_joint_positions", None)
@@ -286,19 +294,20 @@ class InverseKinematicsEEToJoints(ProcessorStep):
         new_act = dict(act)
         for i, name in enumerate(self.motor_names):
             if name == "gripper":
-                new_act[f"{OBS_STATE}.gripper.pos"] = float(raw["gripper"])
+                # TODO(pepijn): Investigate if this is correct
+                # Do we want an observation key in the action field?
+                new_act[f"{ACTION}.gripper.pos"] = float(raw["gripper"])
             else:
                 new_act[f"{ACTION}.{name}.pos"] = float(q_target[i])
-        transition[TransitionKey.ACTION] = new_act
+        new_transition[TransitionKey.ACTION] = new_act
         if not self.initial_guess_current_joints:
-            transition[TransitionKey.COMPLEMENTARY_DATA]["reference_joint_positions"] = q_target
-        return transition
+            new_transition[TransitionKey.COMPLEMENTARY_DATA]["reference_joint_positions"] = q_target
+        return new_transition
 
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
-        features[f"{OBS_STATE}.gripper.pos"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features[f"{ACTION}.gripper.pos"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
+        features[f"{ACTION}.gripper.pos"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
         for name in self.motor_names:
-            features[f"{ACTION}.{name}.pos"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
+            features[f"{ACTION}.{name}.pos"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
 
         return features
 
@@ -330,18 +339,18 @@ class GripperVelocityToJoint(ProcessorStep):
     discrete_gripper: bool = False
 
     def __call__(self, transition: EnvTransition) -> EnvTransition:
-        obs = transition.get(TransitionKey.OBSERVATION) or {}
-        act = transition.get(TransitionKey.ACTION) or {}
-        comp = transition.get(TransitionKey.COMPLEMENTARY_DATA) or {}
+        new_transition = transition.copy()
+        obs = new_transition.get(TransitionKey.OBSERVATION) or {}
+        act = new_transition.get(TransitionKey.ACTION) or {}
+        comp = new_transition.get(TransitionKey.COMPLEMENTARY_DATA) or {}
 
         if f"{ACTION}.gripper" not in act:
-            return transition
+            raise ValueError(f"Required action key '{ACTION}.gripper' not found in transition")
 
         if "gripper" not in self.motor_names:
-            new_act = dict(act)
-            new_act.pop(f"{ACTION}.gripper", None)
-            transition[TransitionKey.ACTION] = new_act
-            return transition
+            raise ValueError(
+                f"Required motor name 'gripper' not found in self.motor_names={self.motor_names}"
+            )
 
         if self.discrete_gripper:
             # Discrete gripper actions are in [0, 1, 2]
@@ -364,21 +373,23 @@ class GripperVelocityToJoint(ProcessorStep):
         new_act = dict(act)
         new_act[f"{ACTION}.gripper.pos"] = gripper_pos
         new_act.pop(f"{ACTION}.gripper", None)
-        transition[TransitionKey.ACTION] = new_act
+        new_transition[TransitionKey.ACTION] = new_act
 
         obs[f"{OBS_STATE}.gripper.pos"] = curr_pos
-        transition[TransitionKey.OBSERVATION] = obs
-        return transition
+        new_transition[TransitionKey.OBSERVATION] = obs
+        return new_transition
 
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
         features.pop(f"{ACTION}.gripper", None)
-        features[f"{ACTION}.gripper.pos"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
+        features[f"{ACTION}.gripper.pos"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{OBS_STATE}.gripper.pos"] = PolicyFeature(type=FeatureType.STATE, shape=(1,))
+
         return features
 
 
 @ProcessorStepRegistry.register("forward_kinematics_joints_to_ee")
 @dataclass
-class ForwardKinematicsJointsToEE(ObservationProcessor):
+class ForwardKinematicsJointsToEE(ObservationProcessorStep):
     """
     Compute the end-effector pose from the joint positions.
 
@@ -398,7 +409,7 @@ class ForwardKinematicsJointsToEE(ObservationProcessor):
 
     def observation(self, obs: dict) -> dict:
         if not all(f"{OBS_STATE}.{n}.pos" in obs for n in self.motor_names):
-            return obs
+            raise ValueError(f"Missing required joint positions for motors: {self.motor_names}")
 
         q = np.array([obs[f"{OBS_STATE}.{n}.pos"] for n in self.motor_names], dtype=float)
         t = self.kinematics.forward_kinematics(q)
@@ -416,13 +427,13 @@ class ForwardKinematicsJointsToEE(ObservationProcessor):
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
         # We specify the dataset features of this step that we want to be stored in the dataset
         for k in ["x", "y", "z", "wx", "wy", "wz"]:
-            features[f"{OBS_STATE}.ee.{k}"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
+            features[f"{OBS_STATE}.ee.{k}"] = PolicyFeature(type=FeatureType.STATE, shape=(1,))
         return features
 
 
 @ProcessorStepRegistry.register("add_robot_observation")
 @dataclass
-class AddRobotObservationAsComplimentaryData(ComplementaryDataProcessor):
+class AddRobotObservationAsComplimentaryData(ComplementaryDataProcessorStep):
     """
     Read the robot's current observation and insert it into the transition as complementary data.
 
@@ -444,3 +455,6 @@ class AddRobotObservationAsComplimentaryData(ComplementaryDataProcessor):
             if isinstance(k, str) and k.endswith(".pos")
         }
         return new_comp
+
+    def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
+        return features

src/lerobot/scripts/rl/actor.py

@@ -62,7 +62,7 @@ from lerobot.configs import parser
 from lerobot.configs.train import TrainRLServerPipelineConfig
 from lerobot.policies.factory import make_policy
 from lerobot.policies.sac.modeling_sac import SACPolicy
-from lerobot.processor.pipeline import TransitionKey
+from lerobot.processor import TransitionKey
 from lerobot.robots import so100_follower  # noqa: F401
 from lerobot.scripts.rl.gym_manipulator import (
     create_transition,

src/lerobot/scripts/rl/gym_manipulator.py

@@ -29,25 +29,27 @@ from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.envs.configs import HILSerlRobotEnvConfig
 from lerobot.model.kinematics import RobotKinematics
 from lerobot.processor import (
-    AddTeleopActionAsComplimentaryData,
-    AddTeleopEventsAsInfo,
-    DeviceProcessor,
-    GripperPenaltyProcessor,
-    ImageCropResizeProcessor,
-    InterventionActionProcessor,
-    JointVelocityProcessor,
-    MapDeltaActionToRobotAction,
-    MapTensorToDeltaActionDict,
-    MotorCurrentProcessor,
-    Numpy2TorchActionProcessor,
-    RewardClassifierProcessor,
-    RobotProcessor,
-    TimeLimitProcessor,
-    ToBatchProcessor,
-    Torch2NumpyActionProcessor,
-    VanillaObservationProcessor,
+    AddBatchDimensionProcessorStep,
+    AddTeleopActionAsComplimentaryDataStep,
+    AddTeleopEventsAsInfoStep,
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    EnvTransition,
+    GripperPenaltyProcessorStep,
+    ImageCropResizeProcessorStep,
+    InterventionActionProcessorStep,
+    JointVelocityProcessorStep,
+    MapDeltaActionToRobotActionStep,
+    MapTensorToDeltaActionDictStep,
+    MotorCurrentProcessorStep,
+    Numpy2TorchActionProcessorStep,
+    RewardClassifierProcessorStep,
+    TimeLimitProcessorStep,
+    Torch2NumpyActionProcessorStep,
+    TransitionKey,
+    VanillaObservationProcessorStep,
+    create_transition,
 )
-from lerobot.processor.pipeline import EnvTransition, TransitionKey
 from lerobot.robots import (  # noqa: F401
     RobotConfig,
     make_robot_from_config,
@@ -98,21 +100,6 @@ class GymManipulatorConfig:
     device: str = "cpu"
 
 
-def create_transition(
-    observation=None, action=None, reward=0.0, done=False, truncated=False, info=None, complementary_data=None
-) -> dict[str, Any]:
-    """Create an EnvTransition dictionary with default values."""
-    return {
-        TransitionKey.OBSERVATION: observation,
-        TransitionKey.ACTION: action,
-        TransitionKey.REWARD: reward,
-        TransitionKey.DONE: done,
-        TransitionKey.TRUNCATED: truncated,
-        TransitionKey.INFO: info if info is not None else {},
-        TransitionKey.COMPLEMENTARY_DATA: complementary_data if complementary_data is not None else {},
-    }
-
-
 def reset_follower_position(robot_arm: Robot, target_position: np.ndarray) -> None:
     """Reset robot arm to target position using smooth trajectory."""
     current_position_dict = robot_arm.bus.sync_read("Present_Position")
@@ -375,19 +362,21 @@ def make_processors(
 
     if cfg.name == "gym_hil":
         action_pipeline_steps = [
-            InterventionActionProcessor(terminate_on_success=terminate_on_success),
-            Torch2NumpyActionProcessor(),
+            InterventionActionProcessorStep(terminate_on_success=terminate_on_success),
+            Torch2NumpyActionProcessorStep(),
         ]
 
         # Minimal processor pipeline for GymHIL simulation
         env_pipeline_steps = [
-            Numpy2TorchActionProcessor(),
-            VanillaObservationProcessor(),
-            ToBatchProcessor(),
-            DeviceProcessor(device=device),
+            Numpy2TorchActionProcessorStep(),
+            VanillaObservationProcessorStep(),
+            AddBatchDimensionProcessorStep(),
+            DeviceProcessorStep(device=device),
         ]
 
-        return RobotProcessor(steps=env_pipeline_steps), RobotProcessor(steps=action_pipeline_steps)
+        return DataProcessorPipeline(steps=env_pipeline_steps), DataProcessorPipeline(
+            steps=action_pipeline_steps
+        )
 
     # Full processor pipeline for real robot environment
     # Get robot and motor information for kinematics
@@ -402,13 +391,13 @@ def make_processors(
             joint_names=motor_names,
         )
 
-    env_pipeline_steps = [VanillaObservationProcessor()]
+    env_pipeline_steps = [VanillaObservationProcessorStep()]
 
     if cfg.processor.observation is not None:
         if cfg.processor.observation.add_joint_velocity_to_observation:
-            env_pipeline_steps.append(JointVelocityProcessor(dt=1.0 / cfg.fps))
+            env_pipeline_steps.append(JointVelocityProcessorStep(dt=1.0 / cfg.fps))
         if cfg.processor.observation.add_current_to_observation:
-            env_pipeline_steps.append(MotorCurrentProcessor(robot=env.robot))
+            env_pipeline_steps.append(MotorCurrentProcessorStep(robot=env.robot))
 
     if kinematics_solver is not None:
         env_pipeline_steps.append(
@@ -420,7 +409,7 @@ def make_processors(
 
     if cfg.processor.image_preprocessing is not None:
         env_pipeline_steps.append(
-            ImageCropResizeProcessor(
+            ImageCropResizeProcessorStep(
                 crop_params_dict=cfg.processor.image_preprocessing.crop_params_dict,
                 resize_size=cfg.processor.image_preprocessing.resize_size,
             )
@@ -429,13 +418,13 @@ def make_processors(
     # Add time limit processor if reset config exists
     if cfg.processor.reset is not None:
         env_pipeline_steps.append(
-            TimeLimitProcessor(max_episode_steps=int(cfg.processor.reset.control_time_s * cfg.fps))
+            TimeLimitProcessorStep(max_episode_steps=int(cfg.processor.reset.control_time_s * cfg.fps))
         )
 
     # Add gripper penalty processor if gripper config exists and enabled
     if cfg.processor.gripper is not None and cfg.processor.gripper.use_gripper:
         env_pipeline_steps.append(
-            GripperPenaltyProcessor(
+            GripperPenaltyProcessorStep(
                 penalty=cfg.processor.gripper.gripper_penalty,
                 max_gripper_pos=cfg.processor.max_gripper_pos,
             )
@@ -446,7 +435,7 @@ def make_processors(
         and cfg.processor.reward_classifier.pretrained_path is not None
     ):
         env_pipeline_steps.append(
-            RewardClassifierProcessor(
+            RewardClassifierProcessorStep(
                 pretrained_path=cfg.processor.reward_classifier.pretrained_path,
                 device=device,
                 success_threshold=cfg.processor.reward_classifier.success_threshold,
@@ -455,14 +444,14 @@ def make_processors(
             )
         )
 
-    env_pipeline_steps.append(ToBatchProcessor())
-    env_pipeline_steps.append(DeviceProcessor(device=device))
+    env_pipeline_steps.append(AddBatchDimensionProcessorStep())
+    env_pipeline_steps.append(DeviceProcessorStep(device=device))
 
     action_pipeline_steps = [
-        AddTeleopActionAsComplimentaryData(teleop_device=teleop_device),
-        AddTeleopEventsAsInfo(teleop_device=teleop_device),
+        AddTeleopActionAsComplimentaryDataStep(teleop_device=teleop_device),
+        AddTeleopEventsAsInfoStep(teleop_device=teleop_device),
         AddRobotObservationAsComplimentaryData(robot=env.robot),
-        InterventionActionProcessor(
+        InterventionActionProcessorStep(
             use_gripper=cfg.processor.gripper.use_gripper if cfg.processor.gripper is not None else False,
             terminate_on_success=terminate_on_success,
         ),
@@ -472,8 +461,10 @@ def make_processors(
     if cfg.processor.inverse_kinematics is not None and kinematics_solver is not None:
         # Add EE bounds and safety processor
         inverse_kinematics_steps = [
-            MapTensorToDeltaActionDict(),
-            MapDeltaActionToRobotAction(),
+            MapTensorToDeltaActionDictStep(
+                use_gripper=cfg.processor.gripper.use_gripper if cfg.processor.gripper is not None else False
+            ),
+            MapDeltaActionToRobotActionStep(),
             EEReferenceAndDelta(
                 kinematics=kinematics_solver,
                 end_effector_step_sizes=cfg.processor.inverse_kinematics.end_effector_step_sizes,
@@ -497,15 +488,15 @@ def make_processors(
         ]
         action_pipeline_steps.extend(inverse_kinematics_steps)
 
-    return RobotProcessor(steps=env_pipeline_steps), RobotProcessor(steps=action_pipeline_steps)
+    return DataProcessorPipeline(steps=env_pipeline_steps), DataProcessorPipeline(steps=action_pipeline_steps)
 
 
 def step_env_and_process_transition(
     env: gym.Env,
     transition: EnvTransition,
     action: torch.Tensor,
-    env_processor: RobotProcessor,
-    action_processor: RobotProcessor,
+    env_processor: DataProcessorPipeline,
+    action_processor: DataProcessorPipeline,
 ):
     """
     Execute one step with processor pipeline.
@@ -554,8 +545,8 @@ def step_env_and_process_transition(
 
 def control_loop(
     env: gym.Env,
-    env_processor: RobotProcessor,
-    action_processor: RobotProcessor,
+    env_processor: DataProcessorPipeline,
+    action_processor: DataProcessorPipeline,
     teleop_device: Teleoperator,
     cfg: GymManipulatorConfig,
 ) -> None:
@@ -709,7 +700,9 @@ def control_loop(
         dataset.push_to_hub()
 
 
-def replay_trajectory(env: gym.Env, action_processor: RobotProcessor, cfg: GymManipulatorConfig) -> None:
+def replay_trajectory(
+    env: gym.Env, action_processor: DataProcessorPipeline, cfg: GymManipulatorConfig
+) -> None:
     """Replay recorded trajectory on robot environment."""
     assert cfg.dataset.replay_episode is not None, "Replay episode must be provided for replay"
 

src/lerobot/teleoperate.py

@@ -61,13 +61,12 @@ import rerun as rr
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig  # noqa: F401
 from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig  # noqa: F401
 from lerobot.configs import parser
-from lerobot.processor import RobotProcessor
+from lerobot.processor import IdentityProcessorStep, RobotProcessorPipeline
 from lerobot.processor.converters import (
-    to_output_robot_action,
-    to_transition_robot_observation,
-    to_transition_teleop_action,
+    action_to_transition,
+    observation_to_transition,
+    transition_to_robot_action,
 )
-from lerobot.processor.pipeline import IdentityProcessor
 from lerobot.robots import (  # noqa: F401
     Robot,
     RobotConfig,
@@ -105,9 +104,9 @@ class TeleoperateConfig:
     # Display all cameras on screen
     display_data: bool = False
     # Optional processors for data transformation
-    teleop_action_processor: RobotProcessor | None = None  # runs after teleop
-    robot_action_processor: RobotProcessor | None = None  # runs before robot
-    robot_observation_processor: RobotProcessor | None = None  # runs after robot
+    teleop_action_processor: RobotProcessorPipeline | None = None  # runs after teleop
+    robot_action_processor: RobotProcessorPipeline | None = None  # runs before robot
+    robot_observation_processor: RobotProcessorPipeline | None = None  # runs after robot
 
 
 def teleop_loop(
@@ -116,21 +115,23 @@ def teleop_loop(
     fps: int,
     display_data: bool = False,
     duration: float | None = None,
-    teleop_action_processor: RobotProcessor | None = None,
-    robot_action_processor: RobotProcessor | None = None,
-    robot_observation_processor: RobotProcessor | None = None,
+    teleop_action_processor: RobotProcessorPipeline | None = None,
+    robot_action_processor: RobotProcessorPipeline | None = None,
+    robot_observation_processor: RobotProcessorPipeline | None = None,
 ):
     # Initialize processors with defaults if not provided
-    teleop_action_processor = teleop_action_processor or RobotProcessor(
-        steps=[IdentityProcessor()], to_transition=to_transition_teleop_action, to_output=lambda tr: tr
+    teleop_action_processor = teleop_action_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()], to_transition=action_to_transition, to_output=lambda tr: tr
     )
-    robot_action_processor = robot_action_processor or RobotProcessor(
-        steps=[IdentityProcessor()],
+    robot_action_processor = robot_action_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()],
         to_transition=lambda tr: tr,
-        to_output=to_output_robot_action,  # type: ignore[arg-type]
+        to_output=transition_to_robot_action,  # type: ignore[arg-type]
     )
-    robot_observation_processor = robot_observation_processor or RobotProcessor(
-        steps=[IdentityProcessor()], to_transition=to_transition_robot_observation, to_output=lambda tr: tr
+    robot_observation_processor = robot_observation_processor or RobotProcessorPipeline(
+        steps=[IdentityProcessorStep()],
+        to_transition=observation_to_transition,
+        to_output=lambda tr: tr,
     )
 
     # Reset processors

src/lerobot/teleoperators/phone/phone_processor.py

@@ -17,13 +17,14 @@
 from dataclasses import dataclass, field
 
 from lerobot.configs.types import FeatureType, PolicyFeature
-from lerobot.processor.pipeline import ActionProcessor, ProcessorStepRegistry
+from lerobot.constants import ACTION
+from lerobot.processor import ActionProcessorStep, ProcessorStepRegistry
 from lerobot.teleoperators.phone.config_phone import PhoneOS
 
 
 @ProcessorStepRegistry.register("map_phone_action_to_robot_action")
 @dataclass
-class MapPhoneActionToRobotAction(ActionProcessor):
+class MapPhoneActionToRobotAction(ActionProcessorStep):
     """
     Map calibrated phone pose (actions) to the inputs for robot actions
 
@@ -48,13 +49,13 @@ class MapPhoneActionToRobotAction(ActionProcessor):
 
     def action(self, act: dict) -> dict:
         # Pop them from the action
-        enabled = bool(act.pop("action.phone.enabled", 0))
-        pos = act.pop("action.phone.pos", None)
-        rot = act.pop("action.phone.rot", None)
-        inputs = act.pop("action.phone.raw_inputs", {})
+        enabled = bool(act.pop(f"{ACTION}.phone.enabled", 0))
+        pos = act.pop(f"{ACTION}.phone.pos", None)
+        rot = act.pop(f"{ACTION}.phone.rot", None)
+        inputs = act.pop(f"{ACTION}.phone.raw_inputs", {})
 
         if pos is None or rot is None:
-            return act
+            raise ValueError("pos and rot must be present in action")
 
         rotvec = rot.as_rotvec()  # Absolute orientation as rotvec
 
@@ -69,28 +70,28 @@ class MapPhoneActionToRobotAction(ActionProcessor):
             )  # Positive if a is pressed, negative if b is pressed, 0 if both or neither are pressed
 
         # For some actions we need to invert the axis
-        act["action.enabled"] = enabled
-        act["action.target_x"] = -pos[1] if enabled else 0.0
-        act["action.target_y"] = pos[0] if enabled else 0.0
-        act["action.target_z"] = pos[2] if enabled else 0.0
-        act["action.target_wx"] = rotvec[1] if enabled else 0.0
-        act["action.target_wy"] = rotvec[0] if enabled else 0.0
-        act["action.target_wz"] = -rotvec[2] if enabled else 0.0
-        act["action.gripper"] = gripper  # Still send gripper action when disabled
+        act[f"{ACTION}.enabled"] = enabled
+        act[f"{ACTION}.target_x"] = -pos[1] if enabled else 0.0
+        act[f"{ACTION}.target_y"] = pos[0] if enabled else 0.0
+        act[f"{ACTION}.target_z"] = pos[2] if enabled else 0.0
+        act[f"{ACTION}.target_wx"] = rotvec[1] if enabled else 0.0
+        act[f"{ACTION}.target_wy"] = rotvec[0] if enabled else 0.0
+        act[f"{ACTION}.target_wz"] = -rotvec[2] if enabled else 0.0
+        act[f"{ACTION}.gripper"] = gripper  # Still send gripper action when disabled
         return act
 
     def transform_features(self, features: dict[str, PolicyFeature]) -> dict[str, PolicyFeature]:
-        features.pop("action.phone.enabled", None)
-        features.pop("action.phone.pos", None)
-        features.pop("action.phone.rot", None)
-        features.pop("action.phone.raw_inputs", None)
+        features.pop(f"{ACTION}.phone.enabled", None)
+        features.pop(f"{ACTION}.phone.pos", None)
+        features.pop(f"{ACTION}.phone.rot", None)
+        features.pop(f"{ACTION}.phone.raw_inputs", None)
 
-        features["action.enabled"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.target_x"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.target_y"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.target_z"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.target_wx"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.target_wy"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.target_wz"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
-        features["action.gripper"] = (PolicyFeature(type=FeatureType.ACTION, shape=(1,)),)
+        features[f"{ACTION}.enabled"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_x"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_y"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_z"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_wx"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_wy"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.target_wz"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
+        features[f"{ACTION}.gripper"] = PolicyFeature(type=FeatureType.ACTION, shape=(1,))
         return features

src/lerobot/teleoperators/phone/teleop_phone.py

@@ -101,28 +101,27 @@ class IOSPhone(BasePhone, Teleoperator):
             "Hold the phone so that: top edge points forward in same direction as the robot (robot +x) and screen points up (robot +z)"
         )
         print("Press and hold B1 in the HEBI Mobile I/O app to capture this pose...\n")
-
-        pos, rot = self._wait_for_capture_trigger()
-        self._calib_pos = pos.copy()
-        self._calib_rot_inv = rot.inv()
+        position, rotation = self._wait_for_capture_trigger()
+        self._calib_pos = position.copy()
+        self._calib_rot_inv = rotation.inv()
         self._enabled = False
         print("Calibration done\n")
 
     def _wait_for_capture_trigger(self) -> tuple[np.ndarray, Rotation]:
         """Wait trigger for calibration: iOS: B1. Android: 'move'."""
         while True:
-            ok, pos, rot, pose = self._read_current_pose()
-            if not ok:
+            has_pose, position, rotation, fb_pose = self._read_current_pose()
+            if not has_pose:
                 time.sleep(0.01)
                 continue
 
-            io = getattr(pose, "io", None)
-            b = getattr(io, "b", None) if io is not None else None
-            b1 = False
-            if b is not None:
-                b1 = bool(b.get_int(1))
-            if b1:
-                return pos, rot
+            io = getattr(fb_pose, "io", None)
+            button_b = getattr(io, "b", None) if io is not None else None
+            button_b1_pressed = False
+            if button_b is not None:
+                button_b1_pressed = bool(button_b.get_int(1))
+            if button_b1_pressed:
+                return position, rotation
 
             time.sleep(0.01)
 
@@ -141,13 +140,13 @@ class IOSPhone(BasePhone, Teleoperator):
         return True, pos, rot, pose
 
     def get_action(self) -> dict:
-        ok, raw_pos, raw_rot, pose = self._read_current_pose()
-        if not ok or not self.is_calibrated:
+        has_pose, raw_position, raw_rotation, fb_pose = self._read_current_pose()
+        if not has_pose or not self.is_calibrated:
             return {}
 
         # Collect raw inputs (B1 / analogs on iOS, move/scale on Android)
         raw_inputs: dict[str, float | int | bool] = {}
-        io = getattr(pose, "io", None)
+        io = getattr(fb_pose, "io", None)
         if io is not None:
             bank_a, bank_b = io.a, io.b
             if bank_a:
@@ -165,11 +164,11 @@ class IOSPhone(BasePhone, Teleoperator):
 
         # Rising edge then re-capture calibration immediately from current raw pose
         if enable and not self._enabled:
-            self._reapply_position_calibration(raw_pos)
+            self._reapply_position_calibration(raw_position)
 
         # Apply calibration
-        pos_cal = self._calib_rot_inv.apply(raw_pos - self._calib_pos)
-        rot_cal = self._calib_rot_inv * raw_rot
+        pos_cal = self._calib_rot_inv.apply(raw_position - self._calib_pos)
+        rot_cal = self._calib_rot_inv * raw_rotation
 
         self._enabled = enable
 

src/lerobot/utils/control_utils.py

@@ -31,7 +31,7 @@ from termcolor import colored
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.utils import DEFAULT_FEATURES
 from lerobot.policies.pretrained import PreTrainedPolicy
-from lerobot.processor import RobotProcessor, TransitionKey
+from lerobot.processor import PolicyProcessorPipeline, TransitionKey
 from lerobot.robots import Robot
 
 
@@ -102,8 +102,8 @@ def predict_action(
     observation: dict[str, np.ndarray],
     policy: PreTrainedPolicy,
     device: torch.device,
-    preprocessor: RobotProcessor,
-    postprocessor: RobotProcessor,
+    preprocessor: PolicyProcessorPipeline,
+    postprocessor: PolicyProcessorPipeline,
     use_amp: bool,
     task: str | None = None,
     robot_type: str | None = None,

src/lerobot/utils/train_utils.py

@@ -32,7 +32,7 @@ from lerobot.datasets.utils import load_json, write_json
 from lerobot.optim.optimizers import load_optimizer_state, save_optimizer_state
 from lerobot.optim.schedulers import load_scheduler_state, save_scheduler_state
 from lerobot.policies.pretrained import PreTrainedPolicy
-from lerobot.processor.pipeline import RobotProcessor
+from lerobot.processor import PolicyProcessorPipeline
 from lerobot.utils.random_utils import load_rng_state, save_rng_state
 
 
@@ -75,8 +75,8 @@ def save_checkpoint(
     policy: PreTrainedPolicy,
     optimizer: Optimizer,
     scheduler: LRScheduler | None = None,
-    preprocessor: RobotProcessor | None = None,
-    postprocessor: RobotProcessor | None = None,
+    preprocessor: PolicyProcessorPipeline | None = None,
+    postprocessor: PolicyProcessorPipeline | None = None,
 ) -> None:
     """This function creates the following directory structure:
 

src/lerobot/utils/visualization_utils.py

@@ -19,7 +19,7 @@ from typing import Any
 import numpy as np
 import rerun as rr
 
-from lerobot.processor.pipeline import EnvTransition, TransitionKey
+from lerobot.processor import EnvTransition, TransitionKey
 
 
 def _init_rerun(session_name: str = "lerobot_control_loop") -> None:

tests/datasets/test_dataset_utils.py

@@ -20,7 +20,7 @@ from datasets import Dataset
 from huggingface_hub import DatasetCard
 
 from lerobot.datasets.push_dataset_to_hub.utils import calculate_episode_data_index
-from lerobot.datasets.utils import create_lerobot_dataset_card, hf_transform_to_torch, merge_features
+from lerobot.datasets.utils import combine_feature_dicts, create_lerobot_dataset_card, hf_transform_to_torch
 
 
 def test_default_parameters():
@@ -72,7 +72,7 @@ def test_merge_simple_vectors():
         }
     }
 
-    out = merge_features(g1, g2)
+    out = combine_feature_dicts(g1, g2)
 
     assert "action" in out
     assert out["action"]["dtype"] == "float32"
@@ -87,7 +87,7 @@ def test_merge_multiple_groups_order_and_dedup():
     g2 = {"action": {"dtype": "float32", "shape": (2,), "names": ["b", "c"]}}
     g3 = {"action": {"dtype": "float32", "shape": (3,), "names": ["a", "c", "d"]}}
 
-    out = merge_features(g1, g2, g3)
+    out = combine_feature_dicts(g1, g2, g3)
 
     assert out["action"]["names"] == ["a", "b", "c", "d"]
     assert out["action"]["shape"] == (4,)
@@ -110,7 +110,7 @@ def test_non_vector_last_wins_for_images():
         }
     }
 
-    out = merge_features(g1, g2)
+    out = combine_feature_dicts(g1, g2)
     assert out["observation.images.front"]["shape"] == (3, 720, 1280)
     assert out["observation.images.front"]["dtype"] == "image"
 
@@ -120,13 +120,13 @@ def test_dtype_mismatch_raises():
     g2 = {"action": {"dtype": "float64", "shape": (1,), "names": ["b"]}}
 
     with pytest.raises(ValueError, match="dtype mismatch for 'action'"):
-        _ = merge_features(g1, g2)
+        _ = combine_feature_dicts(g1, g2)
 
 
 def test_non_dict_passthrough_last_wins():
     g1 = {"misc": 123}
     g2 = {"misc": 456}
 
-    out = merge_features(g1, g2)
+    out = combine_feature_dicts(g1, g2)
     # For non-dict entries the last one wins
     assert out["misc"] == 456

tests/processor/test_act_processor.py

@@ -25,14 +25,14 @@ from lerobot.constants import ACTION, OBS_STATE
 from lerobot.policies.act.configuration_act import ACTConfig
 from lerobot.policies.act.processor_act import make_act_pre_post_processors
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -86,15 +86,15 @@ def test_make_act_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 4
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
-    assert isinstance(preprocessor.steps[3], DeviceProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
+    assert isinstance(preprocessor.steps[3], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_act_processor_normalization():
@@ -250,7 +250,7 @@ def test_act_processor_save_and_load():
         preprocessor.save_pretrained(tmpdir)
 
         # Load preprocessor
-        loaded_preprocessor = RobotProcessor.from_pretrained(
+        loaded_preprocessor = DataProcessorPipeline.from_pretrained(
             tmpdir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -303,11 +303,11 @@ def test_act_processor_mixed_precision():
         postprocessor_kwargs={"to_transition": lambda x: x, "to_output": lambda x: x},
     )
 
-    # Replace DeviceProcessor with one that uses float16
+    # Replace DeviceProcessorStep with one that uses float16
     modified_steps = []
     for step in preprocessor.steps:
-        if isinstance(step, DeviceProcessor):
-            modified_steps.append(DeviceProcessor(device=config.device, float_dtype="float16"))
+        if isinstance(step, DeviceProcessorStep):
+            modified_steps.append(DeviceProcessorStep(device=config.device, float_dtype="float16"))
         else:
             modified_steps.append(step)
     preprocessor.steps = modified_steps

tests/processor/test_batch_conversion.py

@@ -1,11 +1,7 @@
 import torch
 
-from lerobot.processor.pipeline import (
-    RobotProcessor,
-    TransitionKey,
-    _default_batch_to_transition,
-    _default_transition_to_batch,
-)
+from lerobot.processor import DataProcessorPipeline, TransitionKey
+from lerobot.processor.converters import batch_to_transition, transition_to_batch
 
 
 def _dummy_batch():
@@ -24,7 +20,7 @@ def _dummy_batch():
 
 def test_observation_grouping_roundtrip():
     """Test that observation.* keys are properly grouped and ungrouped."""
-    proc = RobotProcessor([])
+    proc = DataProcessorPipeline([])
     batch_in = _dummy_batch()
     batch_out = proc(batch_in)
 
@@ -48,7 +44,7 @@ def test_observation_grouping_roundtrip():
 
 
 def test_batch_to_transition_observation_grouping():
-    """Test that _default_batch_to_transition correctly groups observation.* keys."""
+    """Test that batch_to_transition correctly groups observation.* keys."""
     batch = {
         "observation.image.top": torch.randn(1, 3, 128, 128),
         "observation.image.left": torch.randn(1, 3, 128, 128),
@@ -60,7 +56,7 @@ def test_batch_to_transition_observation_grouping():
         "info": {"episode": 42},
     }
 
-    transition = _default_batch_to_transition(batch)
+    transition = batch_to_transition(batch)
 
     # Check observation is a dict with all observation.* keys
     assert isinstance(transition[TransitionKey.OBSERVATION], dict)
@@ -87,7 +83,7 @@ def test_batch_to_transition_observation_grouping():
 
 
 def test_transition_to_batch_observation_flattening():
-    """Test that _default_transition_to_batch correctly flattens observation dict."""
+    """Test that transition_to_batch correctly flattens observation dict."""
     observation_dict = {
         "observation.image.top": torch.randn(1, 3, 128, 128),
         "observation.image.left": torch.randn(1, 3, 128, 128),
@@ -104,7 +100,7 @@ def test_transition_to_batch_observation_flattening():
         TransitionKey.COMPLEMENTARY_DATA: {},
     }
 
-    batch = _default_transition_to_batch(transition)
+    batch = transition_to_batch(transition)
 
     # Check that observation.* keys are flattened back to batch
     assert "observation.image.top" in batch
@@ -134,7 +130,7 @@ def test_no_observation_keys():
         "info": {"test": "no_obs"},
     }
 
-    transition = _default_batch_to_transition(batch)
+    transition = batch_to_transition(batch)
 
     # Observation should be None when no observation.* keys
     assert transition[TransitionKey.OBSERVATION] is None
@@ -147,7 +143,7 @@ def test_no_observation_keys():
     assert transition[TransitionKey.INFO] == {"test": "no_obs"}
 
     # Round trip should work
-    reconstructed_batch = _default_transition_to_batch(transition)
+    reconstructed_batch = transition_to_batch(transition)
     assert reconstructed_batch["action"] == "action_data"
     assert reconstructed_batch["next.reward"] == 2.0
     assert not reconstructed_batch["next.done"]
@@ -159,7 +155,7 @@ def test_minimal_batch():
     """Test with minimal batch containing only observation.* and action."""
     batch = {"observation.state": "minimal_state", "action": "minimal_action"}
 
-    transition = _default_batch_to_transition(batch)
+    transition = batch_to_transition(batch)
 
     # Check observation
     assert transition[TransitionKey.OBSERVATION] == {"observation.state": "minimal_state"}
@@ -173,7 +169,7 @@ def test_minimal_batch():
     assert transition[TransitionKey.COMPLEMENTARY_DATA] == {}
 
     # Round trip
-    reconstructed_batch = _default_transition_to_batch(transition)
+    reconstructed_batch = transition_to_batch(transition)
     assert reconstructed_batch["observation.state"] == "minimal_state"
     assert reconstructed_batch["action"] == "minimal_action"
     assert reconstructed_batch["next.reward"] == 0.0
@@ -186,7 +182,7 @@ def test_empty_batch():
     """Test behavior with empty batch."""
     batch = {}
 
-    transition = _default_batch_to_transition(batch)
+    transition = batch_to_transition(batch)
 
     # All fields should have defaults
     assert transition[TransitionKey.OBSERVATION] is None
@@ -198,7 +194,7 @@ def test_empty_batch():
     assert transition[TransitionKey.COMPLEMENTARY_DATA] == {}
 
     # Round trip
-    reconstructed_batch = _default_transition_to_batch(transition)
+    reconstructed_batch = transition_to_batch(transition)
     assert reconstructed_batch["action"] is None
     assert reconstructed_batch["next.reward"] == 0.0
     assert not reconstructed_batch["next.done"]
@@ -219,8 +215,8 @@ def test_complex_nested_observation():
         "info": {"episode_length": 200, "success": True},
     }
 
-    transition = _default_batch_to_transition(batch)
-    reconstructed_batch = _default_transition_to_batch(transition)
+    transition = batch_to_transition(batch)
+    reconstructed_batch = transition_to_batch(transition)
 
     # Check that all observation keys are preserved
     original_obs_keys = {k for k in batch if k.startswith("observation.")}
@@ -254,7 +250,7 @@ def test_custom_converter():
 
     def to_tr(batch):
         # Custom converter that modifies the reward
-        tr = _default_batch_to_transition(batch)
+        tr = batch_to_transition(batch)
         # Double the reward
         reward = tr.get(TransitionKey.REWARD, 0.0)
         new_tr = tr.copy()
@@ -262,10 +258,10 @@ def test_custom_converter():
         return new_tr
 
     def to_batch(tr):
-        batch = _default_transition_to_batch(tr)
+        batch = transition_to_batch(tr)
         return batch
 
-    processor = RobotProcessor(steps=[], to_transition=to_tr, to_output=to_batch)
+    processor = DataProcessorPipeline(steps=[], to_transition=to_tr, to_output=to_batch)
 
     batch = {
         "observation.state": torch.randn(1, 4),

tests/processor/test_batch_processor.py

@@ -22,9 +22,12 @@ import pytest
 import torch
 
 from lerobot.constants import OBS_ENV_STATE, OBS_IMAGE, OBS_IMAGES, OBS_STATE
-from lerobot.processor import ProcessorStepRegistry, RobotProcessor
-from lerobot.processor.batch_processor import ToBatchProcessor
-from lerobot.processor.pipeline import TransitionKey
+from lerobot.processor import (
+    AddBatchDimensionProcessorStep,
+    DataProcessorPipeline,
+    ProcessorStepRegistry,
+    TransitionKey,
+)
 
 
 def create_transition(
@@ -44,7 +47,7 @@ def create_transition(
 
 def test_state_1d_to_2d():
     """Test that 1D state tensors get unsqueezed to 2D."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test observation.state
     state_1d = torch.randn(7)
@@ -60,7 +63,7 @@ def test_state_1d_to_2d():
 
 def test_env_state_1d_to_2d():
     """Test that 1D environment state tensors get unsqueezed to 2D."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test observation.environment_state
     env_state_1d = torch.randn(10)
@@ -76,7 +79,7 @@ def test_env_state_1d_to_2d():
 
 def test_image_3d_to_4d():
     """Test that 3D image tensors get unsqueezed to 4D."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test observation.image
     image_3d = torch.randn(224, 224, 3)
@@ -92,7 +95,7 @@ def test_image_3d_to_4d():
 
 def test_multiple_images_3d_to_4d():
     """Test that 3D image tensors in observation.images.* get unsqueezed to 4D."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test observation.images.camera1 and observation.images.camera2
     image1_3d = torch.randn(64, 64, 3)
@@ -117,7 +120,7 @@ def test_multiple_images_3d_to_4d():
 
 def test_already_batched_tensors_unchanged():
     """Test that already batched tensors remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create already batched tensors
     state_2d = torch.randn(1, 7)
@@ -143,7 +146,7 @@ def test_already_batched_tensors_unchanged():
 
 def test_higher_dimensional_tensors_unchanged():
     """Test that tensors with more dimensions than expected remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create tensors with more dimensions
     state_3d = torch.randn(2, 7, 5)  # More than 1D
@@ -166,7 +169,7 @@ def test_higher_dimensional_tensors_unchanged():
 
 def test_non_tensor_values_unchanged():
     """Test that non-tensor values in observations remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     observation = {
         OBS_STATE: [1, 2, 3],  # List, not tensor
@@ -189,7 +192,7 @@ def test_non_tensor_values_unchanged():
 
 def test_none_observation():
     """Test processor handles None observation gracefully."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     transition = create_transition(observation=None)
     result = processor(transition)
@@ -199,7 +202,7 @@ def test_none_observation():
 
 def test_empty_observation():
     """Test processor handles empty observation dict."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     observation = {}
     transition = create_transition(observation=observation)
@@ -211,7 +214,7 @@ def test_empty_observation():
 
 def test_mixed_observation():
     """Test processor with mixed observation containing various types and dimensions."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     state_1d = torch.randn(5)
     env_state_2d = torch.randn(1, 8)  # Already batched
@@ -243,9 +246,9 @@ def test_mixed_observation():
 
 
 def test_integration_with_robot_processor():
-    """Test ToBatchProcessor integration with RobotProcessor."""
-    to_batch_processor = ToBatchProcessor()
-    pipeline = RobotProcessor([to_batch_processor], to_transition=lambda x: x, to_output=lambda x: x)
+    """Test AddBatchDimensionProcessorStep integration with RobotProcessor."""
+    to_batch_processor = AddBatchDimensionProcessorStep()
+    pipeline = DataProcessorPipeline([to_batch_processor], to_transition=lambda x: x, to_output=lambda x: x)
 
     # Create unbatched observation
     observation = {
@@ -263,7 +266,7 @@ def test_integration_with_robot_processor():
 
 def test_serialization_methods():
     """Test get_config, state_dict, load_state_dict, and reset methods."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test get_config
     config = processor.get_config()
@@ -283,9 +286,9 @@ def test_serialization_methods():
 
 
 def test_save_and_load_pretrained():
-    """Test saving and loading ToBatchProcessor with RobotProcessor."""
-    processor = ToBatchProcessor()
-    pipeline = RobotProcessor(
+    """Test saving and loading AddBatchDimensionProcessorStep with RobotProcessor."""
+    processor = AddBatchDimensionProcessorStep()
+    pipeline = DataProcessorPipeline(
         [processor], name="BatchPipeline", to_transition=lambda x: x, to_output=lambda x: x
     )
 
@@ -298,13 +301,13 @@ def test_save_and_load_pretrained():
         assert config_path.exists()
 
         # Load pipeline
-        loaded_pipeline = RobotProcessor.from_pretrained(
+        loaded_pipeline = DataProcessorPipeline.from_pretrained(
             tmp_dir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
         assert loaded_pipeline.name == "BatchPipeline"
         assert len(loaded_pipeline) == 1
-        assert isinstance(loaded_pipeline.steps[0], ToBatchProcessor)
+        assert isinstance(loaded_pipeline.steps[0], AddBatchDimensionProcessorStep)
 
         # Test functionality of loaded processor
         observation = {OBS_STATE: torch.randn(5)}
@@ -315,10 +318,10 @@ def test_save_and_load_pretrained():
 
 
 def test_registry_functionality():
-    """Test that ToBatchProcessor is properly registered."""
+    """Test that AddBatchDimensionProcessorStep is properly registered."""
     # Check that the processor is registered
     registered_class = ProcessorStepRegistry.get("to_batch_processor")
-    assert registered_class is ToBatchProcessor
+    assert registered_class is AddBatchDimensionProcessorStep
 
     # Check that it's in the list of registered processors
     assert "to_batch_processor" in ProcessorStepRegistry.list()
@@ -326,12 +329,12 @@ def test_registry_functionality():
 
 def test_registry_based_save_load():
     """Test saving and loading using registry name."""
-    processor = ToBatchProcessor()
-    pipeline = RobotProcessor([processor], to_transition=lambda x: x, to_output=lambda x: x)
+    processor = AddBatchDimensionProcessorStep()
+    pipeline = DataProcessorPipeline([processor], to_transition=lambda x: x, to_output=lambda x: x)
 
     with tempfile.TemporaryDirectory() as tmp_dir:
         pipeline.save_pretrained(tmp_dir)
-        loaded_pipeline = RobotProcessor.from_pretrained(
+        loaded_pipeline = DataProcessorPipeline.from_pretrained(
             tmp_dir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -352,7 +355,7 @@ def test_registry_based_save_load():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_device_compatibility():
     """Test processor works with tensors on different devices."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create tensors on GPU
     state_1d = torch.randn(7, device="cuda")
@@ -376,7 +379,7 @@ def test_device_compatibility():
 
 def test_processor_preserves_other_transition_keys():
     """Test that processor only modifies observation and preserves other transition keys."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     action = torch.randn(5)
     reward = 1.5
@@ -413,7 +416,7 @@ def test_processor_preserves_other_transition_keys():
 
 def test_edge_case_zero_dimensional_tensors():
     """Test processor handles 0D tensors (scalars) correctly."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # 0D tensors should not be modified
     scalar_tensor = torch.tensor(42.0)
@@ -435,7 +438,7 @@ def test_edge_case_zero_dimensional_tensors():
 # Action-specific tests
 def test_action_1d_to_2d():
     """Test that 1D action tensors get batch dimension added."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create 1D action tensor
     action_1d = torch.randn(4)
@@ -450,7 +453,7 @@ def test_action_1d_to_2d():
 
 def test_action_already_batched():
     """Test that already batched action tensors remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test various batch sizes
     action_batched_1 = torch.randn(1, 4)
@@ -469,7 +472,7 @@ def test_action_already_batched():
 
 def test_action_higher_dimensional():
     """Test that higher dimensional action tensors remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # 3D action tensor (e.g., sequence of actions)
     action_3d = torch.randn(2, 4, 3)
@@ -486,7 +489,7 @@ def test_action_higher_dimensional():
 
 def test_action_scalar_tensor():
     """Test that scalar (0D) action tensors remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     action_scalar = torch.tensor(1.5)
     transition = create_transition(action=action_scalar)
@@ -499,7 +502,7 @@ def test_action_scalar_tensor():
 
 def test_action_non_tensor():
     """Test that non-tensor actions remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # List action
     action_list = [0.1, 0.2, 0.3, 0.4]
@@ -528,7 +531,7 @@ def test_action_non_tensor():
 
 def test_action_none():
     """Test that None action is handled correctly."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     transition = create_transition(action=None)
     result = processor(transition)
@@ -537,7 +540,7 @@ def test_action_none():
 
 def test_action_with_observation():
     """Test action processing together with observation processing."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Both need batching
     observation = {
@@ -557,7 +560,7 @@ def test_action_with_observation():
 
 def test_action_different_sizes():
     """Test action processing with various action dimensions."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Different action sizes (robot with different DOF)
     action_sizes = [1, 2, 4, 7, 10, 20]
@@ -574,7 +577,7 @@ def test_action_different_sizes():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_action_device_compatibility():
     """Test action processing on different devices."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # CUDA action
     action_cuda = torch.randn(4, device="cuda")
@@ -595,7 +598,7 @@ def test_action_device_compatibility():
 
 def test_action_dtype_preservation():
     """Test that action dtype is preserved during processing."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Different dtypes
     dtypes = [torch.float32, torch.float64, torch.int32, torch.int64]
@@ -611,7 +614,7 @@ def test_action_dtype_preservation():
 
 def test_empty_action_tensor():
     """Test handling of empty action tensors."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Empty 1D tensor
     action_empty = torch.tensor([])
@@ -633,7 +636,7 @@ def test_empty_action_tensor():
 # Task-specific tests
 def test_task_string_to_list():
     """Test that string tasks get wrapped in lists to add batch dimension."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create complementary data with string task
     complementary_data = {"task": "pick_cube"}
@@ -650,7 +653,7 @@ def test_task_string_to_list():
 
 def test_task_string_validation():
     """Test that only string and list of strings are valid task values."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Valid string task - should be converted to list
     complementary_data = {"task": "valid_task"}
@@ -669,7 +672,7 @@ def test_task_string_validation():
 
 def test_task_list_of_strings():
     """Test that lists of strings remain unchanged (already batched)."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test various list of strings
     test_lists = [
@@ -695,7 +698,7 @@ def test_task_list_of_strings():
 
 def test_complementary_data_none():
     """Test processor handles None complementary_data gracefully."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     transition = create_transition(complementary_data=None)
     result = processor(transition)
@@ -705,7 +708,7 @@ def test_complementary_data_none():
 
 def test_complementary_data_empty():
     """Test processor handles empty complementary_data dict."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     complementary_data = {}
     transition = create_transition(complementary_data=complementary_data)
@@ -717,7 +720,7 @@ def test_complementary_data_empty():
 
 def test_complementary_data_no_task():
     """Test processor handles complementary_data without task field."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     complementary_data = {
         "episode_id": 123,
@@ -735,7 +738,7 @@ def test_complementary_data_no_task():
 
 def test_complementary_data_mixed():
     """Test processor with mixed complementary_data containing task and other fields."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     complementary_data = {
         "task": "stack_blocks",
@@ -760,7 +763,7 @@ def test_complementary_data_mixed():
 
 def test_task_with_observation_and_action():
     """Test task processing together with observation and action processing."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # All components need batching
     observation = {
@@ -785,7 +788,7 @@ def test_task_with_observation_and_action():
 
 def test_task_comprehensive_string_cases():
     """Test task processing with comprehensive string cases and edge cases."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test various string formats
     string_tasks = [
@@ -843,7 +846,7 @@ def test_task_comprehensive_string_cases():
 
 def test_task_preserves_other_keys():
     """Test that task processing preserves other keys in complementary_data."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     complementary_data = {
         "task": "clean_table",
@@ -871,7 +874,7 @@ def test_task_preserves_other_keys():
 # Index and task_index specific tests
 def test_index_scalar_to_1d():
     """Test that 0D index tensor gets unsqueezed to 1D."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create 0D index tensor (scalar)
     index_0d = torch.tensor(42, dtype=torch.int64)
@@ -888,7 +891,7 @@ def test_index_scalar_to_1d():
 
 def test_task_index_scalar_to_1d():
     """Test that 0D task_index tensor gets unsqueezed to 1D."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create 0D task_index tensor (scalar)
     task_index_0d = torch.tensor(7, dtype=torch.int64)
@@ -905,7 +908,7 @@ def test_task_index_scalar_to_1d():
 
 def test_index_and_task_index_together():
     """Test processing both index and task_index together."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create 0D tensors for both
     index_0d = torch.tensor(100, dtype=torch.int64)
@@ -935,7 +938,7 @@ def test_index_and_task_index_together():
 
 def test_index_already_batched():
     """Test that already batched index tensors remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create already batched tensors
     index_1d = torch.tensor([42], dtype=torch.int64)
@@ -956,7 +959,7 @@ def test_index_already_batched():
 
 def test_task_index_already_batched():
     """Test that already batched task_index tensors remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create already batched tensors
     task_index_1d = torch.tensor([7], dtype=torch.int64)
@@ -977,7 +980,7 @@ def test_task_index_already_batched():
 
 def test_index_non_tensor_unchanged():
     """Test that non-tensor index values remain unchanged."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     complementary_data = {
         "index": 42,  # Plain int, not tensor
@@ -994,7 +997,7 @@ def test_index_non_tensor_unchanged():
 
 def test_index_dtype_preservation():
     """Test that index and task_index dtype is preserved during processing."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Test different dtypes
     dtypes = [torch.int32, torch.int64, torch.long]
@@ -1017,7 +1020,7 @@ def test_index_dtype_preservation():
 
 def test_index_with_full_transition():
     """Test index/task_index processing with full transition data."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create full transition with all components
     observation = {
@@ -1059,7 +1062,7 @@ def test_index_with_full_transition():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_index_device_compatibility():
     """Test processor works with index/task_index tensors on different devices."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Create tensors on GPU
     index_0d = torch.tensor(42, dtype=torch.int64, device="cuda")
@@ -1083,7 +1086,7 @@ def test_index_device_compatibility():
 
 def test_empty_index_tensor():
     """Test handling of empty index tensors."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     # Empty 0D tensor doesn't make sense, but test empty 1D
     index_empty = torch.tensor([], dtype=torch.int64)
@@ -1098,7 +1101,7 @@ def test_empty_index_tensor():
 
 def test_action_processing_creates_new_transition():
     """Test that the processor creates a new transition object with correctly processed action."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     action = torch.randn(4)
     transition = create_transition(action=action)
@@ -1120,7 +1123,7 @@ def test_action_processing_creates_new_transition():
 
 def test_task_processing_creates_new_transition():
     """Test that the processor creates a new transition object with correctly processed task."""
-    processor = ToBatchProcessor()
+    processor = AddBatchDimensionProcessorStep()
 
     complementary_data = {"task": "sort_objects"}
     transition = create_transition(complementary_data=complementary_data)

tests/processor/test_classifier_processor.py

@@ -24,8 +24,13 @@ from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
 from lerobot.constants import OBS_IMAGE, OBS_STATE
 from lerobot.policies.sac.reward_model.configuration_classifier import RewardClassifierConfig
 from lerobot.policies.sac.reward_model.processor_classifier import make_classifier_processor
-from lerobot.processor import DeviceProcessor, IdentityProcessor, NormalizerProcessor, RobotProcessor
-from lerobot.processor.pipeline import TransitionKey
+from lerobot.processor import (
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    IdentityProcessorStep,
+    NormalizerProcessorStep,
+    TransitionKey,
+)
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -82,14 +87,14 @@ def test_make_classifier_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 3
-    assert isinstance(preprocessor.steps[0], NormalizerProcessor)  # For input features
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)  # For output features
-    assert isinstance(preprocessor.steps[2], DeviceProcessor)
+    assert isinstance(preprocessor.steps[0], NormalizerProcessorStep)  # For input features
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)  # For output features
+    assert isinstance(preprocessor.steps[2], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], IdentityProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], IdentityProcessorStep)
 
 
 def test_classifier_processor_normalization():
@@ -249,7 +254,7 @@ def test_classifier_processor_save_and_load():
     factory_preprocessor, factory_postprocessor = make_classifier_processor(config, stats)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(
+    preprocessor = DataProcessorPipeline(
         factory_preprocessor.steps, to_transition=lambda x: x, to_output=lambda x: x
     )
 
@@ -258,7 +263,7 @@ def test_classifier_processor_save_and_load():
         preprocessor.save_pretrained(tmpdir)
 
         # Load preprocessor
-        loaded_preprocessor = RobotProcessor.from_pretrained(
+        loaded_preprocessor = DataProcessorPipeline.from_pretrained(
             tmpdir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -286,16 +291,16 @@ def test_classifier_processor_mixed_precision():
     # Get the steps from the factory function
     factory_preprocessor, factory_postprocessor = make_classifier_processor(config, stats)
 
-    # Replace DeviceProcessor with one that uses float16
+    # Replace DeviceProcessorStep with one that uses float16
     modified_steps = []
     for step in factory_preprocessor.steps:
-        if isinstance(step, DeviceProcessor):
-            modified_steps.append(DeviceProcessor(device=config.device, float_dtype="float16"))
+        if isinstance(step, DeviceProcessorStep):
+            modified_steps.append(DeviceProcessorStep(device=config.device, float_dtype="float16"))
         else:
             modified_steps.append(step)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(modified_steps, to_transition=lambda x: x, to_output=lambda x: x)
+    preprocessor = DataProcessorPipeline(modified_steps, to_transition=lambda x: x, to_output=lambda x: x)
 
     # Create test data
     observation = {

tests/processor/test_converters.py

@@ -2,14 +2,16 @@ import numpy as np
 import pytest
 import torch
 
+from lerobot.processor import TransitionKey
 from lerobot.processor.converters import (
-    to_dataset_frame,
-    to_output_robot_action,
+    action_to_transition,
+    batch_to_transition,
+    observation_to_transition,
     to_tensor,
-    to_transition_robot_observation,
-    to_transition_teleop_action,
+    transition_to_batch,
+    transition_to_dataset_frame,
+    transition_to_robot_action,
 )
-from lerobot.processor.pipeline import TransitionKey
 
 
 def test_to_transition_teleop_action_prefix_and_tensor_conversion():
@@ -21,7 +23,7 @@ def test_to_transition_teleop_action_prefix_and_tensor_conversion():
         "raw_img": img,  # uint8 HWC to torch tensor
     }
 
-    tr = to_transition_teleop_action(act)
+    tr = action_to_transition(act)
 
     # Should be an EnvTransition-like dict with ACTION populated
     assert isinstance(tr, dict)
@@ -59,7 +61,7 @@ def test_to_transition_robot_observation_state_vs_images_split():
         "arr": np.array([1.5, 2.5]),  # vector to state to torch tensor
     }
 
-    tr = to_transition_robot_observation(obs)
+    tr = observation_to_transition(obs)
     assert isinstance(tr, dict)
     assert TransitionKey.OBSERVATION in tr
 
@@ -97,7 +99,7 @@ def test_to_output_robot_action_strips_prefix_and_filters_pos_keys_only():
         }
     }
 
-    out = to_output_robot_action(tr)
+    out = transition_to_robot_action(tr)
     # Only ".pos" keys with "action." prefix are retained and stripped to base names
     assert set(out.keys()) == {"j1.pos", "gripper.pos"}
     # Values converted to float
@@ -107,7 +109,7 @@ def test_to_output_robot_action_strips_prefix_and_filters_pos_keys_only():
     assert out["gripper.pos"] == pytest.approx(33.0)
 
 
-def test_to_dataset_frame_merge_and_pack_vectors_and_metadata():
+def test_transition_to_dataset_frame_merge_and_pack_vectors_and_metadata():
     # Fabricate dataset features (as stored in dataset.meta["features"])
     features = {
         # Action vector: 3 elements in specific order
@@ -160,7 +162,7 @@ def test_to_dataset_frame_merge_and_pack_vectors_and_metadata():
     }
 
     # Directly call the refactored function
-    batch = to_dataset_frame([teleop_transition, robot_transition], features)
+    batch = transition_to_dataset_frame([teleop_transition, robot_transition], features)
 
     # Images passthrough
     assert "observation.images.front" in batch
@@ -377,3 +379,117 @@ def test_to_tensor_unsupported_type():
 
     with pytest.raises(TypeError, match="Unsupported type for tensor conversion"):
         to_tensor(object())
+
+
+def create_transition(
+    observation=None, action=None, reward=0.0, done=False, truncated=False, info=None, complementary_data=None
+):
+    """Helper to create an EnvTransition dictionary."""
+    return {
+        TransitionKey.OBSERVATION: observation,
+        TransitionKey.ACTION: action,
+        TransitionKey.REWARD: reward,
+        TransitionKey.DONE: done,
+        TransitionKey.TRUNCATED: truncated,
+        TransitionKey.INFO: info if info is not None else {},
+        TransitionKey.COMPLEMENTARY_DATA: complementary_data if complementary_data is not None else {},
+    }
+
+
+def test_batch_to_transition_with_index_fields():
+    """Test that batch_to_transition handles index and task_index fields correctly."""
+
+    # Create batch with index and task_index fields
+    batch = {
+        "observation.state": torch.randn(1, 7),
+        "action": torch.randn(1, 4),
+        "next.reward": 1.5,
+        "next.done": False,
+        "task": ["pick_cube"],
+        "index": torch.tensor([42], dtype=torch.int64),
+        "task_index": torch.tensor([3], dtype=torch.int64),
+    }
+
+    transition = batch_to_transition(batch)
+
+    # Check basic transition structure
+    assert TransitionKey.OBSERVATION in transition
+    assert TransitionKey.ACTION in transition
+    assert TransitionKey.COMPLEMENTARY_DATA in transition
+
+    # Check that index and task_index are in complementary_data
+    comp_data = transition[TransitionKey.COMPLEMENTARY_DATA]
+    assert "index" in comp_data
+    assert "task_index" in comp_data
+    assert "task" in comp_data
+
+    # Verify values
+    assert torch.equal(comp_data["index"], batch["index"])
+    assert torch.equal(comp_data["task_index"], batch["task_index"])
+    assert comp_data["task"] == batch["task"]
+
+
+def testtransition_to_batch_with_index_fields():
+    """Test that transition_to_batch handles index and task_index fields correctly."""
+
+    # Create transition with index and task_index in complementary_data
+    transition = create_transition(
+        observation={"observation.state": torch.randn(1, 7)},
+        action=torch.randn(1, 4),
+        reward=1.5,
+        done=False,
+        complementary_data={
+            "task": ["navigate"],
+            "index": torch.tensor([100], dtype=torch.int64),
+            "task_index": torch.tensor([5], dtype=torch.int64),
+        },
+    )
+
+    batch = transition_to_batch(transition)
+
+    # Check that index and task_index are in the batch
+    assert "index" in batch
+    assert "task_index" in batch
+    assert "task" in batch
+
+    # Verify values
+    assert torch.equal(batch["index"], transition[TransitionKey.COMPLEMENTARY_DATA]["index"])
+    assert torch.equal(batch["task_index"], transition[TransitionKey.COMPLEMENTARY_DATA]["task_index"])
+    assert batch["task"] == transition[TransitionKey.COMPLEMENTARY_DATA]["task"]
+
+
+def test_batch_to_transition_without_index_fields():
+    """Test that conversion works without index and task_index fields."""
+
+    # Batch without index/task_index
+    batch = {
+        "observation.state": torch.randn(1, 7),
+        "action": torch.randn(1, 4),
+        "task": ["pick_cube"],
+    }
+
+    transition = batch_to_transition(batch)
+    comp_data = transition[TransitionKey.COMPLEMENTARY_DATA]
+
+    # Should have task but not index/task_index
+    assert "task" in comp_data
+    assert "index" not in comp_data
+    assert "task_index" not in comp_data
+
+
+def test_transition_to_batch_without_index_fields():
+    """Test that conversion works without index and task_index fields."""
+
+    # Transition without index/task_index
+    transition = create_transition(
+        observation={"observation.state": torch.randn(1, 7)},
+        action=torch.randn(1, 4),
+        complementary_data={"task": ["navigate"]},
+    )
+
+    batch = transition_to_batch(transition)
+
+    # Should have task but not index/task_index
+    assert "task" in batch
+    assert "index" not in batch
+    assert "task_index" not in batch

tests/processor/test_device_processor.py

@@ -19,8 +19,7 @@ import pytest
 import torch
 
 from lerobot.configs.types import FeatureType, PolicyFeature
-from lerobot.processor import DeviceProcessor, RobotProcessor
-from lerobot.processor.pipeline import TransitionKey
+from lerobot.processor import DataProcessorPipeline, DeviceProcessorStep, TransitionKey
 
 
 def create_transition(
@@ -47,7 +46,7 @@ def create_transition(
 
 def test_basic_functionality():
     """Test basic device processor functionality on CPU."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     # Create a transition with CPU tensors
     observation = {"observation.state": torch.randn(10), "observation.image": torch.randn(3, 224, 224)}
@@ -74,7 +73,7 @@ def test_basic_functionality():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_cuda_functionality():
     """Test device processor functionality on CUDA."""
-    processor = DeviceProcessor(device="cuda")
+    processor = DeviceProcessorStep(device="cuda")
 
     # Create a transition with CPU tensors
     observation = {"observation.state": torch.randn(10), "observation.image": torch.randn(3, 224, 224)}
@@ -101,7 +100,7 @@ def test_cuda_functionality():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_specific_cuda_device():
     """Test device processor with specific CUDA device."""
-    processor = DeviceProcessor(device="cuda:0")
+    processor = DeviceProcessorStep(device="cuda:0")
 
     observation = {"observation.state": torch.randn(10)}
     action = torch.randn(5)
@@ -117,7 +116,7 @@ def test_specific_cuda_device():
 
 def test_non_tensor_values():
     """Test that non-tensor values are preserved."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     observation = {
         "observation.state": torch.randn(10),
@@ -143,7 +142,7 @@ def test_non_tensor_values():
 
 def test_none_values():
     """Test handling of None values."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     # Test with None observation
     transition = create_transition(observation=None, action=torch.randn(5))
@@ -160,7 +159,7 @@ def test_none_values():
 
 def test_empty_observation():
     """Test handling of empty observation dictionary."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     transition = create_transition(observation={}, action=torch.randn(5))
     result = processor(transition)
@@ -171,7 +170,7 @@ def test_empty_observation():
 
 def test_scalar_tensors():
     """Test handling of scalar tensors."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     observation = {"observation.scalar": torch.tensor(1.5)}
     action = torch.tensor(2.0)
@@ -188,7 +187,7 @@ def test_scalar_tensors():
 
 def test_dtype_preservation():
     """Test that tensor dtypes are preserved."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     observation = {
         "observation.float32": torch.randn(5, dtype=torch.float32),
@@ -210,7 +209,7 @@ def test_dtype_preservation():
 
 def test_shape_preservation():
     """Test that tensor shapes are preserved."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     observation = {
         "observation.1d": torch.randn(10),
@@ -233,7 +232,7 @@ def test_shape_preservation():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_mixed_devices():
     """Test handling of tensors already on different devices."""
-    processor = DeviceProcessor(device="cuda")
+    processor = DeviceProcessorStep(device="cuda")
 
     # Create tensors on different devices
     observation = {
@@ -254,22 +253,22 @@ def test_mixed_devices():
 def test_non_blocking_flag():
     """Test that non_blocking flag is set correctly."""
     # CPU processor should have non_blocking=False
-    cpu_processor = DeviceProcessor(device="cpu")
+    cpu_processor = DeviceProcessorStep(device="cpu")
     assert cpu_processor.non_blocking is False
 
     if torch.cuda.is_available():
         # CUDA processor should have non_blocking=True
-        cuda_processor = DeviceProcessor(device="cuda")
+        cuda_processor = DeviceProcessorStep(device="cuda")
         assert cuda_processor.non_blocking is True
 
-        cuda_0_processor = DeviceProcessor(device="cuda:0")
+        cuda_0_processor = DeviceProcessorStep(device="cuda:0")
         assert cuda_0_processor.non_blocking is True
 
 
 def test_serialization_methods():
     """Test get_config, state_dict, and load_state_dict methods."""
     device = "cuda" if torch.cuda.is_available() else "cpu"
-    processor = DeviceProcessor(device=device)
+    processor = DeviceProcessorStep(device=device)
 
     # Test get_config
     config = processor.get_config()
@@ -290,7 +289,7 @@ def test_serialization_methods():
 
 def test_features():
     """Test that features returns features unchanged."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     features = {
         "observation.state": PolicyFeature(type=FeatureType.STATE, shape=(10,)),
@@ -305,13 +304,13 @@ def test_features():
 def test_integration_with_robot_processor():
     """Test integration with RobotProcessor."""
     from lerobot.constants import OBS_STATE
-    from lerobot.processor import ToBatchProcessor
+    from lerobot.processor import AddBatchDimensionProcessorStep
 
-    # Create a pipeline with DeviceProcessor
-    device_processor = DeviceProcessor(device="cpu")
-    batch_processor = ToBatchProcessor()
+    # Create a pipeline with DeviceProcessorStep
+    device_processor = DeviceProcessorStep(device="cpu")
+    batch_processor = AddBatchDimensionProcessorStep()
 
-    processor = RobotProcessor(
+    processor = DataProcessorPipeline(
         steps=[batch_processor, device_processor],
         name="test_pipeline",
         to_transition=lambda x: x,
@@ -334,21 +333,21 @@ def test_integration_with_robot_processor():
 
 
 def test_save_and_load_pretrained():
-    """Test saving and loading processor with DeviceProcessor."""
+    """Test saving and loading processor with DeviceProcessorStep."""
     device = "cuda:0" if torch.cuda.is_available() else "cpu"
-    processor = DeviceProcessor(device=device, float_dtype="float16")
-    robot_processor = RobotProcessor(steps=[processor], name="device_test_processor")
+    processor = DeviceProcessorStep(device=device, float_dtype="float16")
+    robot_processor = DataProcessorPipeline(steps=[processor], name="device_test_processor")
 
     with tempfile.TemporaryDirectory() as tmpdir:
         # Save
         robot_processor.save_pretrained(tmpdir)
 
         # Load
-        loaded_processor = RobotProcessor.from_pretrained(tmpdir)
+        loaded_processor = DataProcessorPipeline.from_pretrained(tmpdir)
 
         assert len(loaded_processor.steps) == 1
         loaded_device_processor = loaded_processor.steps[0]
-        assert isinstance(loaded_device_processor, DeviceProcessor)
+        assert isinstance(loaded_device_processor, DeviceProcessorStep)
         # Use getattr to access attributes safely
         assert (
             getattr(loaded_device_processor, "device", None) == device.split(":")[0]
@@ -357,18 +356,18 @@ def test_save_and_load_pretrained():
 
 
 def test_registry_functionality():
-    """Test that DeviceProcessor is properly registered."""
-    from lerobot.processor.pipeline import ProcessorStepRegistry
+    """Test that DeviceProcessorStep is properly registered."""
+    from lerobot.processor import ProcessorStepRegistry
 
-    # Check that DeviceProcessor is registered
+    # Check that DeviceProcessorStep is registered
     registered_class = ProcessorStepRegistry.get("device_processor")
-    assert registered_class is DeviceProcessor
+    assert registered_class is DeviceProcessorStep
 
 
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_performance_with_large_tensors():
     """Test performance with large tensors and non_blocking flag."""
-    processor = DeviceProcessor(device="cuda")
+    processor = DeviceProcessorStep(device="cuda")
 
     # Create large tensors
     observation = {
@@ -390,7 +389,7 @@ def test_performance_with_large_tensors():
 
 def test_reward_done_truncated_types():
     """Test handling of different types for reward, done, and truncated."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     # Test with scalar values (not tensors)
     transition = create_transition(
@@ -430,7 +429,7 @@ def test_reward_done_truncated_types():
 
 def test_complementary_data_preserved():
     """Test that complementary_data is preserved unchanged."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     complementary_data = {
         "task": "pick_object",
@@ -450,13 +449,13 @@ def test_complementary_data_preserved():
     assert result[TransitionKey.COMPLEMENTARY_DATA]["task"] == "pick_object"
     assert result[TransitionKey.COMPLEMENTARY_DATA]["episode_id"] == 42
     assert result[TransitionKey.COMPLEMENTARY_DATA]["metadata"] == {"sensor": "camera_1"}
-    # Note: Currently DeviceProcessor doesn't process tensors in complementary_data
+    # Note: Currently DeviceProcessorStep doesn't process tensors in complementary_data
     # This is intentional as complementary_data is typically metadata
 
 
 def test_float_dtype_conversion():
     """Test float dtype conversion functionality."""
-    processor = DeviceProcessor(device="cpu", float_dtype="float16")
+    processor = DeviceProcessorStep(device="cpu", float_dtype="float16")
 
     # Create tensors of different types
     observation = {
@@ -486,7 +485,7 @@ def test_float_dtype_conversion():
 
 def test_float_dtype_none():
     """Test that when float_dtype is None, no dtype conversion occurs."""
-    processor = DeviceProcessor(device="cpu", float_dtype=None)
+    processor = DeviceProcessorStep(device="cpu", float_dtype=None)
 
     observation = {
         "observation.float32": torch.randn(5, dtype=torch.float32),
@@ -507,7 +506,7 @@ def test_float_dtype_none():
 
 def test_float_dtype_bfloat16():
     """Test conversion to bfloat16."""
-    processor = DeviceProcessor(device="cpu", float_dtype="bfloat16")
+    processor = DeviceProcessorStep(device="cpu", float_dtype="bfloat16")
 
     observation = {"observation.state": torch.randn(5, dtype=torch.float32)}
     action = torch.randn(3, dtype=torch.float64)
@@ -521,7 +520,7 @@ def test_float_dtype_bfloat16():
 
 def test_float_dtype_float64():
     """Test conversion to float64."""
-    processor = DeviceProcessor(device="cpu", float_dtype="float64")
+    processor = DeviceProcessorStep(device="cpu", float_dtype="float64")
 
     observation = {"observation.state": torch.randn(5, dtype=torch.float16)}
     action = torch.randn(3, dtype=torch.float32)
@@ -536,27 +535,27 @@ def test_float_dtype_float64():
 def test_float_dtype_invalid():
     """Test that invalid float_dtype raises ValueError."""
     with pytest.raises(ValueError, match="Invalid float_dtype 'invalid_dtype'"):
-        DeviceProcessor(device="cpu", float_dtype="invalid_dtype")
+        DeviceProcessorStep(device="cpu", float_dtype="invalid_dtype")
 
 
 def test_float_dtype_aliases():
     """Test that dtype aliases work correctly."""
     # Test 'half' alias for float16
-    processor_half = DeviceProcessor(device="cpu", float_dtype="half")
+    processor_half = DeviceProcessorStep(device="cpu", float_dtype="half")
     assert processor_half._target_float_dtype == torch.float16
 
     # Test 'float' alias for float32
-    processor_float = DeviceProcessor(device="cpu", float_dtype="float")
+    processor_float = DeviceProcessorStep(device="cpu", float_dtype="float")
     assert processor_float._target_float_dtype == torch.float32
 
     # Test 'double' alias for float64
-    processor_double = DeviceProcessor(device="cpu", float_dtype="double")
+    processor_double = DeviceProcessorStep(device="cpu", float_dtype="double")
     assert processor_double._target_float_dtype == torch.float64
 
 
 def test_float_dtype_with_mixed_tensors():
     """Test float dtype conversion with mixed tensor types."""
-    processor = DeviceProcessor(device="cpu", float_dtype="float32")
+    processor = DeviceProcessorStep(device="cpu", float_dtype="float32")
 
     observation = {
         "observation.image": torch.randint(0, 255, (3, 64, 64), dtype=torch.uint8),  # Should not convert
@@ -580,13 +579,13 @@ def test_float_dtype_with_mixed_tensors():
 def test_float_dtype_serialization():
     """Test that float_dtype is properly serialized in get_config."""
     device = "cuda" if torch.cuda.is_available() else "cpu"
-    processor = DeviceProcessor(device=device, float_dtype="float16")
+    processor = DeviceProcessorStep(device=device, float_dtype="float16")
     config = processor.get_config()
 
     assert config == {"device": device, "float_dtype": "float16"}
 
     # Test with None float_dtype
-    processor_none = DeviceProcessor(device="cpu", float_dtype=None)
+    processor_none = DeviceProcessorStep(device="cpu", float_dtype=None)
     config_none = processor_none.get_config()
 
     assert config_none == {"device": "cpu", "float_dtype": None}
@@ -595,7 +594,7 @@ def test_float_dtype_serialization():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_float_dtype_with_cuda():
     """Test float dtype conversion combined with CUDA device."""
-    processor = DeviceProcessor(device="cuda", float_dtype="float16")
+    processor = DeviceProcessorStep(device="cuda", float_dtype="float16")
 
     # Create tensors on CPU with different dtypes
     observation = {
@@ -620,7 +619,7 @@ def test_float_dtype_with_cuda():
 
 def test_complementary_data_index_fields():
     """Test processing of index and task_index fields in complementary_data."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     # Create transition with index and task_index in complementary_data
     complementary_data = {
@@ -658,7 +657,7 @@ def test_complementary_data_index_fields():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_complementary_data_index_fields_cuda():
     """Test moving index and task_index fields to CUDA."""
-    processor = DeviceProcessor(device="cuda:0")
+    processor = DeviceProcessorStep(device="cuda:0")
 
     # Create CPU tensors
     complementary_data = {
@@ -680,7 +679,7 @@ def test_complementary_data_index_fields_cuda():
 
 def test_complementary_data_without_index_fields():
     """Test that complementary_data without index/task_index fields works correctly."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     complementary_data = {
         "task": ["navigate"],
@@ -698,7 +697,7 @@ def test_complementary_data_without_index_fields():
 
 def test_complementary_data_mixed_tensors():
     """Test complementary_data with mix of tensors and non-tensors."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     complementary_data = {
         "task": ["pick_and_place"],
@@ -727,7 +726,7 @@ def test_complementary_data_mixed_tensors():
 
 def test_complementary_data_float_dtype_conversion():
     """Test that float dtype conversion doesn't affect int tensors in complementary_data."""
-    processor = DeviceProcessor(device="cpu", float_dtype="float16")
+    processor = DeviceProcessorStep(device="cpu", float_dtype="float16")
 
     complementary_data = {
         "index": torch.tensor([42], dtype=torch.int64),
@@ -751,7 +750,7 @@ def test_complementary_data_float_dtype_conversion():
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_complementary_data_full_pipeline_cuda():
     """Test full transition with complementary_data on CUDA."""
-    processor = DeviceProcessor(device="cuda:0", float_dtype="float16")
+    processor = DeviceProcessorStep(device="cuda:0", float_dtype="float16")
 
     # Create full transition with mixed CPU tensors
     observation = {"observation.state": torch.randn(1, 7, dtype=torch.float32)}
@@ -797,7 +796,7 @@ def test_complementary_data_full_pipeline_cuda():
 
 def test_complementary_data_empty():
     """Test empty complementary_data handling."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     transition = create_transition(
         observation={"observation.state": torch.randn(1, 7)},
@@ -812,7 +811,7 @@ def test_complementary_data_empty():
 
 def test_complementary_data_none():
     """Test None complementary_data handling."""
-    processor = DeviceProcessor(device="cpu")
+    processor = DeviceProcessorStep(device="cpu")
 
     transition = create_transition(
         observation={"observation.state": torch.randn(1, 7)},
@@ -827,8 +826,8 @@ def test_complementary_data_none():
 
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
 def test_preserves_gpu_placement():
-    """Test that DeviceProcessor preserves GPU placement when tensor is already on GPU."""
-    processor = DeviceProcessor(device="cuda:0")
+    """Test that DeviceProcessorStep preserves GPU placement when tensor is already on GPU."""
+    processor = DeviceProcessorStep(device="cuda:0")
 
     # Create tensors already on GPU
     observation = {
@@ -853,9 +852,9 @@ def test_preserves_gpu_placement():
 
 @pytest.mark.skipif(torch.cuda.device_count() < 2, reason="Requires at least 2 GPUs")
 def test_multi_gpu_preservation():
-    """Test that DeviceProcessor preserves placement on different GPUs in multi-GPU setup."""
+    """Test that DeviceProcessorStep preserves placement on different GPUs in multi-GPU setup."""
     # Test 1: GPU-to-GPU preservation (cuda:0 config, cuda:1 input)
-    processor_gpu = DeviceProcessor(device="cuda:0")
+    processor_gpu = DeviceProcessorStep(device="cuda:0")
 
     # Create tensors on cuda:1 (simulating Accelerate placement)
     cuda1_device = torch.device("cuda:1")
@@ -874,7 +873,7 @@ def test_multi_gpu_preservation():
     assert result[TransitionKey.ACTION].device == cuda1_device
 
     # Test 2: GPU-to-CPU should move to CPU (not preserve GPU)
-    processor_cpu = DeviceProcessor(device="cpu")
+    processor_cpu = DeviceProcessorStep(device="cpu")
 
     transition_gpu = create_transition(
         observation={"observation.state": torch.randn(10).cuda()}, action=torch.randn(5).cuda()
@@ -890,7 +889,7 @@ def test_multi_gpu_preservation():
 def test_multi_gpu_with_cpu_tensors():
     """Test that CPU tensors are moved to configured device even in multi-GPU context."""
     # Processor configured for cuda:1
-    processor = DeviceProcessor(device="cuda:1")
+    processor = DeviceProcessorStep(device="cuda:1")
 
     # Mix of CPU and GPU tensors
     observation = {
@@ -917,7 +916,7 @@ def test_multi_gpu_with_cpu_tensors():
 @pytest.mark.skipif(torch.cuda.device_count() < 2, reason="Requires at least 2 GPUs")
 def test_multi_gpu_with_float_dtype():
     """Test float dtype conversion works correctly with multi-GPU preservation."""
-    processor = DeviceProcessor(device="cuda:0", float_dtype="float16")
+    processor = DeviceProcessorStep(device="cuda:0", float_dtype="float16")
 
     # Create float tensors on different GPUs
     observation = {
@@ -947,7 +946,7 @@ def test_simulated_accelerate_scenario():
     for gpu_id in range(min(torch.cuda.device_count(), 2)):
         # Each "process" has a processor configured for cuda:0
         # but data comes in already placed on the process's GPU
-        processor = DeviceProcessor(device="cuda:0")
+        processor = DeviceProcessorStep(device="cuda:0")
 
         # Simulate data already placed by Accelerate
         device = torch.device(f"cuda:{gpu_id}")
@@ -967,7 +966,11 @@ def test_policy_processor_integration():
     """Test integration with policy processors - input on GPU, output on CPU."""
     from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
     from lerobot.constants import ACTION, OBS_STATE
-    from lerobot.processor import NormalizerProcessor, ToBatchProcessor, UnnormalizerProcessor
+    from lerobot.processor import (
+        AddBatchDimensionProcessorStep,
+        NormalizerProcessorStep,
+        UnnormalizerProcessorStep,
+    )
 
     # Create features and stats
     features = {
@@ -983,11 +986,11 @@ def test_policy_processor_integration():
     norm_map = {FeatureType.STATE: NormalizationMode.MEAN_STD, FeatureType.ACTION: NormalizationMode.MEAN_STD}
 
     # Create input processor (preprocessor) that moves to GPU
-    input_processor = RobotProcessor(
+    input_processor = DataProcessorPipeline(
         steps=[
-            NormalizerProcessor(features=features, norm_map=norm_map, stats=stats),
-            ToBatchProcessor(),
-            DeviceProcessor(device="cuda"),
+            NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats),
+            AddBatchDimensionProcessorStep(),
+            DeviceProcessorStep(device="cuda"),
         ],
         name="test_preprocessor",
         to_transition=lambda x: x,
@@ -995,10 +998,10 @@ def test_policy_processor_integration():
     )
 
     # Create output processor (postprocessor) that moves to CPU
-    output_processor = RobotProcessor(
+    output_processor = DataProcessorPipeline(
         steps=[
-            DeviceProcessor(device="cpu"),
-            UnnormalizerProcessor(features={ACTION: features[ACTION]}, norm_map=norm_map, stats=stats),
+            DeviceProcessorStep(device="cpu"),
+            UnnormalizerProcessorStep(features={ACTION: features[ACTION]}, norm_map=norm_map, stats=stats),
         ],
         name="test_postprocessor",
         to_transition=lambda x: x,

tests/processor/test_diffusion_processor.py

@@ -25,14 +25,14 @@ from lerobot.constants import ACTION, OBS_IMAGE, OBS_STATE
 from lerobot.policies.diffusion.configuration_diffusion import DiffusionConfig
 from lerobot.policies.diffusion.processor_diffusion import make_diffusion_pre_post_processors
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -89,15 +89,15 @@ def test_make_diffusion_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 4
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
-    assert isinstance(preprocessor.steps[3], DeviceProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
+    assert isinstance(preprocessor.steps[3], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_diffusion_processor_with_images():
@@ -257,7 +257,7 @@ def test_diffusion_processor_save_and_load():
     factory_preprocessor, factory_postprocessor = make_diffusion_pre_post_processors(config, stats)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(
+    preprocessor = DataProcessorPipeline(
         factory_preprocessor.steps, to_transition=lambda x: x, to_output=lambda x: x
     )
 
@@ -266,7 +266,7 @@ def test_diffusion_processor_save_and_load():
         preprocessor.save_pretrained(tmpdir)
 
         # Load preprocessor
-        loaded_preprocessor = RobotProcessor.from_pretrained(
+        loaded_preprocessor = DataProcessorPipeline.from_pretrained(
             tmpdir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -294,16 +294,16 @@ def test_diffusion_processor_mixed_precision():
     # Get the steps from the factory function
     factory_preprocessor, factory_postprocessor = make_diffusion_pre_post_processors(config, stats)
 
-    # Replace DeviceProcessor with one that uses float16
+    # Replace DeviceProcessorStep with one that uses float16
     modified_steps = []
     for step in factory_preprocessor.steps:
-        if isinstance(step, DeviceProcessor):
-            modified_steps.append(DeviceProcessor(device=config.device, float_dtype="float16"))
+        if isinstance(step, DeviceProcessorStep):
+            modified_steps.append(DeviceProcessorStep(device=config.device, float_dtype="float16"))
         else:
             modified_steps.append(step)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(modified_steps, to_transition=lambda x: x, to_output=lambda x: x)
+    preprocessor = DataProcessorPipeline(modified_steps, to_transition=lambda x: x, to_output=lambda x: x)
 
     # Create test data
     observation = {

tests/processor/test_normalize_processor.py

@@ -20,13 +20,15 @@ import pytest
 import torch
 
 from lerobot.configs.types import FeatureType, NormalizationMode, PolicyFeature
-from lerobot.processor.converters import to_tensor
-from lerobot.processor.normalize_processor import (
-    NormalizerProcessor,
-    UnnormalizerProcessor,
+from lerobot.processor import (
+    DataProcessorPipeline,
+    IdentityProcessorStep,
+    NormalizerProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
     hotswap_stats,
 )
-from lerobot.processor.pipeline import IdentityProcessor, RobotProcessor, TransitionKey
+from lerobot.processor.converters import to_tensor
 
 
 def create_transition(
@@ -123,7 +125,7 @@ def _create_observation_norm_map():
     }
 
 
-# Fixtures for observation normalisation tests using NormalizerProcessor
+# Fixtures for observation normalisation tests using NormalizerProcessorStep
 @pytest.fixture
 def observation_stats():
     return {
@@ -140,10 +142,10 @@ def observation_stats():
 
 @pytest.fixture
 def observation_normalizer(observation_stats):
-    """Return a NormalizerProcessor that only has observation stats (no action)."""
+    """Return a NormalizerProcessorStep that only has observation stats (no action)."""
     features = _create_observation_features()
     norm_map = _create_observation_norm_map()
-    return NormalizerProcessor(features=features, norm_map=norm_map, stats=observation_stats)
+    return NormalizerProcessorStep(features=features, norm_map=norm_map, stats=observation_stats)
 
 
 def test_mean_std_normalization(observation_normalizer):
@@ -180,7 +182,7 @@ def test_min_max_normalization(observation_normalizer):
 def test_selective_normalization(observation_stats):
     features = _create_observation_features()
     norm_map = _create_observation_norm_map()
-    normalizer = NormalizerProcessor(
+    normalizer = NormalizerProcessorStep(
         features=features,
         norm_map=norm_map,
         stats=observation_stats,
@@ -206,7 +208,7 @@ def test_selective_normalization(observation_stats):
 def test_device_compatibility(observation_stats):
     features = _create_observation_features()
     norm_map = _create_observation_norm_map()
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=observation_stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=observation_stats)
     observation = {
         "observation.image": torch.tensor([0.7, 0.5, 0.3]).cuda(),
     }
@@ -235,7 +237,7 @@ def test_from_lerobot_dataset():
         FeatureType.ACTION: NormalizationMode.MEAN_STD,
     }
 
-    normalizer = NormalizerProcessor.from_lerobot_dataset(mock_dataset, features, norm_map)
+    normalizer = NormalizerProcessorStep.from_lerobot_dataset(mock_dataset, features, norm_map)
 
     # Both observation and action statistics should be present in tensor stats
     assert "observation.image" in normalizer._tensor_stats
@@ -250,7 +252,7 @@ def test_state_dict_save_load(observation_normalizer):
     # Create new normalizer and load state
     features = _create_observation_features()
     norm_map = _create_observation_norm_map()
-    new_normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats={})
+    new_normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats={})
     new_normalizer.load_state_dict(state_dict)
 
     # Test that it works the same
@@ -301,7 +303,7 @@ def _create_action_norm_map_min_max():
 def test_mean_std_unnormalization(action_stats_mean_std):
     features = _create_action_features()
     norm_map = _create_action_norm_map_mean_std()
-    unnormalizer = UnnormalizerProcessor(
+    unnormalizer = UnnormalizerProcessorStep(
         features=features, norm_map=norm_map, stats={"action": action_stats_mean_std}
     )
 
@@ -319,7 +321,7 @@ def test_mean_std_unnormalization(action_stats_mean_std):
 def test_min_max_unnormalization(action_stats_min_max):
     features = _create_action_features()
     norm_map = _create_action_norm_map_min_max()
-    unnormalizer = UnnormalizerProcessor(
+    unnormalizer = UnnormalizerProcessorStep(
         features=features, norm_map=norm_map, stats={"action": action_stats_min_max}
     )
 
@@ -345,7 +347,7 @@ def test_min_max_unnormalization(action_stats_min_max):
 def test_numpy_action_input(action_stats_mean_std):
     features = _create_action_features()
     norm_map = _create_action_norm_map_mean_std()
-    unnormalizer = UnnormalizerProcessor(
+    unnormalizer = UnnormalizerProcessorStep(
         features=features, norm_map=norm_map, stats={"action": action_stats_mean_std}
     )
 
@@ -363,7 +365,7 @@ def test_numpy_action_input(action_stats_mean_std):
 def test_none_action(action_stats_mean_std):
     features = _create_action_features()
     norm_map = _create_action_norm_map_mean_std()
-    unnormalizer = UnnormalizerProcessor(
+    unnormalizer = UnnormalizerProcessorStep(
         features=features, norm_map=norm_map, stats={"action": action_stats_mean_std}
     )
 
@@ -379,11 +381,11 @@ def test_action_from_lerobot_dataset():
     mock_dataset.meta.stats = {"action": {"mean": [0.0], "std": [1.0]}}
     features = {"action": PolicyFeature(FeatureType.ACTION, (1,))}
     norm_map = {FeatureType.ACTION: NormalizationMode.MEAN_STD}
-    unnormalizer = UnnormalizerProcessor.from_lerobot_dataset(mock_dataset, features, norm_map)
+    unnormalizer = UnnormalizerProcessorStep.from_lerobot_dataset(mock_dataset, features, norm_map)
     assert "mean" in unnormalizer._tensor_stats["action"]
 
 
-# Fixtures for NormalizerProcessor tests
+# Fixtures for NormalizerProcessorStep tests
 @pytest.fixture
 def full_stats():
     return {
@@ -422,7 +424,7 @@ def _create_full_norm_map():
 def normalizer_processor(full_stats):
     features = _create_full_features()
     norm_map = _create_full_norm_map()
-    return NormalizerProcessor(features=features, norm_map=norm_map, stats=full_stats)
+    return NormalizerProcessorStep(features=features, norm_map=norm_map, stats=full_stats)
 
 
 def test_combined_normalization(normalizer_processor):
@@ -466,7 +468,7 @@ def test_processor_from_lerobot_dataset(full_stats):
     features = _create_full_features()
     norm_map = _create_full_norm_map()
 
-    processor = NormalizerProcessor.from_lerobot_dataset(
+    processor = NormalizerProcessorStep.from_lerobot_dataset(
         mock_dataset, features, norm_map, normalize_observation_keys={"observation.image"}
     )
 
@@ -478,7 +480,7 @@ def test_processor_from_lerobot_dataset(full_stats):
 def test_get_config(full_stats):
     features = _create_full_features()
     norm_map = _create_full_norm_map()
-    processor = NormalizerProcessor(
+    processor = NormalizerProcessorStep(
         features=features,
         norm_map=norm_map,
         stats=full_stats,
@@ -506,7 +508,9 @@ def test_get_config(full_stats):
 
 def test_integration_with_robot_processor(normalizer_processor):
     """Test integration with RobotProcessor pipeline"""
-    robot_processor = RobotProcessor([normalizer_processor], to_transition=lambda x: x, to_output=lambda x: x)
+    robot_processor = DataProcessorPipeline(
+        [normalizer_processor], to_transition=lambda x: x, to_output=lambda x: x
+    )
 
     observation = {
         "observation.image": torch.tensor([0.7, 0.5, 0.3]),
@@ -535,7 +539,7 @@ def test_empty_observation():
     stats = {"observation.image": {"mean": [0.5], "std": [0.2]}}
     features = {"observation.image": PolicyFeature(FeatureType.VISUAL, (3, 96, 96))}
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     transition = create_transition()
     result = normalizer(transition)
@@ -546,7 +550,7 @@ def test_empty_observation():
 def test_empty_stats():
     features = {"observation.image": PolicyFeature(FeatureType.VISUAL, (3, 96, 96))}
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats={})
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats={})
     observation = {"observation.image": torch.tensor([0.5])}
     transition = create_transition(observation=observation)
 
@@ -562,7 +566,7 @@ def test_partial_stats():
     stats = {"observation.image": {"mean": [0.5]}}  # Missing std / (min,max)
     features = {"observation.image": PolicyFeature(FeatureType.VISUAL, (3, 96, 96))}
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
     observation = {"observation.image": torch.tensor([0.7])}
     transition = create_transition(observation=observation)
 
@@ -577,7 +581,7 @@ def test_missing_action_stats_no_error():
     features = {"observation.image": PolicyFeature(FeatureType.VISUAL, (3, 96, 96))}
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
 
-    processor = UnnormalizerProcessor.from_lerobot_dataset(mock_dataset, features, norm_map)
+    processor = UnnormalizerProcessorStep.from_lerobot_dataset(mock_dataset, features, norm_map)
     # The tensor stats should not contain the 'action' key
     assert "action" not in processor._tensor_stats
 
@@ -586,7 +590,7 @@ def test_serialization_roundtrip(full_stats):
     """Test that features and norm_map can be serialized and deserialized correctly."""
     features = _create_full_features()
     norm_map = _create_full_norm_map()
-    original_processor = NormalizerProcessor(
+    original_processor = NormalizerProcessorStep(
         features=features,
         norm_map=norm_map,
         stats=full_stats,
@@ -598,7 +602,7 @@ def test_serialization_roundtrip(full_stats):
     config = original_processor.get_config()
 
     # Create a new processor from the config (deserialization)
-    new_processor = NormalizerProcessor(
+    new_processor = NormalizerProcessorStep(
         features=config["features"],
         norm_map=config["norm_map"],
         stats=full_stats,
@@ -666,7 +670,7 @@ def test_identity_normalization_observations():
         "observation.state": {"mean": [0.0, 0.0], "std": [1.0, 1.0]},
     }
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     observation = {
         "observation.image": torch.tensor([0.7, 0.5, 0.3]),
@@ -691,7 +695,7 @@ def test_identity_normalization_actions():
     norm_map = {FeatureType.ACTION: NormalizationMode.IDENTITY}
     stats = {"action": {"mean": [0.0, 0.0], "std": [1.0, 2.0]}}
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     action = torch.tensor([1.0, -0.5])
     transition = create_transition(action=action)
@@ -717,7 +721,7 @@ def test_identity_unnormalization_observations():
         "observation.state": {"min": [-1.0, -1.0], "max": [1.0, 1.0]},
     }
 
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     observation = {
         "observation.image": torch.tensor([0.7, 0.5, 0.3]),
@@ -744,7 +748,7 @@ def test_identity_unnormalization_actions():
     norm_map = {FeatureType.ACTION: NormalizationMode.IDENTITY}
     stats = {"action": {"min": [-1.0, -2.0], "max": [1.0, 2.0]}}
 
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     action = torch.tensor([0.5, -0.8])  # Normalized values
     transition = create_transition(action=action)
@@ -767,8 +771,8 @@ def test_identity_with_missing_stats():
     }
     stats = {}  # No stats provided
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     observation = {"observation.image": torch.tensor([0.7, 0.5, 0.3])}
     action = torch.tensor([1.0, -0.5])
@@ -808,7 +812,7 @@ def test_identity_mixed_with_other_modes():
         "action": {"min": [-1.0, -1.0], "max": [1.0, 1.0]},
     }
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     observation = {
         "observation.image": torch.tensor([0.7, 0.5, 0.3]),
@@ -850,7 +854,7 @@ def test_identity_defaults_when_not_in_norm_map():
         "observation.state": {"mean": [0.0, 0.0], "std": [1.0, 1.0]},
     }
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     observation = {
         "observation.image": torch.tensor([0.7, 0.5, 0.3]),
@@ -884,8 +888,8 @@ def test_identity_roundtrip():
         "action": {"min": [-1.0, -1.0], "max": [1.0, 1.0]},
     }
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     original_observation = {"observation.image": torch.tensor([0.7, 0.5, 0.3])}
     original_action = torch.tensor([0.5, -0.2])
@@ -917,7 +921,7 @@ def test_identity_config_serialization():
         "action": {"mean": [0.0, 0.0], "std": [1.0, 1.0]},
     }
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     # Get config
     config = normalizer.get_config()
@@ -927,7 +931,7 @@ def test_identity_config_serialization():
     assert config["norm_map"]["ACTION"] == "MEAN_STD"
 
     # Create new processor from config (simulating load)
-    new_normalizer = NormalizerProcessor(
+    new_normalizer = NormalizerProcessorStep(
         features=config["features"],
         norm_map=config["norm_map"],
         stats=stats,
@@ -965,7 +969,7 @@ def test_identity_config_serialization():
 #     norm_map = {FeatureType.STATE: NormalizationMode.MEAN_STD}
 #     stats = {"observation.state": {"mean": [0.0, 0.0], "std": [1.0, 1.0]}}
 
-#     normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+#     normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
 #     # Manually inject an invalid mode to test error handling
 #     normalizer.norm_map[FeatureType.STATE] = "INVALID_MODE"
@@ -1002,12 +1006,12 @@ def test_hotswap_stats_basic_functionality():
     }
 
     # Create processors
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    identity = IdentityProcessor()
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    identity = IdentityProcessorStep()
 
     # Create robot processor
-    robot_processor = RobotProcessor(steps=[normalizer, unnormalizer, identity])
+    robot_processor = DataProcessorPipeline(steps=[normalizer, unnormalizer, identity])
 
     # Hotswap stats
     new_processor = hotswap_stats(robot_processor, new_stats)
@@ -1043,8 +1047,8 @@ def test_hotswap_stats_deep_copy():
     }
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    original_processor = RobotProcessor(steps=[normalizer])
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    original_processor = DataProcessorPipeline(steps=[normalizer])
 
     # Store reference to original stats
     original_stats_reference = original_processor.steps[0].stats
@@ -1068,7 +1072,7 @@ def test_hotswap_stats_deep_copy():
 
 
 def test_hotswap_stats_only_affects_normalizer_steps():
-    """Test that hotswap_stats only modifies NormalizerProcessor and UnnormalizerProcessor steps."""
+    """Test that hotswap_stats only modifies NormalizerProcessorStep and UnnormalizerProcessorStep steps."""
     stats = {
         "observation.image": {"mean": np.array([0.5]), "std": np.array([0.2])},
     }
@@ -1083,11 +1087,11 @@ def test_hotswap_stats_only_affects_normalizer_steps():
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
 
     # Create mixed steps
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
-    identity = IdentityProcessor()
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
+    identity = IdentityProcessorStep()
 
-    robot_processor = RobotProcessor(steps=[normalizer, identity, unnormalizer])
+    robot_processor = DataProcessorPipeline(steps=[normalizer, identity, unnormalizer])
 
     # Hotswap stats
     new_processor = hotswap_stats(robot_processor, new_stats)
@@ -1113,8 +1117,8 @@ def test_hotswap_stats_empty_stats():
     }
     norm_map = {FeatureType.VISUAL: NormalizationMode.MEAN_STD}
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    robot_processor = RobotProcessor(steps=[normalizer])
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    robot_processor = DataProcessorPipeline(steps=[normalizer])
 
     # Hotswap with empty stats
     new_processor = hotswap_stats(robot_processor, empty_stats)
@@ -1131,7 +1135,7 @@ def test_hotswap_stats_no_normalizer_steps():
     }
 
     # Create processor with only identity steps
-    robot_processor = RobotProcessor(steps=[IdentityProcessor(), IdentityProcessor()])
+    robot_processor = DataProcessorPipeline(steps=[IdentityProcessorStep(), IdentityProcessorStep()])
 
     # Hotswap stats - should work without error
     new_processor = hotswap_stats(robot_processor, stats)
@@ -1163,14 +1167,14 @@ def test_hotswap_stats_preserves_other_attributes():
     normalize_observation_keys = {"observation.image"}
     eps = 1e-6
 
-    normalizer = NormalizerProcessor(
+    normalizer = NormalizerProcessorStep(
         features=features,
         norm_map=norm_map,
         stats=initial_stats,
         normalize_observation_keys=normalize_observation_keys,
         eps=eps,
     )
-    robot_processor = RobotProcessor(steps=[normalizer])
+    robot_processor = DataProcessorPipeline(steps=[normalizer])
 
     # Hotswap stats
     new_processor = hotswap_stats(robot_processor, new_stats)
@@ -1208,12 +1212,12 @@ def test_hotswap_stats_multiple_normalizer_types():
     }
 
     # Create multiple normalizers and unnormalizers
-    normalizer1 = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    normalizer2 = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    unnormalizer1 = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    unnormalizer2 = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
+    normalizer1 = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    normalizer2 = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    unnormalizer1 = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    unnormalizer2 = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
 
-    robot_processor = RobotProcessor(steps=[normalizer1, unnormalizer1, normalizer2, unnormalizer2])
+    robot_processor = DataProcessorPipeline(steps=[normalizer1, unnormalizer1, normalizer2, unnormalizer2])
 
     # Hotswap stats
     new_processor = hotswap_stats(robot_processor, new_stats)
@@ -1260,8 +1264,8 @@ def test_hotswap_stats_with_different_data_types():
         FeatureType.ACTION: NormalizationMode.MEAN_STD,
     }
 
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    robot_processor = RobotProcessor(steps=[normalizer])
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    robot_processor = DataProcessorPipeline(steps=[normalizer])
 
     # Hotswap stats
     new_processor = hotswap_stats(robot_processor, new_stats)
@@ -1316,8 +1320,10 @@ def test_hotswap_stats_functional_test():
     }
 
     # Create original processor
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=initial_stats)
-    original_processor = RobotProcessor(steps=[normalizer], to_transition=lambda x: x, to_output=lambda x: x)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=initial_stats)
+    original_processor = DataProcessorPipeline(
+        steps=[normalizer], to_transition=lambda x: x, to_output=lambda x: x
+    )
 
     # Process with original stats
     original_result = original_processor(transition)
@@ -1360,7 +1366,7 @@ def test_zero_std_uses_eps():
     features = {"observation.state": PolicyFeature(FeatureType.STATE, (1,))}
     norm_map = {FeatureType.STATE: NormalizationMode.MEAN_STD}
     stats = {"observation.state": {"mean": np.array([0.5]), "std": np.array([0.0])}}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats, eps=1e-6)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats, eps=1e-6)
 
     observation = {"observation.state": torch.tensor([0.5])}  # equals mean
     out = normalizer(create_transition(observation=observation))
@@ -1372,7 +1378,7 @@ def test_min_equals_max_maps_to_minus_one():
     features = {"observation.state": PolicyFeature(FeatureType.STATE, (1,))}
     norm_map = {FeatureType.STATE: NormalizationMode.MIN_MAX}
     stats = {"observation.state": {"min": np.array([2.0]), "max": np.array([2.0])}}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats, eps=1e-6)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats, eps=1e-6)
 
     observation = {"observation.state": torch.tensor([2.0])}
     out = normalizer(create_transition(observation=observation))
@@ -1387,7 +1393,7 @@ def test_action_normalized_despite_normalize_observation_keys():
     }
     norm_map = {FeatureType.STATE: NormalizationMode.IDENTITY, FeatureType.ACTION: NormalizationMode.MEAN_STD}
     stats = {"action": {"mean": np.array([1.0, -1.0]), "std": np.array([2.0, 4.0])}}
-    normalizer = NormalizerProcessor(
+    normalizer = NormalizerProcessorStep(
         features=features, norm_map=norm_map, stats=stats, normalize_observation_keys={"observation.state"}
     )
 
@@ -1405,12 +1411,12 @@ def test_unnormalize_observations_mean_std_and_min_max():
         "observation.mm": PolicyFeature(FeatureType.STATE, (2,)),
     }
     # Build two processors: one mean/std and one min/max
-    unnorm_ms = UnnormalizerProcessor(
+    unnorm_ms = UnnormalizerProcessorStep(
         features={"observation.ms": features["observation.ms"]},
         norm_map={FeatureType.STATE: NormalizationMode.MEAN_STD},
         stats={"observation.ms": {"mean": np.array([1.0, -1.0]), "std": np.array([2.0, 4.0])}},
     )
-    unnorm_mm = UnnormalizerProcessor(
+    unnorm_mm = UnnormalizerProcessorStep(
         features={"observation.mm": features["observation.mm"]},
         norm_map={FeatureType.STATE: NormalizationMode.MIN_MAX},
         stats={"observation.mm": {"min": np.array([0.0, -2.0]), "max": np.array([2.0, 2.0])}},
@@ -1432,7 +1438,7 @@ def test_unknown_observation_keys_ignored():
     features = {"observation.state": PolicyFeature(FeatureType.STATE, (1,))}
     norm_map = {FeatureType.STATE: NormalizationMode.MEAN_STD}
     stats = {"observation.state": {"mean": np.array([0.0]), "std": np.array([1.0])}}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     obs = {"observation.state": torch.tensor([1.0]), "observation.unknown": torch.tensor([5.0])}
     tr = create_transition(observation=obs)
@@ -1446,7 +1452,7 @@ def test_batched_action_normalization():
     features = {"action": PolicyFeature(FeatureType.ACTION, (2,))}
     norm_map = {FeatureType.ACTION: NormalizationMode.MEAN_STD}
     stats = {"action": {"mean": np.array([1.0, -1.0]), "std": np.array([2.0, 4.0])}}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     actions = torch.tensor([[1.0, -1.0], [3.0, 3.0]])  # first equals mean → zeros; second → [1, 1]
     out = normalizer(create_transition(action=actions))[TransitionKey.ACTION]
@@ -1458,7 +1464,7 @@ def test_complementary_data_preservation():
     features = {"observation.state": PolicyFeature(FeatureType.STATE, (1,))}
     norm_map = {FeatureType.STATE: NormalizationMode.MEAN_STD}
     stats = {"observation.state": {"mean": np.array([0.0]), "std": np.array([1.0])}}
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     comp = {"existing": 123}
     tr = create_transition(observation={"observation.state": torch.tensor([1.0])}, complementary_data=comp)
@@ -1477,8 +1483,8 @@ def test_roundtrip_normalize_unnormalize_non_identity():
         "observation.state": {"mean": np.array([1.0, -1.0]), "std": np.array([2.0, 4.0])},
         "action": {"min": np.array([-2.0, 0.0]), "max": np.array([2.0, 4.0])},
     }
-    normalizer = NormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
-    unnormalizer = UnnormalizerProcessor(features=features, norm_map=norm_map, stats=stats)
+    normalizer = NormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
+    unnormalizer = UnnormalizerProcessorStep(features=features, norm_map=norm_map, stats=stats)
 
     # Add a time dimension in action for broadcasting check (B,T,D)
     obs = {"observation.state": torch.tensor([[3.0, 3.0], [1.0, -1.0]])}

tests/processor/test_observation_processor.py

@@ -20,8 +20,7 @@ import torch
 
 from lerobot.configs.types import FeatureType
 from lerobot.constants import OBS_ENV_STATE, OBS_IMAGE, OBS_IMAGES, OBS_STATE
-from lerobot.processor import VanillaObservationProcessor
-from lerobot.processor.pipeline import TransitionKey
+from lerobot.processor import TransitionKey, VanillaObservationProcessorStep
 from tests.conftest import assert_contract_is_typed
 
 
@@ -42,7 +41,7 @@ def create_transition(
 
 def test_process_single_image():
     """Test processing a single image."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Create a mock image (H, W, C) format, uint8
     image = np.random.randint(0, 256, size=(64, 64, 3), dtype=np.uint8)
@@ -68,7 +67,7 @@ def test_process_single_image():
 
 def test_process_image_dict():
     """Test processing multiple images in a dictionary."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Create mock images
     image1 = np.random.randint(0, 256, size=(32, 32, 3), dtype=np.uint8)
@@ -91,7 +90,7 @@ def test_process_image_dict():
 
 def test_process_batched_image():
     """Test processing already batched images."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Create a batched image (B, H, W, C)
     image = np.random.randint(0, 256, size=(2, 64, 64, 3), dtype=np.uint8)
@@ -108,7 +107,7 @@ def test_process_batched_image():
 
 def test_invalid_image_format():
     """Test error handling for invalid image formats."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Test wrong channel order (channels first)
     image = np.random.randint(0, 256, size=(3, 64, 64), dtype=np.uint8)
@@ -121,7 +120,7 @@ def test_invalid_image_format():
 
 def test_invalid_image_dtype():
     """Test error handling for invalid image dtype."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Test wrong dtype
     image = np.random.rand(64, 64, 3).astype(np.float32)
@@ -134,7 +133,7 @@ def test_invalid_image_dtype():
 
 def test_no_pixels_in_observation():
     """Test processor when no pixels are in observation."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     observation = {"other_data": np.array([1, 2, 3])}
     transition = create_transition(observation=observation)
@@ -149,7 +148,7 @@ def test_no_pixels_in_observation():
 
 def test_none_observation():
     """Test processor with None observation."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     transition = create_transition()
     result = processor(transition)
@@ -159,7 +158,7 @@ def test_none_observation():
 
 def test_serialization_methods():
     """Test serialization methods."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Test get_config
     config = processor.get_config()
@@ -178,7 +177,7 @@ def test_serialization_methods():
 
 def test_process_environment_state():
     """Test processing environment_state."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     env_state = np.array([1.0, 2.0, 3.0], dtype=np.float32)
     observation = {"environment_state": env_state}
@@ -199,7 +198,7 @@ def test_process_environment_state():
 
 def test_process_agent_pos():
     """Test processing agent_pos."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     agent_pos = np.array([0.5, -0.5, 1.0], dtype=np.float32)
     observation = {"agent_pos": agent_pos}
@@ -220,7 +219,7 @@ def test_process_agent_pos():
 
 def test_process_batched_states():
     """Test processing already batched states."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     env_state = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
     agent_pos = np.array([[0.5, -0.5], [1.0, -1.0]], dtype=np.float32)
@@ -238,7 +237,7 @@ def test_process_batched_states():
 
 def test_process_both_states():
     """Test processing both environment_state and agent_pos."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     env_state = np.array([1.0, 2.0], dtype=np.float32)
     agent_pos = np.array([0.5, -0.5], dtype=np.float32)
@@ -263,7 +262,7 @@ def test_process_both_states():
 
 def test_no_states_in_observation():
     """Test processor when no states are in observation."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     observation = {"other_data": np.array([1, 2, 3])}
     transition = create_transition(observation=observation)
@@ -277,7 +276,7 @@ def test_no_states_in_observation():
 
 def test_complete_observation_processing():
     """Test processing a complete observation with both images and states."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Create mock data
     image = np.random.randint(0, 256, size=(32, 32, 3), dtype=np.uint8)
@@ -314,7 +313,7 @@ def test_complete_observation_processing():
 
 def test_image_only_processing():
     """Test processing observation with only images."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     image = np.random.randint(0, 256, size=(64, 64, 3), dtype=np.uint8)
     observation = {"pixels": image}
@@ -329,7 +328,7 @@ def test_image_only_processing():
 
 def test_state_only_processing():
     """Test processing observation with only states."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     agent_pos = np.array([1.0, 2.0], dtype=np.float32)
     observation = {"agent_pos": agent_pos}
@@ -344,7 +343,7 @@ def test_state_only_processing():
 
 def test_empty_observation():
     """Test processing empty observation."""
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     observation = {}
     transition = create_transition(observation=observation)
@@ -360,7 +359,7 @@ def test_equivalent_to_original_function():
     # Import the original function for comparison
     from lerobot.envs.utils import preprocess_observation
 
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Create test data similar to what the original function expects
     image = np.random.randint(0, 256, size=(64, 64, 3), dtype=np.uint8)
@@ -387,7 +386,7 @@ def test_equivalent_with_image_dict():
     """Test equivalence with dictionary of images."""
     from lerobot.envs.utils import preprocess_observation
 
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
 
     # Create test data with multiple cameras
     image1 = np.random.randint(0, 256, size=(32, 32, 3), dtype=np.uint8)
@@ -411,7 +410,7 @@ def test_equivalent_with_image_dict():
 
 
 def test_image_processor_features_pixels_to_image(policy_feature_factory):
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
     features = {
         "pixels": policy_feature_factory(FeatureType.VISUAL, (3, 64, 64)),
         "keep": policy_feature_factory(FeatureType.ENV, (1,)),
@@ -425,7 +424,7 @@ def test_image_processor_features_pixels_to_image(policy_feature_factory):
 
 
 def test_image_processor_features_observation_pixels_to_image(policy_feature_factory):
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
     features = {
         "observation.pixels": policy_feature_factory(FeatureType.VISUAL, (3, 64, 64)),
         "keep": policy_feature_factory(FeatureType.ENV, (1,)),
@@ -439,7 +438,7 @@ def test_image_processor_features_observation_pixels_to_image(policy_feature_fac
 
 
 def test_image_processor_features_multi_camera_and_prefixed(policy_feature_factory):
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
     features = {
         "pixels.front": policy_feature_factory(FeatureType.VISUAL, (3, 64, 64)),
         "pixels.wrist": policy_feature_factory(FeatureType.VISUAL, (3, 64, 64)),
@@ -457,7 +456,7 @@ def test_image_processor_features_multi_camera_and_prefixed(policy_feature_facto
 
 
 def test_state_processor_features_environment_and_agent_pos(policy_feature_factory):
-    processor = VanillaObservationProcessor()
+    processor = VanillaObservationProcessorStep()
     features = {
         "environment_state": policy_feature_factory(FeatureType.STATE, (3,)),
         "agent_pos": policy_feature_factory(FeatureType.STATE, (7,)),
@@ -473,7 +472,7 @@ def test_state_processor_features_environment_and_agent_pos(policy_feature_facto
 
 
 def test_state_processor_features_prefixed_inputs(policy_feature_factory):
-    proc = VanillaObservationProcessor()
+    proc = VanillaObservationProcessorStep()
     features = {
         "observation.environment_state": policy_feature_factory(FeatureType.STATE, (2,)),
         "observation.agent_pos": policy_feature_factory(FeatureType.STATE, (4,)),

tests/processor/test_pi0_processor.py

@@ -25,13 +25,31 @@ from lerobot.constants import ACTION, OBS_IMAGE, OBS_STATE
 from lerobot.policies.pi0.configuration_pi0 import PI0Config
 from lerobot.policies.pi0.processor_pi0 import Pi0NewLineProcessor, make_pi0_pre_post_processors
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    EnvTransition,
+    NormalizerProcessorStep,
+    ProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
+
+
+class MockTokenizerProcessorStep(ProcessorStep):
+    """Mock tokenizer processor step for testing."""
+
+    def __init__(self, *args, **kwargs):
+        # Accept any arguments to mimic the real TokenizerProcessorStep interface
+        pass
+
+    def __call__(self, transition: EnvTransition) -> EnvTransition:
+        # Pass through transition unchanged
+        return transition
+
+    def transform_features(self, features):
+        # Pass through features unchanged
+        return features
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -83,7 +101,7 @@ def test_make_pi0_processor_basic():
     config = create_default_config()
     stats = create_default_stats()
 
-    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessor"):
+    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessorStep", MockTokenizerProcessorStep):
         preprocessor, postprocessor = make_pi0_pre_post_processors(
             config,
             stats,
@@ -97,17 +115,17 @@ def test_make_pi0_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 6
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
     assert isinstance(preprocessor.steps[3], Pi0NewLineProcessor)
-    # Step 4 would be TokenizerProcessor but it's mocked
-    assert isinstance(preprocessor.steps[5], DeviceProcessor)
+    # Step 4 would be TokenizerProcessorStep but it's mocked
+    assert isinstance(preprocessor.steps[5], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_pi0_newline_processor_single_task():
@@ -165,7 +183,7 @@ def test_pi0_processor_cuda():
     stats = create_default_stats()
 
     # Mock the tokenizer processor to act as pass-through
-    class MockTokenizerProcessor:
+    class MockTokenizerProcessorStep(ProcessorStep):
         def __init__(self, *args, **kwargs):
             pass
 
@@ -187,7 +205,7 @@ def test_pi0_processor_cuda():
         def transform_features(self, features):
             return features
 
-    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessor", MockTokenizerProcessor):
+    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessorStep", MockTokenizerProcessorStep):
         preprocessor, postprocessor = make_pi0_pre_post_processors(
             config,
             stats,
@@ -220,7 +238,7 @@ def test_pi0_processor_accelerate_scenario():
     stats = create_default_stats()
 
     # Mock the tokenizer processor to act as pass-through
-    class MockTokenizerProcessor:
+    class MockTokenizerProcessorStep(ProcessorStep):
         def __init__(self, *args, **kwargs):
             pass
 
@@ -242,7 +260,7 @@ def test_pi0_processor_accelerate_scenario():
         def transform_features(self, features):
             return features
 
-    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessor", MockTokenizerProcessor):
+    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessorStep", MockTokenizerProcessorStep):
         preprocessor, postprocessor = make_pi0_pre_post_processors(
             config,
             stats,
@@ -276,7 +294,7 @@ def test_pi0_processor_multi_gpu():
     stats = create_default_stats()
 
     # Mock the tokenizer processor to act as pass-through
-    class MockTokenizerProcessor:
+    class MockTokenizerProcessorStep(ProcessorStep):
         def __init__(self, *args, **kwargs):
             pass
 
@@ -298,7 +316,7 @@ def test_pi0_processor_multi_gpu():
         def transform_features(self, features):
             return features
 
-    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessor", MockTokenizerProcessor):
+    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessorStep", MockTokenizerProcessorStep):
         preprocessor, postprocessor = make_pi0_pre_post_processors(
             config,
             stats,
@@ -329,7 +347,7 @@ def test_pi0_processor_without_stats():
     config = create_default_config()
 
     # Mock the tokenizer processor
-    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessor"):
+    with patch("lerobot.policies.pi0.processor_pi0.TokenizerProcessorStep", MockTokenizerProcessorStep):
         preprocessor, postprocessor = make_pi0_pre_post_processors(
             config,
             dataset_stats=None,

tests/processor/test_rename_processor.py

@@ -20,7 +20,12 @@ import numpy as np
 import torch
 
 from lerobot.configs.types import FeatureType
-from lerobot.processor import ProcessorStepRegistry, RenameProcessor, RobotProcessor, TransitionKey
+from lerobot.processor import (
+    DataProcessorPipeline,
+    ProcessorStepRegistry,
+    RenameProcessorStep,
+    TransitionKey,
+)
 from lerobot.processor.rename_processor import rename_stats
 from tests.conftest import assert_contract_is_typed
 
@@ -46,7 +51,7 @@ def test_basic_renaming():
         "old_key1": "new_key1",
         "old_key2": "new_key2",
     }
-    processor = RenameProcessor(rename_map=rename_map)
+    processor = RenameProcessorStep(rename_map=rename_map)
 
     observation = {
         "old_key1": torch.tensor([1.0, 2.0]),
@@ -74,7 +79,7 @@ def test_basic_renaming():
 
 def test_empty_rename_map():
     """Test processor with empty rename map (should pass through unchanged)."""
-    processor = RenameProcessor(rename_map={})
+    processor = RenameProcessorStep(rename_map={})
 
     observation = {
         "key1": torch.tensor([1.0]),
@@ -93,7 +98,7 @@ def test_empty_rename_map():
 
 def test_none_observation():
     """Test processor with None observation."""
-    processor = RenameProcessor(rename_map={"old": "new"})
+    processor = RenameProcessorStep(rename_map={"old": "new"})
 
     transition = create_transition()
     result = processor(transition)
@@ -108,7 +113,7 @@ def test_overlapping_rename():
         "a": "b",
         "b": "c",  # This creates a potential conflict
     }
-    processor = RenameProcessor(rename_map=rename_map)
+    processor = RenameProcessorStep(rename_map=rename_map)
 
     observation = {
         "a": 1,
@@ -133,7 +138,7 @@ def test_partial_rename():
         "observation.state": "observation.proprio_state",
         "pixels": "observation.image",
     }
-    processor = RenameProcessor(rename_map=rename_map)
+    processor = RenameProcessorStep(rename_map=rename_map)
 
     observation = {
         "observation.state": torch.randn(10),
@@ -163,15 +168,15 @@ def test_get_config():
         "old1": "new1",
         "old2": "new2",
     }
-    processor = RenameProcessor(rename_map=rename_map)
+    processor = RenameProcessorStep(rename_map=rename_map)
 
     config = processor.get_config()
     assert config == {"rename_map": rename_map}
 
 
 def test_state_dict():
-    """Test state dict (should be empty for RenameProcessor)."""
-    processor = RenameProcessor(rename_map={"old": "new"})
+    """Test state dict (should be empty for RenameProcessorStep)."""
+    processor = RenameProcessorStep(rename_map={"old": "new"})
 
     state = processor.state_dict()
     assert state == {}
@@ -186,9 +191,9 @@ def test_integration_with_robot_processor():
         "agent_pos": "observation.state",
         "pixels": "observation.image",
     }
-    rename_processor = RenameProcessor(rename_map=rename_map)
+    rename_processor = RenameProcessorStep(rename_map=rename_map)
 
-    pipeline = RobotProcessor([rename_processor], to_transition=lambda x: x, to_output=lambda x: x)
+    pipeline = DataProcessorPipeline([rename_processor], to_transition=lambda x: x, to_output=lambda x: x)
 
     observation = {
         "agent_pos": np.array([1.0, 2.0, 3.0]),
@@ -220,32 +225,34 @@ def test_save_and_load_pretrained():
         "old_state": "observation.state",
         "old_image": "observation.image",
     }
-    processor = RenameProcessor(rename_map=rename_map)
-    pipeline = RobotProcessor([processor], name="TestRenameProcessor")
+    processor = RenameProcessorStep(rename_map=rename_map)
+    pipeline = DataProcessorPipeline([processor], name="TestRenameProcessorStep")
 
     with tempfile.TemporaryDirectory() as tmp_dir:
         # Save pipeline
         pipeline.save_pretrained(tmp_dir)
 
         # Check files were created
-        config_path = Path(tmp_dir) / "testrenameprocessor.json"  # Based on name="TestRenameProcessor"
+        config_path = (
+            Path(tmp_dir) / "testrenameprocessorstep.json"
+        )  # Based on name="TestRenameProcessorStep"
         assert config_path.exists()
 
-        # No state files should be created for RenameProcessor
+        # No state files should be created for RenameProcessorStep
         state_files = list(Path(tmp_dir).glob("*.safetensors"))
         assert len(state_files) == 0
 
         # Load pipeline
-        loaded_pipeline = RobotProcessor.from_pretrained(
+        loaded_pipeline = DataProcessorPipeline.from_pretrained(
             tmp_dir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
-        assert loaded_pipeline.name == "TestRenameProcessor"
+        assert loaded_pipeline.name == "TestRenameProcessorStep"
         assert len(loaded_pipeline) == 1
 
         # Check that loaded processor works correctly
         loaded_processor = loaded_pipeline.steps[0]
-        assert isinstance(loaded_processor, RenameProcessor)
+        assert isinstance(loaded_processor, RenameProcessorStep)
         assert loaded_processor.rename_map == rename_map
 
         # Test functionality after loading
@@ -262,24 +269,24 @@ def test_save_and_load_pretrained():
 
 
 def test_registry_functionality():
-    """Test that RenameProcessor is properly registered."""
+    """Test that RenameProcessorStep is properly registered."""
     # Check that it's registered
     assert "rename_processor" in ProcessorStepRegistry.list()
 
     # Get from registry
     retrieved_class = ProcessorStepRegistry.get("rename_processor")
-    assert retrieved_class is RenameProcessor
+    assert retrieved_class is RenameProcessorStep
 
     # Create instance from registry
     instance = retrieved_class(rename_map={"old": "new"})
-    assert isinstance(instance, RenameProcessor)
+    assert isinstance(instance, RenameProcessorStep)
     assert instance.rename_map == {"old": "new"}
 
 
 def test_registry_based_save_load():
     """Test save/load using registry name instead of module path."""
-    processor = RenameProcessor(rename_map={"key1": "renamed_key1"})
-    pipeline = RobotProcessor([processor], to_transition=lambda x: x, to_output=lambda x: x)
+    processor = RenameProcessorStep(rename_map={"key1": "renamed_key1"})
+    pipeline = DataProcessorPipeline([processor], to_transition=lambda x: x, to_output=lambda x: x)
 
     with tempfile.TemporaryDirectory() as tmp_dir:
         # Save and load
@@ -288,7 +295,7 @@ def test_registry_based_save_load():
         # Verify config uses registry name
         import json
 
-        with open(Path(tmp_dir) / "robotprocessor.json") as f:  # Default name is "RobotProcessor"
+        with open(Path(tmp_dir) / "dataprocessorpipeline.json") as f:  # Default name is "RobotProcessor"
             config = json.load(f)
 
         assert "registry_name" in config["steps"][0]
@@ -296,16 +303,16 @@ def test_registry_based_save_load():
         assert "class" not in config["steps"][0]  # Should use registry, not module path
 
         # Load should work
-        loaded_pipeline = RobotProcessor.from_pretrained(tmp_dir)
+        loaded_pipeline = DataProcessorPipeline.from_pretrained(tmp_dir)
         loaded_processor = loaded_pipeline.steps[0]
-        assert isinstance(loaded_processor, RenameProcessor)
+        assert isinstance(loaded_processor, RenameProcessorStep)
         assert loaded_processor.rename_map == {"key1": "renamed_key1"}
 
 
 def test_chained_rename_processors():
-    """Test multiple RenameProcessors in a pipeline."""
+    """Test multiple RenameProcessorSteps in a pipeline."""
     # First processor: rename raw keys to intermediate format
-    processor1 = RenameProcessor(
+    processor1 = RenameProcessorStep(
         rename_map={
             "pos": "agent_position",
             "img": "camera_image",
@@ -313,14 +320,16 @@ def test_chained_rename_processors():
     )
 
     # Second processor: rename to final format
-    processor2 = RenameProcessor(
+    processor2 = RenameProcessorStep(
         rename_map={
             "agent_position": "observation.state",
             "camera_image": "observation.image",
         }
     )
 
-    pipeline = RobotProcessor([processor1, processor2], to_transition=lambda x: x, to_output=lambda x: x)
+    pipeline = DataProcessorPipeline(
+        [processor1, processor2], to_transition=lambda x: x, to_output=lambda x: x
+    )
 
     observation = {
         "pos": np.array([1.0, 2.0]),
@@ -356,7 +365,7 @@ def test_nested_observation_rename():
         "observation.images.right": "observation.camera.right_view",
         "observation.proprio": "observation.proprioception",
     }
-    processor = RenameProcessor(rename_map=rename_map)
+    processor = RenameProcessorStep(rename_map=rename_map)
 
     observation = {
         "observation.images.left": torch.randn(3, 64, 64),
@@ -386,7 +395,7 @@ def test_nested_observation_rename():
 def test_value_types_preserved():
     """Test that various value types are preserved during renaming."""
     rename_map = {"old_tensor": "new_tensor", "old_array": "new_array", "old_scalar": "new_scalar"}
-    processor = RenameProcessor(rename_map=rename_map)
+    processor = RenameProcessorStep(rename_map=rename_map)
 
     tensor_value = torch.randn(3, 3)
     array_value = np.random.rand(2, 2)
@@ -414,7 +423,7 @@ def test_value_types_preserved():
 
 
 def test_features_basic_renaming(policy_feature_factory):
-    processor = RenameProcessor(rename_map={"a": "x", "b": "y"})
+    processor = RenameProcessorStep(rename_map={"a": "x", "b": "y"})
     features = {
         "a": policy_feature_factory(FeatureType.STATE, (2,)),
         "b": policy_feature_factory(FeatureType.ACTION, (3,)),
@@ -435,7 +444,7 @@ def test_features_basic_renaming(policy_feature_factory):
 
 def test_features_overlapping_keys(policy_feature_factory):
     # Overlapping renames: both 'a' and 'b' exist. 'a'->'b', 'b'->'c'
-    processor = RenameProcessor(rename_map={"a": "b", "b": "c"})
+    processor = RenameProcessorStep(rename_map={"a": "b", "b": "c"})
     features = {
         "a": policy_feature_factory(FeatureType.STATE, (1,)),
         "b": policy_feature_factory(FeatureType.STATE, (2,)),
@@ -450,11 +459,11 @@ def test_features_overlapping_keys(policy_feature_factory):
 
 def test_features_chained_processors(policy_feature_factory):
     # Chain two rename processors at the contract level
-    processor1 = RenameProcessor(rename_map={"pos": "agent_position", "img": "camera_image"})
-    processor2 = RenameProcessor(
+    processor1 = RenameProcessorStep(rename_map={"pos": "agent_position", "img": "camera_image"})
+    processor2 = RenameProcessorStep(
         rename_map={"agent_position": "observation.state", "camera_image": "observation.image"}
     )
-    pipeline = RobotProcessor([processor1, processor2])
+    pipeline = DataProcessorPipeline([processor1, processor2])
 
     spec = {
         "pos": policy_feature_factory(FeatureType.STATE, (7,)),

tests/processor/test_sac_processor.py

@@ -25,14 +25,14 @@ from lerobot.constants import ACTION, OBS_STATE
 from lerobot.policies.sac.configuration_sac import SACConfig
 from lerobot.policies.sac.processor_sac import make_sac_pre_post_processors
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -91,15 +91,15 @@ def test_make_sac_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 4
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
-    assert isinstance(preprocessor.steps[3], DeviceProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
+    assert isinstance(preprocessor.steps[3], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_sac_processor_normalization_modes():
@@ -234,13 +234,13 @@ def test_sac_processor_without_stats():
     factory_preprocessor, factory_postprocessor = make_sac_pre_post_processors(config, dataset_stats=None)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(
+    preprocessor = DataProcessorPipeline(
         factory_preprocessor.steps,
         name=factory_preprocessor.name,
         to_transition=lambda x: x,
         to_output=lambda x: x,
     )
-    postprocessor = RobotProcessor(
+    postprocessor = DataProcessorPipeline(
         factory_postprocessor.steps,
         name=factory_postprocessor.name,
         to_transition=lambda x: x,
@@ -277,7 +277,7 @@ def test_sac_processor_save_and_load():
         preprocessor.save_pretrained(tmpdir)
 
         # Load preprocessor
-        loaded_preprocessor = RobotProcessor.from_pretrained(
+        loaded_preprocessor = DataProcessorPipeline.from_pretrained(
             tmpdir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -306,10 +306,10 @@ def test_sac_processor_mixed_precision():
         postprocessor_kwargs={"to_transition": lambda x: x, "to_output": lambda x: x},
     )
 
-    # Replace DeviceProcessor with one that uses float16
+    # Replace DeviceProcessorStep with one that uses float16
     for i, step in enumerate(preprocessor.steps):
-        if isinstance(step, DeviceProcessor):
-            preprocessor.steps[i] = DeviceProcessor(device=config.device, float_dtype="float16")
+        if isinstance(step, DeviceProcessorStep):
+            preprocessor.steps[i] = DeviceProcessorStep(device=config.device, float_dtype="float16")
 
     # Create test data
     observation = {OBS_STATE: torch.randn(10, dtype=torch.float32)}

tests/processor/test_smolvla_processor.py

@@ -28,13 +28,31 @@ from lerobot.policies.smolvla.processor_smolvla import (
     make_smolvla_pre_post_processors,
 )
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DeviceProcessorStep,
+    EnvTransition,
+    NormalizerProcessorStep,
+    ProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
+
+
+class MockTokenizerProcessorStep(ProcessorStep):
+    """Mock tokenizer processor step for testing."""
+
+    def __init__(self, *args, **kwargs):
+        # Accept any arguments to mimic the real TokenizerProcessorStep interface
+        pass
+
+    def __call__(self, transition: EnvTransition) -> EnvTransition:
+        # Pass through transition unchanged
+        return transition
+
+    def transform_features(self, features):
+        # Pass through features unchanged
+        return features
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -88,7 +106,9 @@ def test_make_smolvla_processor_basic():
     config = create_default_config()
     stats = create_default_stats()
 
-    with patch("lerobot.policies.smolvla.processor_smolvla.TokenizerProcessor"):
+    with patch(
+        "lerobot.policies.smolvla.processor_smolvla.TokenizerProcessorStep", MockTokenizerProcessorStep
+    ):
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
@@ -102,17 +122,17 @@ def test_make_smolvla_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 6
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
     assert isinstance(preprocessor.steps[3], SmolVLANewLineProcessor)
-    # Step 4 would be TokenizerProcessor but it's mocked
-    assert isinstance(preprocessor.steps[5], DeviceProcessor)
+    # Step 4 would be TokenizerProcessorStep but it's mocked
+    assert isinstance(preprocessor.steps[5], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_smolvla_newline_processor_single_task():
@@ -170,7 +190,7 @@ def test_smolvla_processor_cuda():
     stats = create_default_stats()
 
     # Mock the tokenizer processor to act as pass-through
-    class MockTokenizerProcessor:
+    class MockTokenizerProcessorStep(ProcessorStep):
         def __init__(self, *args, **kwargs):
             pass
 
@@ -192,7 +212,9 @@ def test_smolvla_processor_cuda():
         def transform_features(self, features):
             return features
 
-    with patch("lerobot.policies.smolvla.processor_smolvla.TokenizerProcessor", MockTokenizerProcessor):
+    with patch(
+        "lerobot.policies.smolvla.processor_smolvla.TokenizerProcessorStep", MockTokenizerProcessorStep
+    ):
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
@@ -225,7 +247,7 @@ def test_smolvla_processor_accelerate_scenario():
     stats = create_default_stats()
 
     # Mock the tokenizer processor to act as pass-through
-    class MockTokenizerProcessor:
+    class MockTokenizerProcessorStep(ProcessorStep):
         def __init__(self, *args, **kwargs):
             pass
 
@@ -247,7 +269,9 @@ def test_smolvla_processor_accelerate_scenario():
         def transform_features(self, features):
             return features
 
-    with patch("lerobot.policies.smolvla.processor_smolvla.TokenizerProcessor", MockTokenizerProcessor):
+    with patch(
+        "lerobot.policies.smolvla.processor_smolvla.TokenizerProcessorStep", MockTokenizerProcessorStep
+    ):
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
@@ -281,7 +305,7 @@ def test_smolvla_processor_multi_gpu():
     stats = create_default_stats()
 
     # Mock the tokenizer processor to act as pass-through
-    class MockTokenizerProcessor:
+    class MockTokenizerProcessorStep(ProcessorStep):
         def __init__(self, *args, **kwargs):
             pass
 
@@ -303,7 +327,9 @@ def test_smolvla_processor_multi_gpu():
         def transform_features(self, features):
             return features
 
-    with patch("lerobot.policies.smolvla.processor_smolvla.TokenizerProcessor", MockTokenizerProcessor):
+    with patch(
+        "lerobot.policies.smolvla.processor_smolvla.TokenizerProcessorStep", MockTokenizerProcessorStep
+    ):
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
@@ -334,7 +360,9 @@ def test_smolvla_processor_without_stats():
     config = create_default_config()
 
     # Mock the tokenizer processor
-    with patch("lerobot.policies.smolvla.processor_smolvla.TokenizerProcessor"):
+    with patch(
+        "lerobot.policies.smolvla.processor_smolvla.TokenizerProcessorStep", MockTokenizerProcessorStep
+    ):
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             dataset_stats=None,

tests/processor/test_tdmpc_processor.py

@@ -25,14 +25,14 @@ from lerobot.constants import ACTION, OBS_IMAGE, OBS_STATE
 from lerobot.policies.tdmpc.configuration_tdmpc import TDMPCConfig
 from lerobot.policies.tdmpc.processor_tdmpc import make_tdmpc_pre_post_processors
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -94,15 +94,15 @@ def test_make_tdmpc_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 4
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
-    assert isinstance(preprocessor.steps[3], DeviceProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
+    assert isinstance(preprocessor.steps[3], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_tdmpc_processor_normalization():
@@ -251,13 +251,13 @@ def test_tdmpc_processor_without_stats():
     factory_preprocessor, factory_postprocessor = make_tdmpc_pre_post_processors(config, dataset_stats=None)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(
+    preprocessor = DataProcessorPipeline(
         factory_preprocessor.steps,
         name=factory_preprocessor.name,
         to_transition=lambda x: x,
         to_output=lambda x: x,
     )
-    postprocessor = RobotProcessor(
+    postprocessor = DataProcessorPipeline(
         factory_postprocessor.steps,
         name=factory_postprocessor.name,
         to_transition=lambda x: x,
@@ -297,7 +297,7 @@ def test_tdmpc_processor_save_and_load():
         preprocessor.save_pretrained(tmpdir)
 
         # Load preprocessor
-        loaded_preprocessor = RobotProcessor.from_pretrained(
+        loaded_preprocessor = DataProcessorPipeline.from_pretrained(
             tmpdir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -330,10 +330,10 @@ def test_tdmpc_processor_mixed_precision():
         postprocessor_kwargs={"to_transition": lambda x: x, "to_output": lambda x: x},
     )
 
-    # Replace DeviceProcessor with one that uses float16
+    # Replace DeviceProcessorStep with one that uses float16
     for i, step in enumerate(preprocessor.steps):
-        if isinstance(step, DeviceProcessor):
-            preprocessor.steps[i] = DeviceProcessor(device=config.device, float_dtype="float16")
+        if isinstance(step, DeviceProcessorStep):
+            preprocessor.steps[i] = DeviceProcessorStep(device=config.device, float_dtype="float16")
 
     # Create test data
     observation = {

tests/processor/test_tokenizer_processor.py

@@ -1,5 +1,5 @@
 """
-Tests for the TokenizerProcessor class.
+Tests for the TokenizerProcessorStep class.
 """
 
 import tempfile
@@ -10,8 +10,7 @@ import torch
 
 from lerobot.configs.types import FeatureType, PolicyFeature
 from lerobot.constants import OBS_LANGUAGE
-from lerobot.processor.pipeline import RobotProcessor, TransitionKey
-from lerobot.processor.tokenizer_processor import TokenizerProcessor
+from lerobot.processor import DataProcessorPipeline, TokenizerProcessorStep, TransitionKey
 from tests.utils import require_package
 
 
@@ -96,7 +95,7 @@ def test_basic_tokenization(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=10)
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=10)
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -128,7 +127,7 @@ def test_basic_tokenization_with_tokenizer_object():
     """Test basic string tokenization functionality using tokenizer object directly."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
 
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -162,7 +161,7 @@ def test_list_of_strings_tokenization(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=8)
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=8)
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -190,7 +189,7 @@ def test_custom_keys(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer", task_key="instruction", max_length=5)
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", task_key="instruction", max_length=5)
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -216,7 +215,7 @@ def test_none_complementary_data(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     transition = create_transition(complementary_data=None)
 
@@ -231,7 +230,7 @@ def test_missing_task_key(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     transition = create_transition(complementary_data={"other_field": "some value"})
 
@@ -246,7 +245,7 @@ def test_none_task_value(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     transition = create_transition(complementary_data={"task": None})
 
@@ -261,7 +260,7 @@ def test_unsupported_task_type(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     # Test with integer task
     transition = create_transition(complementary_data={"task": 123})
@@ -280,7 +279,7 @@ def test_unsupported_task_type(mock_auto_tokenizer):
 def test_no_tokenizer_error():
     """Test that ValueError is raised when neither tokenizer nor tokenizer_name is provided."""
     with pytest.raises(ValueError, match="Either 'tokenizer' or 'tokenizer_name' must be provided"):
-        TokenizerProcessor()
+        TokenizerProcessorStep()
 
 
 @require_package("transformers")
@@ -291,7 +290,7 @@ def test_invalid_tokenizer_name_error():
         mock_auto_tokenizer.from_pretrained.side_effect = Exception("Model not found")
 
         with pytest.raises(Exception, match="Model not found"):
-            TokenizerProcessor(tokenizer_name="invalid-tokenizer")
+            TokenizerProcessorStep(tokenizer_name="invalid-tokenizer")
 
 
 @require_package("transformers")
@@ -301,7 +300,7 @@ def test_get_config_with_tokenizer_name(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(
+    processor = TokenizerProcessorStep(
         tokenizer_name="test-tokenizer",
         max_length=256,
         task_key="instruction",
@@ -328,7 +327,7 @@ def test_get_config_with_tokenizer_object():
     """Test configuration serialization when using tokenizer object."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
 
-    processor = TokenizerProcessor(
+    processor = TokenizerProcessorStep(
         tokenizer=mock_tokenizer,
         max_length=256,
         task_key="instruction",
@@ -358,7 +357,7 @@ def test_state_dict_methods(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     # Should return empty dict
     state = processor.state_dict()
@@ -375,7 +374,7 @@ def test_reset_method(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     # Should not raise error
     processor.reset()
@@ -388,8 +387,10 @@ def test_integration_with_robot_processor(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    tokenizer_processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=6)
-    robot_processor = RobotProcessor([tokenizer_processor], to_transition=lambda x: x, to_output=lambda x: x)
+    tokenizer_processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=6)
+    robot_processor = DataProcessorPipeline(
+        [tokenizer_processor], to_transition=lambda x: x, to_output=lambda x: x
+    )
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -423,18 +424,20 @@ def test_save_and_load_pretrained_with_tokenizer_name(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    original_processor = TokenizerProcessor(
+    original_processor = TokenizerProcessorStep(
         tokenizer_name="test-tokenizer", max_length=32, task_key="instruction"
     )
 
-    robot_processor = RobotProcessor([original_processor], to_transition=lambda x: x, to_output=lambda x: x)
+    robot_processor = DataProcessorPipeline(
+        [original_processor], to_transition=lambda x: x, to_output=lambda x: x
+    )
 
     with tempfile.TemporaryDirectory() as temp_dir:
         # Save processor
         robot_processor.save_pretrained(temp_dir)
 
         # Load processor - tokenizer will be recreated from saved config
-        loaded_processor = RobotProcessor.from_pretrained(
+        loaded_processor = DataProcessorPipeline.from_pretrained(
             temp_dir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -456,16 +459,20 @@ def test_save_and_load_pretrained_with_tokenizer_object():
     """Test saving and loading processor with tokenizer object using overrides."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
 
-    original_processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=32, task_key="instruction")
+    original_processor = TokenizerProcessorStep(
+        tokenizer=mock_tokenizer, max_length=32, task_key="instruction"
+    )
 
-    robot_processor = RobotProcessor([original_processor], to_transition=lambda x: x, to_output=lambda x: x)
+    robot_processor = DataProcessorPipeline(
+        [original_processor], to_transition=lambda x: x, to_output=lambda x: x
+    )
 
     with tempfile.TemporaryDirectory() as temp_dir:
         # Save processor
         robot_processor.save_pretrained(temp_dir)
 
         # Load processor with tokenizer override (since tokenizer object wasn't saved)
-        loaded_processor = RobotProcessor.from_pretrained(
+        loaded_processor = DataProcessorPipeline.from_pretrained(
             temp_dir,
             overrides={"tokenizer_processor": {"tokenizer": mock_tokenizer}},
             to_transition=lambda x: x,
@@ -488,21 +495,21 @@ def test_save_and_load_pretrained_with_tokenizer_object():
 @require_package("transformers")
 def test_registry_functionality():
     """Test that the processor is properly registered."""
-    from lerobot.processor.pipeline import ProcessorStepRegistry
+    from lerobot.processor import ProcessorStepRegistry
 
     # Check that the processor is registered
     assert "tokenizer_processor" in ProcessorStepRegistry.list()
 
     # Check that we can retrieve it
     retrieved_class = ProcessorStepRegistry.get("tokenizer_processor")
-    assert retrieved_class is TokenizerProcessor
+    assert retrieved_class is TokenizerProcessorStep
 
 
 @require_package("transformers")
 def test_features_basic():
     """Test basic feature contract functionality."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=128)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=128)
 
     input_features = {
         "observation.state": PolicyFeature(type=FeatureType.STATE, shape=(10,)),
@@ -533,7 +540,7 @@ def test_features_basic():
 def test_features_with_custom_max_length():
     """Test feature contract with custom max_length."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=64)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=64)
 
     input_features = {}
     output_features = processor.transform_features(input_features)
@@ -553,7 +560,7 @@ def test_features_with_custom_max_length():
 def test_features_existing_features():
     """Test feature contract when tokenized features already exist."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=256)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=256)
 
     input_features = {
         f"{OBS_LANGUAGE}.tokens": PolicyFeature(type=FeatureType.LANGUAGE, shape=(100,)),
@@ -590,7 +597,7 @@ def test_tokenization_parameters(mock_auto_tokenizer):
     tracking_tokenizer = TrackingMockTokenizer()
     mock_auto_tokenizer.from_pretrained.return_value = tracking_tokenizer
 
-    processor = TokenizerProcessor(
+    processor = TokenizerProcessorStep(
         tokenizer_name="test-tokenizer",
         max_length=16,
         padding="longest",
@@ -622,7 +629,7 @@ def test_preserves_other_complementary_data(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer")
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer")
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -657,7 +664,7 @@ def test_deterministic_tokenization(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=10)
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=10)
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -685,7 +692,7 @@ def test_empty_string_task(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=8)
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=8)
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -709,7 +716,7 @@ def test_very_long_task(mock_auto_tokenizer):
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=5, truncation=True)
+    processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=5, truncation=True)
 
     long_task = " ".join(["word"] * 100)  # Very long task
     transition = create_transition(
@@ -759,7 +766,9 @@ def test_custom_padding_side(mock_auto_tokenizer):
     mock_auto_tokenizer.from_pretrained.return_value = tracking_tokenizer
 
     # Test left padding
-    processor_left = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=10, padding_side="left")
+    processor_left = TokenizerProcessorStep(
+        tokenizer_name="test-tokenizer", max_length=10, padding_side="left"
+    )
 
     transition = create_transition(
         observation={"state": torch.tensor([1.0, 2.0])},
@@ -771,7 +780,9 @@ def test_custom_padding_side(mock_auto_tokenizer):
     assert tracking_tokenizer.padding_side_calls[-1] == "left"
 
     # Test right padding (default)
-    processor_right = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=10, padding_side="right")
+    processor_right = TokenizerProcessorStep(
+        tokenizer_name="test-tokenizer", max_length=10, padding_side="right"
+    )
 
     processor_right(transition)
 
@@ -782,7 +793,7 @@ def test_custom_padding_side(mock_auto_tokenizer):
 def test_device_detection_cpu():
     """Test that tokenized tensors stay on CPU when other tensors are on CPU."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Create transition with CPU tensors
     observation = {"observation.state": torch.randn(10)}  # CPU tensor
@@ -806,7 +817,7 @@ def test_device_detection_cpu():
 def test_device_detection_cuda():
     """Test that tokenized tensors are moved to CUDA when other tensors are on CUDA."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Create transition with CUDA tensors
     observation = {"observation.state": torch.randn(10).cuda()}  # CUDA tensor
@@ -831,7 +842,7 @@ def test_device_detection_cuda():
 def test_device_detection_multi_gpu():
     """Test that tokenized tensors match device in multi-GPU setup."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Test with tensors on cuda:1
     device = torch.device("cuda:1")
@@ -855,7 +866,7 @@ def test_device_detection_multi_gpu():
 def test_device_detection_no_tensors():
     """Test that tokenized tensors stay on CPU when no other tensors exist."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Create transition with no tensors
     transition = create_transition(
@@ -877,7 +888,7 @@ def test_device_detection_no_tensors():
 def test_device_detection_mixed_devices():
     """Test device detection when tensors are on different devices (uses first found)."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     if torch.cuda.is_available():
         # Create transition with mixed devices
@@ -905,7 +916,7 @@ def test_device_detection_mixed_devices():
 def test_device_detection_from_action():
     """Test that device is detected from action tensor when no observation tensors exist."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Create transition with action on CUDA but no observation tensors
     observation = {"metadata": {"key": "value"}}  # No tensors in observation
@@ -928,7 +939,7 @@ def test_device_detection_from_action():
 def test_device_detection_preserves_dtype():
     """Test that device detection doesn't affect dtype of tokenized tensors."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Create transition with float tensor (to test dtype isn't affected)
     observation = {"observation.state": torch.randn(10, dtype=torch.float16)}
@@ -948,16 +959,16 @@ def test_device_detection_preserves_dtype():
 @require_package("transformers")
 @patch("lerobot.processor.tokenizer_processor.AutoTokenizer")
 def test_integration_with_device_processor(mock_auto_tokenizer):
-    """Test that TokenizerProcessor works correctly with DeviceProcessor in pipeline."""
-    from lerobot.processor import DeviceProcessor
+    """Test that TokenizerProcessorStep works correctly with DeviceProcessorStep in pipeline."""
+    from lerobot.processor import DeviceProcessorStep
 
     mock_tokenizer = MockTokenizer(vocab_size=100)
     mock_auto_tokenizer.from_pretrained.return_value = mock_tokenizer
 
-    # Create pipeline with TokenizerProcessor then DeviceProcessor
-    tokenizer_processor = TokenizerProcessor(tokenizer_name="test-tokenizer", max_length=6)
-    device_processor = DeviceProcessor(device="cuda:0")
-    robot_processor = RobotProcessor(
+    # Create pipeline with TokenizerProcessorStep then DeviceProcessorStep
+    tokenizer_processor = TokenizerProcessorStep(tokenizer_name="test-tokenizer", max_length=6)
+    device_processor = DeviceProcessorStep(device="cuda:0")
+    robot_processor = DataProcessorPipeline(
         [tokenizer_processor, device_processor], to_transition=lambda x: x, to_output=lambda x: x
     )
 
@@ -970,7 +981,7 @@ def test_integration_with_device_processor(mock_auto_tokenizer):
 
     result = robot_processor(transition)
 
-    # All tensors should end up on CUDA (moved by DeviceProcessor)
+    # All tensors should end up on CUDA (moved by DeviceProcessorStep)
     assert result[TransitionKey.OBSERVATION]["observation.state"].device.type == "cuda"
     assert result[TransitionKey.ACTION].device.type == "cuda"
 
@@ -986,7 +997,7 @@ def test_integration_with_device_processor(mock_auto_tokenizer):
 def test_simulated_accelerate_scenario():
     """Test scenario simulating Accelerate with data already on GPU."""
     mock_tokenizer = MockTokenizer(vocab_size=100)
-    processor = TokenizerProcessor(tokenizer=mock_tokenizer, max_length=10)
+    processor = TokenizerProcessorStep(tokenizer=mock_tokenizer, max_length=10)
 
     # Simulate Accelerate scenario: batch already on GPU
     device = torch.device("cuda:0")

tests/processor/test_vqbet_processor.py

@@ -25,14 +25,14 @@ from lerobot.constants import ACTION, OBS_IMAGE, OBS_STATE
 from lerobot.policies.vqbet.configuration_vqbet import VQBeTConfig
 from lerobot.policies.vqbet.processor_vqbet import make_vqbet_pre_post_processors
 from lerobot.processor import (
-    DeviceProcessor,
-    NormalizerProcessor,
-    RenameProcessor,
-    RobotProcessor,
-    ToBatchProcessor,
-    UnnormalizerProcessor,
+    AddBatchDimensionProcessorStep,
+    DataProcessorPipeline,
+    DeviceProcessorStep,
+    NormalizerProcessorStep,
+    RenameProcessorStep,
+    TransitionKey,
+    UnnormalizerProcessorStep,
 )
-from lerobot.processor.pipeline import TransitionKey
 
 
 def create_transition(observation=None, action=None, **kwargs):
@@ -94,15 +94,15 @@ def test_make_vqbet_processor_basic():
 
     # Check steps in preprocessor
     assert len(preprocessor.steps) == 4
-    assert isinstance(preprocessor.steps[0], RenameProcessor)
-    assert isinstance(preprocessor.steps[1], NormalizerProcessor)
-    assert isinstance(preprocessor.steps[2], ToBatchProcessor)
-    assert isinstance(preprocessor.steps[3], DeviceProcessor)
+    assert isinstance(preprocessor.steps[0], RenameProcessorStep)
+    assert isinstance(preprocessor.steps[1], NormalizerProcessorStep)
+    assert isinstance(preprocessor.steps[2], AddBatchDimensionProcessorStep)
+    assert isinstance(preprocessor.steps[3], DeviceProcessorStep)
 
     # Check steps in postprocessor
     assert len(postprocessor.steps) == 2
-    assert isinstance(postprocessor.steps[0], DeviceProcessor)
-    assert isinstance(postprocessor.steps[1], UnnormalizerProcessor)
+    assert isinstance(postprocessor.steps[0], DeviceProcessorStep)
+    assert isinstance(postprocessor.steps[1], UnnormalizerProcessorStep)
 
 
 def test_vqbet_processor_with_images():
@@ -244,13 +244,13 @@ def test_vqbet_processor_without_stats():
     factory_preprocessor, factory_postprocessor = make_vqbet_pre_post_processors(config, dataset_stats=None)
 
     # Create new processors with EnvTransition input/output
-    preprocessor = RobotProcessor(
+    preprocessor = DataProcessorPipeline(
         factory_preprocessor.steps,
         name=factory_preprocessor.name,
         to_transition=lambda x: x,
         to_output=lambda x: x,
     )
-    postprocessor = RobotProcessor(
+    postprocessor = DataProcessorPipeline(
         factory_postprocessor.steps,
         name=factory_postprocessor.name,
         to_transition=lambda x: x,
@@ -290,7 +290,7 @@ def test_vqbet_processor_save_and_load():
         preprocessor.save_pretrained(tmpdir)
 
         # Load preprocessor
-        loaded_preprocessor = RobotProcessor.from_pretrained(
+        loaded_preprocessor = DataProcessorPipeline.from_pretrained(
             tmpdir, to_transition=lambda x: x, to_output=lambda x: x
         )
 
@@ -323,10 +323,10 @@ def test_vqbet_processor_mixed_precision():
         postprocessor_kwargs={"to_transition": lambda x: x, "to_output": lambda x: x},
     )
 
-    # Replace DeviceProcessor with one that uses float16
+    # Replace DeviceProcessorStep with one that uses float16
     for i, step in enumerate(preprocessor.steps):
-        if isinstance(step, DeviceProcessor):
-            preprocessor.steps[i] = DeviceProcessor(device=config.device, float_dtype="float16")
+        if isinstance(step, DeviceProcessorStep):
+            preprocessor.steps[i] = DeviceProcessorStep(device=config.device, float_dtype="float16")
 
     # Create test data
     observation = {

tests/utils/test_visualization_utils.py

@@ -5,7 +5,7 @@ from types import SimpleNamespace
 import numpy as np
 import pytest
 
-from lerobot.processor.pipeline import TransitionKey
+from lerobot.processor import TransitionKey
 
 
 @pytest.fixture