benchmarks/test_patch_benchmarks.py (3)

205-208: Silence Ruff ARG002 by using the fixture without a param

Use the fixture via a decorator and drop the unused function arg.

Apply this diff:

-    @pytest.mark.benchmark
-    def test_waterfall(self, example_patch, cleanup_mpl):
+    @pytest.mark.usefixtures("cleanup_mpl")
+    @pytest.mark.benchmark
+    def test_waterfall(self, example_patch):
         """Timing for waterfall patch."""
         example_patch.viz.waterfall()

---

220-224: Same fix for wiggle plot test

Avoid the unused argument while still activating the fixture.

Apply this diff:

-    @pytest.mark.benchmark
-    def test_wiggle(self, example_patch, cleanup_mpl):
+    @pytest.mark.usefixtures("cleanup_mpl")
+    @pytest.mark.benchmark
+    def test_wiggle(self, example_patch):
         """Time wiggle plot visualization."""
         patch = example_patch.select(distance=(0, 100))  # Subset for performance
         patch.viz.wiggle()

---

129-140: Consider parametrizing separable for Hampel to reduce duplication

One parametrized test can cover both separable=True/False.

Apply this diff:

-    @pytest.mark.benchmark
-    def test_hampel_filter_non_separable(self, example_patch):
-        """Time the Hampel filter."""
-        example_patch.hampel_filter(
-            threshold=3.0, distance=3, time=5, samples=True, separable=False
-        )
-
-    @pytest.mark.benchmark
-    def test_hampel_filter(self, example_patch):
-        """Time the Hampel filter."""
-        example_patch.hampel_filter(
-            threshold=3.0, distance=3, time=5, samples=True, separable=True
-        )
+    @pytest.mark.parametrize("separable", [False, True])
+    @pytest.mark.benchmark
+    def test_hampel_filter(self, example_patch, separable):
+        """Time the Hampel filter (both non-separable and separable)."""
+        example_patch.hampel_filter(
+            threshold=3.0, distance=3, time=5, samples=True, separable=separable
+        )

Also applies to: 135-140

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

dascore/utils/moving.py (5)

57-57: Clean up naming and fix Ruff unused-variable warning

Rename the unpacked module_name to _ and disambiguate func_name to avoid confusion with _get_engine_function’s parameter name. No behavior change.

-    module_name, func_name = OPERATION_REGISTRY[operation]["scipy"]
+    _module_name, scipy_func_name = OPERATION_REGISTRY[operation]["scipy"]
     func = _get_engine_function("scipy", operation)
 
-    if func_name == "uniform_filter1d":
+    if scipy_func_name == "uniform_filter1d":
 ...
-    elif func_name == "median_filter":
+    elif scipy_func_name == "median_filter":

Also applies to: 61-61, 70-70

---

60-69: Cross‑engine boundary/NaN semantics diverge (document or align)

• SciPy path uses padding (eg, reflect) via uniform_filter1d; scaling by window yields a padded-window sum.
• Bottleneck uses sliding windows with min_count semantics and NaN‑aware reductions.
  Results can differ at the edges and in presence of NaNs. Either document this explicitly or add a boundary/min_count option at the top API and route it per engine for predictable behavior.

If you want, I can draft tests asserting expected cross‑engine behavior at boundaries and with NaNs.

Also applies to: 86-89

---

105-110: Return type annotation mismatch (tuple vs list)

Function returns a tuple; update the annotation to match to keep type checkers quiet.

-@cache
-def _get_available_engines() -> list[str]:
+@cache
+def _get_available_engines() -> tuple[str, ...]:
     """Get list of available engines (cached)."""
     bottle_list = [] if bn is None else ["bottleneck"]
     return tuple(["scipy", *bottle_list])

---

112-117: Cache engine function lookup and fix param naming

Name the param operation (it is not a function name) and cache the resolution. This also removes shadowing with local func_name elsewhere.

-def _get_engine_function(engine: str, func_name: str) -> Callable | None:
-    """Get and cache engine function."""
-    module_name, func_name = OPERATION_REGISTRY[func_name][engine]
+@cache
+def _get_engine_function(engine: str, operation: str) -> Callable:
+    """Get and cache engine function."""
+    module_name, func_name = OPERATION_REGISTRY[operation][engine]
     mod = _get_module(module_name)
     return getattr(mod, func_name)

