Validate slice result structure

Author: trissim

src/arraybridge/slice_processing.py

@@ -45,12 +45,33 @@ def process_slices(image, func, args, kwargs, gpu_id=None):
     # Process each slice and handle special outputs
     main_outputs = []
     special_outputs_list = []
+    returns_tuple = None
+    tuple_arity = None
 
-    for slice_2d in slices_2d:
+    for slice_index, slice_2d in enumerate(slices_2d):
         slice_result = func(slice_2d, *args, **kwargs)
 
         # Check if result is a tuple (indicating special outputs)
-        if isinstance(slice_result, tuple):
+        result_is_tuple = isinstance(slice_result, tuple)
+        if returns_tuple is None:
+            returns_tuple = result_is_tuple
+        elif result_is_tuple != returns_tuple:
+            raise TypeError(
+                "Slice processing cannot mix tuple and non-tuple results; "
+                f"slice {slice_index} returned {type(slice_result).__name__}."
+            )
+
+        if result_is_tuple:
+            if not slice_result:
+                raise ValueError("Slice processing result tuples cannot be empty")
+            if tuple_arity is None:
+                tuple_arity = len(slice_result)
+            elif len(slice_result) != tuple_arity:
+                raise ValueError(
+                    "Slice processing requires every result tuple to have the "
+                    f"same arity; slice {slice_index} returned {len(slice_result)}, "
+                    f"expected {tuple_arity}."
+                )
             main_outputs.append(slice_result[0])  # First element is main output
             special_outputs_list.append(slice_result[1:])  # Rest are special outputs
         else:

tests/test_slice_processing.py

@@ -83,9 +83,11 @@ def func_with_args_kwargs(slice_2d, multiplier, offset=0):
         np.testing.assert_array_equal(result, expected)
 
     def test_process_slices_empty_special_outputs(self):
-        """Test process_slices when some slices return no special outputs."""
+        """Reject a tuple/non-tuple result boundary between slices."""
 
-        np.array([[[1]], [[2]]])
+        from arraybridge.slice_processing import process_slices
+
+        image_3d = np.array([[[1]], [[2]]])
 
         # Mix of single output and tuple output
         def mixed_func(slice_2d):
@@ -94,9 +96,31 @@ def mixed_func(slice_2d):
             else:  # Second slice
                 return slice_2d * 3
 
-        # This should work but might be complex; for now, assume consistent return types
-        # In practice, functions should be consistent
-        pass  # Skip this test as it requires more complex logic
+        with pytest.raises(TypeError, match="mix tuple and non-tuple"):
+            process_slices(image_3d, mixed_func, (), {})
+
+    def test_process_slices_rejects_result_tuple_arity_drift(self):
+        """Reject side-output cardinality changes between slices."""
+
+        from arraybridge.slice_processing import process_slices
+
+        image_3d = np.array([[[1]], [[2]]])
+
+        def drifting_func(slice_2d):
+            if np.sum(slice_2d) == 1:
+                return slice_2d, "first"
+            return slice_2d, "second", "surplus"
+
+        with pytest.raises(ValueError, match="same arity"):
+            process_slices(image_3d, drifting_func, (), {})
+
+    def test_process_slices_rejects_empty_result_tuple(self):
+        """Reject a tuple that has no declared main output."""
+
+        from arraybridge.slice_processing import process_slices
+
+        with pytest.raises(ValueError, match="cannot be empty"):
+            process_slices(np.ones((1, 1, 1)), lambda _slice: (), (), {})
 
     @pytest.mark.parametrize(
         "shape",