feat(processor): enhance type safety with generic DataProcessorPipeline for policy and robot pipelines (#1915)

* refactor(processor): enhance type annotations for processors in record, replay, teleoperate, and control utils

- Updated type annotations for preprocessor and postprocessor parameters in record_loop and predict_action functions to specify the expected dictionary types.
- Adjusted robot_action_processor type in ReplayConfig and TeleoperateConfig to improve clarity and maintainability.
- Ensured consistency in type definitions across multiple files, enhancing overall code readability.

* refactor(processor): enhance type annotations for RobotProcessorPipeline in various files

- Updated type annotations for RobotProcessorPipeline instances in evaluate.py, record.py, replay.py, teleoperate.py, and other related files to specify input and output types more clearly.
- Introduced new type conversions for PolicyAction and EnvTransition to improve type safety and maintainability across the processing pipelines.
- Ensured consistency in type definitions, enhancing overall code readability and reducing potential runtime errors.

* refactor(processor): update transition handling in processors to use transition_to_batch

- Replaced direct transition handling with transition_to_batch in various processor tests and implementations to ensure consistent batching of input data.
- Updated assertions in tests to reflect changes in data structure, enhancing clarity and maintainability.
- Improved overall code readability by standardizing the way transitions are processed across different processor types.

* refactor(tests): standardize transition key usage in processor tests

- Updated assertions in processor test files to utilize the TransitionKey for action references, enhancing consistency across tests.
- Replaced direct string references with TransitionKey constants for improved readability and maintainability.
- Ensured that all relevant tests reflect these changes, contributing to a more uniform approach in handling transitions.

tests/processor/test_smolvla_processor.py

@@ -37,7 +37,7 @@ from lerobot.processor import (
     TransitionKey,
     UnnormalizerProcessorStep,
 )
-from lerobot.processor.converters import create_transition, identity_transition
+from lerobot.processor.converters import create_transition, transition_to_batch
 
 
 class MockTokenizerProcessorStep(ProcessorStep):
@@ -98,8 +98,6 @@ def test_make_smolvla_processor_basic():
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
-            preprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
-            postprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
         )
 
     # Check processor names
@@ -204,8 +202,6 @@ def test_smolvla_processor_cuda():
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
-            preprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
-            postprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
         )
 
     # Create CPU data
@@ -216,13 +212,16 @@ def test_smolvla_processor_cuda():
     action = torch.randn(7)
     transition = create_transition(observation, action, complementary_data={"task": "test task"})
 
+    batch = transition_to_batch(transition)
+
     # Process through preprocessor
-    processed = preprocessor(transition)
+
+    processed = preprocessor(batch)
 
     # Check that data is on CUDA
-    assert processed[TransitionKey.OBSERVATION][OBS_STATE].device.type == "cuda"
-    assert processed[TransitionKey.OBSERVATION][OBS_IMAGE].device.type == "cuda"
-    assert processed[TransitionKey.ACTION].device.type == "cuda"
+    assert processed[OBS_STATE].device.type == "cuda"
+    assert processed[OBS_IMAGE].device.type == "cuda"
+    assert processed[TransitionKey.ACTION.value].device.type == "cuda"
 
 
 @pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available")
@@ -261,8 +260,6 @@ def test_smolvla_processor_accelerate_scenario():
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
-            preprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
-            postprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
         )
 
     # Simulate Accelerate: data already on GPU and batched
@@ -274,13 +271,16 @@ def test_smolvla_processor_accelerate_scenario():
     action = torch.randn(1, 7).to(device)
     transition = create_transition(observation, action, complementary_data={"task": ["test task"]})
 
+    batch = transition_to_batch(transition)
+
     # Process through preprocessor
-    processed = preprocessor(transition)
+
+    processed = preprocessor(batch)
 
     # Check that data stays on same GPU
-    assert processed[TransitionKey.OBSERVATION][OBS_STATE].device == device
-    assert processed[TransitionKey.OBSERVATION][OBS_IMAGE].device == device
-    assert processed[TransitionKey.ACTION].device == device
+    assert processed[OBS_STATE].device == device
+    assert processed[OBS_IMAGE].device == device
+    assert processed[TransitionKey.ACTION.value].device == device
 
 
 @pytest.mark.skipif(torch.cuda.device_count() < 2, reason="Requires at least 2 GPUs")
@@ -319,8 +319,6 @@ def test_smolvla_processor_multi_gpu():
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             stats,
-            preprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
-            postprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
         )
 
     # Simulate data on different GPU
@@ -332,13 +330,16 @@ def test_smolvla_processor_multi_gpu():
     action = torch.randn(1, 7).to(device)
     transition = create_transition(observation, action, complementary_data={"task": ["test task"]})
 
+    batch = transition_to_batch(transition)
+
     # Process through preprocessor
-    processed = preprocessor(transition)
+
+    processed = preprocessor(batch)
 
     # Check that data stays on cuda:1
-    assert processed[TransitionKey.OBSERVATION][OBS_STATE].device == device
-    assert processed[TransitionKey.OBSERVATION][OBS_IMAGE].device == device
-    assert processed[TransitionKey.ACTION].device == device
+    assert processed[OBS_STATE].device == device
+    assert processed[OBS_IMAGE].device == device
+    assert processed[TransitionKey.ACTION.value].device == device
 
 
 def test_smolvla_processor_without_stats():
@@ -352,8 +353,6 @@ def test_smolvla_processor_without_stats():
         preprocessor, postprocessor = make_smolvla_pre_post_processors(
             config,
             dataset_stats=None,
-            preprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
-            postprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
         )
 
     # Should still create processors
@@ -405,8 +404,6 @@ def test_smolvla_processor_bfloat16_device_float32_normalizer():
         preprocessor, _ = make_smolvla_pre_post_processors(
             config,
             stats,
-            preprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
-            postprocessor_kwargs={"to_transition": identity_transition, "to_output": identity_transition},
         )
 
     # Modify the pipeline to use bfloat16 device processor with float32 normalizer
@@ -444,15 +441,15 @@ def test_smolvla_processor_bfloat16_device_float32_normalizer():
         observation, action, complementary_data={"task": "test bfloat16 adaptation"}
     )
 
+    batch = transition_to_batch(transition)
+
     # Process through full pipeline
-    processed = preprocessor(transition)
+    processed = preprocessor(batch)
 
     # Verify: DeviceProcessor → bfloat16, NormalizerProcessor adapts → final output is bfloat16
-    assert processed[TransitionKey.OBSERVATION][OBS_STATE].dtype == torch.bfloat16
-    assert (
-        processed[TransitionKey.OBSERVATION][OBS_IMAGE].dtype == torch.bfloat16
-    )  # IDENTITY normalization still gets dtype conversion
-    assert processed[TransitionKey.ACTION].dtype == torch.bfloat16
+    assert processed[OBS_STATE].dtype == torch.bfloat16
+    assert processed[OBS_IMAGE].dtype == torch.bfloat16  # IDENTITY normalization still gets dtype conversion
+    assert processed[TransitionKey.ACTION.value].dtype == torch.bfloat16
 
     # Verify normalizer automatically adapted its internal state
     assert normalizer_step.dtype == torch.bfloat16