---

174-186: Normalize operation case and validate/normalize axis

• Accept case‑insensitive operations.
• Raise ParameterError (not IndexError) on bad axis and normalize negatives.

     data = np.asarray(data)
     # Validate inputs
     if window <= 0:
         raise ParameterError("Window size must be positive")
-    if operation not in OPERATION_REGISTRY:
+    operation = operation.lower()
+    if operation not in OPERATION_REGISTRY:
         raise ParameterError(f"Unknown operation: {operation}")
-    if window > data.shape[axis]:
+    if not (-data.ndim <= axis < data.ndim):
+        raise ParameterError(
+            f"Axis {axis} is out of bounds for array with ndim={data.ndim}"
+        )
+    axis = axis % data.ndim
+    if window > data.shape[axis]:
         msg = (
             f"Window size ({window}) larger than data size ({data.shape[axis]}) "
             f"along axis {axis}"
         )
         raise ParameterError(msg)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

dascore/proc/hampel.py (2)

45-74: Minor alloc cuts in separable path (optional)

Preallocate a boolean mask and use np.copyto(where=…) to avoid temporary arrays/fancy indexing.

-    outlier_mask = abs_med_diff > threshold
-    dataf[outlier_mask] = med[outlier_mask]
+    # Preallocate mask once
+    mask = np.empty(dataf.shape, dtype=bool)
+    np.greater(abs_med_diff, threshold, out=mask)
+    # Copy only where needed
+    np.copyto(dataf, med, where=mask)

---

76-95: Avoid extra arrays in exact path; compute in-place

Saves two temporaries in hot path without changing behavior.

-    # Handle mad values of 0 so denominator doesn't blow up
-    mad_safe = np.where(mad == 0.0, np.finfo(dataf.dtype).eps, mad)
-
-    # Hampel test and replacement
-    thresholded = abs_med_diff / mad_safe
-
-    # Use in-place assignment for consistency
-    outlier_mask = thresholded > threshold
+    # Stabilize denominator in-place
+    eps = np.finfo(dataf.dtype).eps
+    mad[mad == 0.0] = eps
+    # Reuse abs_med_diff buffer
+    np.divide(abs_med_diff, mad, out=abs_med_diff)
+    outlier_mask = abs_med_diff > threshold
     dataf[outlier_mask] = med[outlier_mask]

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/test_utils/test_moving.py (4)

20-29: Stabilize test surface by avoiding internal registry import in parametrization

Importing OPERATION_REGISTRY couples tests to internal implementation and can shift test coverage unintentionally if new ops land (e.g., “std”). Prefer an explicit, curated list for this module’s scope.

-TEST_OPERATIONS = list(OPERATION_REGISTRY.keys())
+# Keep this list explicit to avoid accidental coverage drift when registry changes.
+TEST_OPERATIONS = ["median", "mean", "sum", "min", "max", "std"]

---

175-182: Rename test or docstring: it raises, not warns

The docstring says “warning,” but the test asserts a ParameterError. Align wording to avoid confusion.

-    """Test warning for window larger than data."""
+    """Test error for window larger than data."""

---

65-73: Guard interior slice for small windows and document behavior

Logic is fine; consider naming the half-window and add a brief comment for readability. No behavior change.

