fix(augment): reject CLAHE clip_limit sequences albumentations rejects

A one-element sequence is not a scalar. Albumentations validates clip_limit
as a float or an exact 2-tuple and raises on [4.0], while this helper read
it through _as_range and turned it into (1.0, 4.0). That accepted a config
the CPU backend refuses, which is the divergence the helper exists to
remove.

Also annotates the parametrized arguments and splits the cross-backend
comparison into independent cases, so one failure no longer hides the rest.

Author: adhavan18

src/rfdetr/datasets/kornia_transforms.py

@@ -602,22 +602,33 @@ def _as_clahe_clip_limit(value: Any) -> tuple[float, float]:
     distribution rather than the units.
 
     Args:
-        value: A scalar, a 1-element sequence, or a 2-element ``(min, max)`` pair.
+        value: A scalar, or a 2-element ``(min, max)`` pair.
 
     Returns:
         The ``(min, max)`` pair Albumentations would sample from for the same config.
 
+    Raises:
+        ValueError: If *value* is a sequence of any length other than two. Albumentations validates ``clip_limit`` as
+            either a float or an exact 2-tuple and rejects ``[4.0]``, so accepting it here (as a scalar, via
+            :func:`_as_range`) would make the same config train on the GPU backend and fail on the CPU one. The point
+            of this helper is that the two agree.
+
     Examples:
         >>> _as_clahe_clip_limit(4.0)
         (1.0, 4.0)
         >>> _as_clahe_clip_limit((2.0, 6.0))
         (2.0, 6.0)
     """
-    if isinstance(value, (list, tuple)) and len(value) == 2:
+    if isinstance(value, (list, tuple)):
+        if len(value) != 2:
+            raise ValueError(
+                "CLAHE clip_limit must be a scalar or a 2-element (min, max) pair; "
+                f"got a {len(value)}-element sequence: {value!r}. Albumentations rejects this too, so the CPU "
+                "(albumentations) backend would fail on the same config."
+            )
         return (float(value[0]), float(value[1]))
-    low, high = _as_range(value)
-    # A scalar (or 1-element sequence) arrives here as the degenerate (v, v).
-    return (1.0, high) if low == high else (low, high)
+    # A scalar means the range (1, v), which is what `to_tuple(v, low=1)` produces.
+    return (1.0, float(value))
 
 
 def _make_clahe(params: dict[str, Any]) -> Any:

tests/datasets/test_kornia_transforms.py

@@ -426,7 +426,9 @@ def test_clahe_maps_both_parameters(self):
         ],
         ids=["default", "scalar-default-value", "scalar", "pair", "pair-non-default"],
     )
-    def test_clahe_scalar_clip_limit_is_a_range_not_a_fixed_value(self, configured, expected) -> None:
+    def test_clahe_scalar_clip_limit_is_a_range_not_a_fixed_value(
+        self, configured: float | tuple[float, float] | None, expected: tuple[float, float]
+    ) -> None:
         """Albumentations reads a scalar clip_limit as (1, v), so the GPU path must too.
 
         Passing it through `_as_range` produced the degenerate (v, v), which pins every sample to maximum contrast
@@ -441,20 +443,39 @@ def test_clahe_scalar_clip_limit_is_a_range_not_a_fixed_value(self, configured,
 
         assert tuple(transform.clip_limit) == pytest.approx(expected)
 
-    def test_clahe_clip_limit_matches_albumentations(self) -> None:
+    @pytest.mark.parametrize(
+        "configured",
+        [4.0, 2.0, (2.0, 6.0)],
+        ids=["scalar-default-value", "scalar", "pair"],
+    )
+    def test_clahe_clip_limit_matches_albumentations(self, configured: float | tuple[float, float]) -> None:
         """The contract stated directly: same config, same range on both backends."""
         albumentations = pytest.importorskip("albumentations")
 
         from rfdetr.datasets.kornia_transforms import build_kornia_pipeline
 
-        for configured in (4.0, 2.0, (2.0, 6.0)):
-            pipeline = build_kornia_pipeline({"CLAHE": {"clip_limit": configured}}, 560)
-            transform = next(iter(pipeline.children()))
-            cpu = albumentations.CLAHE(clip_limit=configured)
+        pipeline = build_kornia_pipeline({"CLAHE": {"clip_limit": configured}}, 560)
+        transform = next(iter(pipeline.children()))
+        cpu = albumentations.CLAHE(clip_limit=configured)
 
-            assert tuple(transform.clip_limit) == pytest.approx(tuple(cpu.clip_limit)), (
-                f"backends disagree for clip_limit={configured!r}"
-            )
+        assert tuple(transform.clip_limit) == pytest.approx(tuple(cpu.clip_limit)), (
+            f"backends disagree for clip_limit={configured!r}"
+        )
+
+    @pytest.mark.parametrize("configured", [[4.0], (4.0,), (1.0, 2.0, 3.0)], ids=["one-list", "one-tuple", "three"])
+    def test_clahe_rejects_sequences_that_albumentations_rejects(
+        self, configured: tuple[float, ...] | list[float]
+    ) -> None:
+        """A one-element sequence is not a scalar.
+
+        Albumentations validates `clip_limit` as a float or an exact 2-tuple and raises on `[4.0]`. Reading it as a
+        scalar here would accept a config the CPU backend refuses, which is the divergence this helper exists to
+        remove.
+        """
+        from rfdetr.datasets.kornia_transforms import build_kornia_pipeline
+
+        with pytest.raises(ValueError, match="2-element"):
+            build_kornia_pipeline({"CLAHE": {"clip_limit": configured}}, 560)
 
     def test_hue_saturation_value_still_unsupported(self):
         """Deliberately out of scope: albumentations shifts additively, Kornia scales multiplicatively."""