-        interior_slice = slice(window // 2, -window // 2 if window > 2 else None)
+        h = window // 2  # half-window; avoid edges where padding differs by engine
+        interior_slice = slice(h, -h if window > 2 else None)

---

179-182: Remove unreachable assertion inside raises block

The isinstance check never runs because moving_window raises. Drop it to keep the test tight.

-        with pytest.raises(ParameterError, match="larger than data size"):
-            result = moving_window(data, large_window, "median")
-            assert isinstance(result, np.ndarray)
+        with pytest.raises(ParameterError, match="larger than data size"):
+            moving_window(data, large_window, "median")

dascore/proc/hampel.py (3)

203-207: Prevent overflow on cast-back to narrow integer types

Round then clip to the target dtype’s bounds before astype to avoid wraparound.

-    if np.issubdtype(data.dtype, np.integer):
-        dataf = np.rint(dataf)
-    out = dataf.astype(data.dtype, copy=False)
+    if np.issubdtype(data.dtype, np.integer):
+        dataf = np.rint(dataf, out=dataf)
+        info = np.iinfo(data.dtype)
+        np.clip(dataf, info.min, info.max, out=dataf)
+    out = dataf.astype(data.dtype, copy=False)

---

84-93: Reduce allocations in exact path by mutating MAD in place

You can avoid creating mad_safe by fixing zeros in-place and dividing with out to reuse abs_med_diff.

-    mad_safe = np.where(mad == 0.0, np.finfo(dataf.dtype).eps, mad)
-    # Hampel test and replacement
-    thresholded = abs_med_diff / mad_safe
-    # Use in-place assignment for consistency
-    outlier_mask = thresholded > threshold
+    eps = np.finfo(dataf.dtype).eps
+    mad[mad == 0.0] = eps
+    # Reuse abs_med_diff buffer for thresholding
+    np.divide(abs_med_diff, mad, out=abs_med_diff)
+    outlier_mask = abs_med_diff > threshold

---

147-151: Doc nit: quantify performance claims and qualify with data shape/engine

If you have benchmark numbers, consider citing ranges (e.g., “~3–4x on 2D patches of shape … with bottleneck 1.3.x”). This helps set expectations.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/test_utils/test_moving.py (7)

9-18: Include move_std import to exercise std convenience path (gated by engine).

You’re testing all convenience funcs except std; import it so we can add a conditional test without breaking when Bottleneck isn’t installed.

 from dascore.utils.moving import (
     OPERATION_REGISTRY,
     _get_available_engines,
     move_max,
     move_mean,
     move_median,
     move_min,
+    move_std,
     move_sum,
     moving_window,
 )

---

136-147: Test move_std convenience function when Bottleneck is available.

Std is supported via the Bottleneck engine; add a gated check to cover this path and its equivalence to moving_window.

-    def test_convenience_functions(self, test_data):
+    def test_convenience_functions(self, test_data, available_engines):
         """Test that convenience functions work correctly."""
         data = test_data["1d"]
         window = 3
 
         for operation, func in TEST_CONVENIENCE_FUNCS.items():
             result = func(data, window)
             self._validate_basic_result(result, data)
 
             # Check equivalence with generic function
             expected = moving_window(data, window, operation)
             np.testing.assert_array_equal(result, expected)
+
+        # Also validate std where supported (Bottleneck)
+        if "bottleneck" in available_engines:
+            result_std = move_std(data, window, engine="bottleneck")
+            self._validate_basic_result(result_std, data)
+            expected_std = moving_window(data, window, "std", engine="bottleneck")
+            np.testing.assert_array_equal(result_std, expected_std)

---

42-64: Strengthen property check: assert identity sum == mean * window.

Inequality (sum ≥ mean) only holds for non-negative data; here we can make a stricter, window-aware identity to reduce false positives. Pass window into the helper and assert equality on finite positions.

-    def _test_finite_properties(self, results, data):
+    def _test_finite_properties(self, results, data, window):
         """Test mathematical properties of operations."""
         # Find where all results are finite
         all_finite = np.ones(len(data), dtype=bool)
         for result in results.values():
             all_finite &= np.isfinite(result)
 
         if not np.any(all_finite):
             return  # Skip if no finite values
 
         finite_indices = np.where(all_finite)[0]
 
         # Test properties only where values are finite
         mean_vals = results["mean"][finite_indices]
         sum_vals = results["sum"][finite_indices]
         min_vals = results["min"][finite_indices]
         max_vals = results["max"][finite_indices]
 
-        # Sum should be >= mean (for positive window size)
-        assert np.all(sum_vals >= mean_vals)
+        # Identity: sum equals mean * window
+        np.testing.assert_allclose(sum_vals, mean_vals * window, rtol=1e-12, atol=0.0)
         # Min should be <= max
         assert np.all(min_vals <= max_vals)

---

211-223: Propagate window to property helper.

Pass the window so the strengthened identity can be checked.

     def test_operation_properties(self, test_data):
         """Test mathematical properties of operations."""
         data = test_data["1d"]
         window = 3
 
         results = {}
         for operation in ["median", "mean", "sum", "min", "max"]:
             results[operation] = moving_window(data, window, operation)
 
-        # Test properties where both results are finite
-        self._test_finite_properties(results, data)
+        # Test properties where both results are finite
+        self._test_finite_properties(results, data, window)

---

175-181: Remove unreachable assertions inside pytest.raises context and align name.

Code after the raising call won’t execute; drop it. Optionally rename the test to “raises” for clarity.

     def test_large_window_warning(self, test_data):
         """Test warning for window larger than data."""
         data = test_data["1d"]
         large_window = len(data) + 1
         with pytest.raises(ParameterError, match="larger than data size"):
-            result = moving_window(data, large_window, "median")
-            assert isinstance(result, np.ndarray)
+            moving_window(data, large_window, "median")

---

170-174: Also assert the function returns a valid result when falling back after warn.

Capture the output and check shape to ensure the fallback engine path works.

     def test_unavailable_engine_warns(self, test_data):
         """Test unavailable engine warns."""
-        with pytest.warns(UserWarning, match="not available"):
-            moving_window(test_data["1d"], 3, "median", engine="invalid_engine")
+        with pytest.warns(UserWarning, match="not available"):
+            out = moving_window(test_data["1d"], 3, "median", engine="invalid_engine")
+        assert isinstance(out, np.ndarray)
+        assert out.shape == test_data["1d"].shape

---

115-135: Decouple skip logic from exception message text.

Relying on the substring “not available” is brittle; skip on any ParameterError here since inputs are otherwise valid.

-        except ParameterError as e:
-            if "not available" in str(e):
-                pytest.skip(f"Operation {operation} not available in {engine}")
-            else:
-                raise
+        except ParameterError as e:
+            pytest.skip(f"{operation} not supported on engine={engine}: {e}")

tests/test_core/test_spool.py (1)

178-194: Strengthen the test with a sanity check that duplicates exist on the dedup subset.

Add a quick pre-check so the test fails loudly if the fixture stops producing duplicates on the expected columns.

 def test_drop_duplicates_large_joined_dataframe(self, large_spool_with_duplicates):
     """Test that duplicates are removed when joined dataframe > 10 rows."""
     spool = large_spool_with_duplicates
+    # Sanity: duplicates must exist on the dedup subset to exercise the path.
+    df = spool.get_contents()
+    subset = [c for c in ("network", "station", "data_type", "tag") if c in df.columns]
+    assert subset, "Expected group columns not present in contents"
+    assert len(df) > 10, "Joined DataFrame must exceed threshold to hit dedup path"
+    assert df.duplicated(subset=subset).any(), (
+        "Fixture did not create duplicates on the dedup subset"
+    )

     # Access a patch to trigger _get_patches_from_index
     # This should execute the drop_duplicates code path when len(joined) > 10
     patch = spool[0]
     assert isinstance(patch, dc.Patch)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/test_clients/test_dirspool.py (2)

367-372: Strengthen assertions to validate dedup effectiveness, not just success.

Check the chunk spans the full time extent of the (potentially duplicated) contents.

 def test_chunk_redundant_index(self, directory_spool_redundant_index):
     """Ensure redundant indices are handled effectively with chunking"""
     spool = directory_spool_redundant_index.chunk(time=None)
     patch = spool[0]
     assert isinstance(patch, dc.Patch)
+    contents = directory_spool_redundant_index.get_contents()
+    assert patch.attrs.time_min == contents["time_min"].min()
+    assert patch.attrs.time_max == contents["time_max"].max()

---

71-84: Harden directory_spool_redundant_index fixture to avoid flakiness

• Exclude the index file (.dascore_index.h5) by globbing only *.hdf5 data files.
• Advance each file’s mtime explicitly with os.utime to guarantee duplicates on filesystems with coarse timestamp resolution.
• (Optional) set scope="module" to reduce per-test setup overhead.

Apply this diff:

+import os
 @pytest.fixture(scope="module")
 def directory_spool_redundant_index(random_spool, tmp_path_factory):
     """Force a spool to be indexed many times with same files."""
     path = Path(tmp_path_factory.mktemp("redundant_index_spool"))
     dascore.examples.spool_to_directory(random_spool, path, "dasdae")
     spool = dc.spool(path).update()

-    # Touch each file, re-index to saturate index with duplicates.
-    for _ in range(12):
-        for file_path in path.glob("*"):
-            file_path.touch()
-        spool = spool.update()
+    # Touch only data files, force monotonic mtime to create duplicates robustly.
+    for i in range(12):
+        for file_path in path.glob("*.hdf5"):
+            st = file_path.stat()
+            os.utime(file_path, (st.st_atime, st.st_mtime + i + 1))
+        spool = spool.update()
     return spool

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/test_utils/test_moving.py (6)

69-73: Make interior slicing robust; skip tiny/even-window edge cases

For consistent “interior” comparisons across engines, bail early for very small windows and use a symmetric slice without the special-case None. This avoids pulling edge-influenced values (e.g., for window == 2).

-        interior_slice = slice(window // 2, -window // 2 if window > 2 else None)
+        # Skip comparison for tiny windows where a stable interior is ill-defined.
+        if window < 3:
+            return
+        # Symmetric interior (works for odd/even windows and avoids edges)
+        interior_slice = slice(window // 2, -window // 2)

---

83-87: Avoid hard-coded value bounds; remove or derive from data

Asserting results lie in [-10, 10] is brittle and unrelated to input distribution or operation (e.g., “sum” scales with window). Either drop the guard or compute operation-aware bounds. Given you already compare relative means, the simplest fix is to remove this block.

-            # Check that both give reasonable results (within data range)
-            data_min, data_max = -10, 10  # Reasonable range
-            assert np.all((vals1 >= data_min) & (vals1 <= data_max))
-            assert np.all((vals2 >= data_min) & (vals2 <= data_max))
+            # Value-range guard removed; relative agreement is checked below.

---

21-30: Include std convenience check when Bottleneck is available

You already guard engine availability elsewhere; add std here to increase wrapper coverage.

 TEST_CONVENIENCE_FUNCS = {
     "median": move_median,
     "mean": move_mean,
     "sum": move_sum,
     "min": move_min,
     "max": move_max,
 }
+
+# Add std wrapper when bottleneck is available.
+if "bottleneck" in _get_available_engines():
+    TEST_CONVENIENCE_FUNCS["std"] = move_std

Also applies to: 137-149

---

43-65: Strengthen property test: relate sum and mean on interior

sum >= mean is weak and data-sign dependent. Prefer sum ≈ mean * window on interior indices to avoid edge effects. Pass window into the helper and assert allclose on the interior slice.

-    def _test_finite_properties(self, results, data):
+    def _test_finite_properties(self, results, data, window):
         """Test mathematical properties of operations."""
@@
-        # Sum should be >= mean (for positive window size)
-        assert np.all(sum_vals >= mean_vals)
+        # On interior indices, sum should equal mean * window (within tolerance).
+        left = window // 2
+        right = -window // 2
+        interior = slice(left, right if window >= 3 else None)
+        np.testing.assert_allclose(
+            sum_vals[interior], mean_vals[interior] * window, rtol=1e-6, atol=1e-12
+        )
         # Min should be <= max
         assert np.all(min_vals <= max_vals)

And update the call site:

-        self._test_finite_properties(results, data)
+        self._test_finite_properties(results, data, window)

Also applies to: 215-226

---

150-158: Broaden multi-axis coverage to more ops

Axis handling bugs often differ by op; consider parametrizing over a small set like median/mean/sum/min/max.

-        for axis in [0, 1]:
-            result = move_median(data, window, axis=axis)
-            assert result.shape == data.shape
+        for axis in [0, 1]:
+            for func in (move_median, move_mean, move_sum, move_min, move_max):
+                result = func(data, window, axis=axis)
+                assert result.shape == data.shape

---

208-213: Assert dtype promotion for integer inputs to mean

Mean over integer arrays should produce a floating dtype; assert it to catch regressions.

-            result = move_mean(data, 3)
-            assert isinstance(result, np.ndarray)
+            result = move_mean(data, 3)
+            assert isinstance(result, np.ndarray)
+            # Mean should promote to floating dtype for integer inputs.
+            assert result.dtype.kind == "f"

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/test_utils/test_moving.py (6)

45-45: Include unsigned integer dtype in basic result check

Some ops (min/max/sum) can return unsigned kinds for unsigned inputs. Accept "u" as well.

-        assert result.dtype.kind in ["f", "i", "c"]  # float, int, or complex
+        assert result.dtype.kind in ("f", "i", "u", "c")  # float, (u)int, or complex

---

147-154: Make skip condition robust to error-message wording

Relying only on "not available" is brittle. Broaden to common phrasings and lowercase once.

-        except ParameterError as e:
-            if "not available" in str(e):
-                pytest.skip(f"Operation {operation} not available in {engine}")
-            else:
-                raise
+        except ParameterError as e:
+            msg = str(e).lower()
+            if any(s in msg for s in ("not available", "unsupported", "unknown operation")):
+                pytest.skip(f"{operation} not supported by engine={engine}")
+            raise

---

169-178: Strengthen multi‑axis checks by asserting equivalence with generic API

Currently only shape is asserted. Compare values to moving_window for each op/axis.

-        for axis in [0, 1]:
-            for func in (move_median, move_mean, move_sum, move_min, move_max):
-                result = func(data, window, axis=axis)
-                assert result.shape == data.shape
+        for axis in [0, 1]:
+            for operation, func in TEST_CONVENIENCE_FUNCS.items():
+                result = func(data, window, axis=axis)
+                expected = moving_window(data, window, operation, axis=axis)
+                assert result.shape == data.shape
+                np.testing.assert_array_equal(result, expected)

---

191-197: Also verify fallback equivalence on invalid engine

After warning, ensure output matches the automatic engine selection.

     def test_unavailable_engine_warns(self, test_data):
         """Test unavailable engine warns."""
         with pytest.warns(UserWarning, match="not available"):
-            out = moving_window(test_data["1d"], 3, "median", engine="invalid_engine")
+            out = moving_window(test_data["1d"], 3, "median", engine="invalid_engine")
         # It should also return an array.
         assert isinstance(out, np.ndarray)
         assert out.shape == test_data["1d"].shape
+        # And it should be equivalent to the auto-selected engine.
+        expected = moving_window(test_data["1d"], 3, "median", engine="auto")
+        np.testing.assert_array_equal(out, expected)

---

288-295: Strengthen bottleneck std test: use constant data and check zeros

Shape-only assertion can miss regressions. Constant input should yield zeros.

     def test_bottleneck_std(self, test_data):
         """
         Ensure the bottleneck std works (current scipy engine doesnt have this).
         """
         pytest.importorskip("bottleneck")
-        out = move_std(test_data["1d"], 10, axis=0, engine="bottleneck")
-        assert out.shape == test_data["1d"].shape
+        data = test_data["constant"]
+        out = move_std(data, 3, axis=0, engine="bottleneck")
+        assert out.shape == data.shape
+        assert np.allclose(out, 0.0)

---

23-23: Optional: build TEST_ENGINES dynamically to avoid skip noise

Derive engines from runtime availability and append "auto".

-TEST_ENGINES = ["scipy", "bottleneck", "auto"]
+TEST_ENGINES = [*_get_available_engines(), "auto"]

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tests/test_utils/test_moving.py (7)

62-76: Unify “interior” indexing with the helper and widen valid region

Use the same symmetric interior definition as _compare_engine_results to avoid off‑by‑one inconsistencies and cover more valid samples.

-        if window >= 3 and len(data) >= window:
-            # True interior: start from window-1 to end-(window-1)
-            interior_start = window - 1
-            interior_end = len(data) - (window - 1)
-            if interior_end > interior_start:
-                interior_slice = slice(interior_start, interior_end)
+        if window >= 3 and len(data) >= window:
+            # Symmetric interior consistent with _compare_engine_results
+            interior_slice = slice(window // 2, len(data) - (window // 2))
+            if interior_slice.stop - interior_slice.start > 0:
                 interior_finite = all_finite[interior_slice]
                 if np.any(interior_finite):
                     mean_interior = mean_vals[interior_slice][interior_finite]
                     sum_interior = sum_vals[interior_slice][interior_finite]
                     np.testing.assert_allclose(
                         sum_interior, mean_interior * window, rtol=1e-6, atol=1e-12
                     )

---

151-154: Make engine-unavailable skip more robust to message phrasing

Avoid coupling to a single substring; handle common variants.

-        except ParameterError as e:
-            if "not available" in str(e):
-                pytest.skip(f"Operation {operation} not available in {engine}")
-            else:
-                raise
+        except ParameterError as e:
+            msg = str(e).lower()
+            if any(p in msg for p in ("not available", "unsupported", "unavailable")):
+                pytest.skip(f"Operation {operation} not available in {engine}")
+            else:
+                raise

---

191-197: Also assert behavior matches the auto-engine fallback

Strengthen this by verifying output equals the auto-selected engine result.

     def test_unavailable_engine_warns(self, test_data):
         """Test unavailable engine warns."""
         with pytest.warns(UserWarning, match="not available"):
             out = moving_window(test_data["1d"], 3, "median", engine="invalid_engine")
-        # It should also return an array.
-        assert isinstance(out, np.ndarray)
-        assert out.shape == test_data["1d"].shape
+        # It should also return an array and match auto-engine output.
+        assert isinstance(out, np.ndarray)
+        assert out.shape == test_data["1d"].shape
+        expected = moving_window(test_data["1d"], 3, "median", engine="auto")
+        np.testing.assert_array_equal(out, expected)

---

174-178: Parametrize axis (including negative) for clearer test matrix

Parametrization improves reporting and adds axis=-1 coverage.

-    def test_multi_axis_operations(self, test_data):
+    @pytest.mark.parametrize("axis", (0, 1, -1))
+    def test_multi_axis_operations(self, test_data, axis):
         """Test operations on different axes."""
         data = test_data["2d"]
         window = 2
-
-        for axis in [0, 1]:
-            for func in (move_median, move_mean, move_sum, move_min, move_max):
-                result = func(data, window, axis=axis)
-                assert result.shape == data.shape
+        for func in (move_median, move_mean, move_sum, move_min, move_max):
+            result = func(data, window, axis=axis)
+            assert result.shape == data.shape

---

276-283: Tighten cross‑engine agreement for additive ops on the interior

For mean/sum, engines should agree element‑wise on interior. Keep the existing lenient check, but add an allclose assert.

         for operation in operations_to_test:
             try:
                 result_scipy = moving_window(data, window, operation, engine="scipy")
                 result_bn = moving_window(data, window, operation, engine="bottleneck")
 
                 # Compare interior values (avoiding edge effects)
                 self._compare_engine_results(result_scipy, result_bn, window)
+                interior = slice(window // 2, -window // 2)
+                if operation in ("mean", "sum"):
+                    np.testing.assert_allclose(
+                        result_scipy[interior], result_bn[interior], rtol=1e-7, atol=1e-12
+                    )
 
             except ParameterError:
                 # Skip if operation not available in one engine
                 continue

---

228-236: Broaden dtype coverage and simplify promotion check

Include more integer types and assert promotion generically.

-        dtypes = [np.int32, np.float32, np.float64]
+        dtypes = [np.int32, np.int64, np.uint8, np.float32, np.float64]
         for dtype in dtypes:
             data = base_data.astype(dtype)
             result = move_mean(data, 3)
             assert isinstance(result, np.ndarray)
             # Mean should promote to floating dtype for integer inputs.
-            if dtype in [np.int32]:
-                assert result.dtype.kind == "f"
+            if np.issubdtype(dtype, np.integer):
+                assert result.dtype.kind == "f"

---

107-114: Lax engine‑comparison tolerance risks false negatives

Mean-of-interior with 50% tolerance may miss mismatches. The added per-element allclose (suggested in test_engine_consistency) will catch real divergences while keeping this guard if you want a coarse sanity check.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro