dascore/proc/basic.py (1)

111-125: Consider configurable tolerance and NaN handling for equals(close=True)

Optional, but adds control and aligns NaN treatment with attrs. Also safely falls back for non-numeric dtypes.

Apply:

-def equals(self: PatchType, other: Any, only_required_attrs=True, close=False) -> bool:
+def equals(
+    self: PatchType,
+    other: Any,
+    only_required_attrs=True,
+    close=False,
+    *,
+    rtol: float = 1e-08,
+    atol: float = 1e-08,
+    equal_nan: bool = False,
+) -> bool:
@@
-    close
-        If True, the data can be "close" using np.allclose, otherwise
-        all data must be equal.
+    close
+        If True, use a tolerance-based comparison for data.
+    rtol, atol
+        Relative and absolute tolerances passed to numpy.allclose.
+    equal_nan
+        If True, NaNs compare equal when close=True.
@@
-    if close and not np.allclose(self.data, other.data):
-        return False
-    elif not close and not np.equal(self.data, other.data).all():
-        return False
+    if close:
+        # Guard for non-numeric dtypes.
+        if np.issubdtype(self.data.dtype, np.number) and np.issubdtype(other.data.dtype, np.number):
+            if not np.allclose(self.data, other.data, rtol=rtol, atol=atol, equal_nan=equal_nan):
+                return False
+        else:
+            if not np.array_equal(self.data, other.data):
+                return False
+    else:
+        if not np.equal(self.data, other.data).all():
+            return False

Also applies to: 151-156

tests/test_core/test_coords.py (1)

752-757: Tighten the percentage-length assertion

Use an absolute tolerance of ~1 sample for evenly sampled coords.

-        if coord.evenly_sampled:
-            assert abs((len(out) / len(coord)) - 0.70) < len(coord) / 100.0
+        if coord.evenly_sampled:
+            import pytest
+            assert len(out) == pytest.approx(0.70 * len(coord), rel=0, abs=1)

tests/test_proc/test_taper.py (2)

43-49: Minor: preserve original time range when crafting uneven times

Optional: derive uneven, sorted times from the existing time coord to keep range/units comparable across tests.

Example (conceptual):

• take orig = patch.get_coord("time").values
• add small, cumulative jitter to orig in its native units
• sort, then update_coords(time=new_values)

---

143-147: Uneven-time taper smoke test

Covers the non-even sampling path; consider also asserting shape equality for completeness.

dascore/proc/taper.py (2)

30-35: Percent length calc now correct for uneven coords; one nit.

Using coord.coord_range(exact=False) fixes off-by-one for evenly sampled coords and enables percent semantics on irregular coords. Minor: consider including np.datetime64 in clses to avoid accidental scaling if absolute datetimes are ever passed.

-    clses = (Quantity, np.timedelta64)
+    clses = (Quantity, np.timedelta64, np.datetime64)

---

114-126: Micro: reuse window indexer.

window_inds is identical in both branches; compute once.

-    if samps[0] is not None:
+    window_inds = broadcast_for_index(n_dims, axis, slice(None), fill=None)
+    if samps[0] is not None:
         ...
-        window_inds = broadcast_for_index(n_dims, axis, slice(None), fill=None)
         out[data_inds] = out[data_inds] * window[window_inds]
     if samps[1] is not None:
         ...
-        window_inds = broadcast_for_index(n_dims, axis, slice(None), fill=None)
         out[data_inds] = out[data_inds] * window[window_inds]

dascore/utils/signal.py (2)

9-22: Window registry looks solid; consider making it immutable.

Freezing the mapping prevents accidental mutation at runtime.

+from types import MappingProxyType
 ...
-WINDOW_FUNCTIONS = dict(
+_WINDOW_FUNCTIONS = dict(
     barthann=windows.barthann,
     bartlett=windows.bartlett,
     blackman=windows.blackman,
     blackmanharris=windows.blackmanharris,
     bohman=windows.bohman,
     hamming=windows.hamming,
     hann=windows.hann,
     cos=windows.hann,
     nuttall=windows.nuttall,
     parzen=windows.parzen,
     triang=windows.triang,
     ramp=windows.triang,
 )
+WINDOW_FUNCTIONS = MappingProxyType(_WINDOW_FUNCTIONS)

---

25-35: Add type hints and tighten error message.

Minor ergonomics: hint the callable signature and list options as a comma-separated string.

-from dascore.exceptions import ParameterError
+from dascore.exceptions import ParameterError
+from collections.abc import Callable
+import numpy as np
 ...
-def _get_window_function(window_type):
+def _get_window_function(window_type: str) -> Callable[[int], np.ndarray]:
@@
-        msg = (
-            f"'{window_type}' is not a known window type. "
-            f"Options are: {sorted(WINDOW_FUNCTIONS)}"
-        )
+        opts = ", ".join(sorted(WINDOW_FUNCTIONS))
+        msg = f"'{window_type}' is not a known window type. Options are: {opts}"

dascore/core/coords.py (1)

618-624: Percent handling looks right; one edge-case to confirm.

If self.units is None and a non-percent Quantity is passed, convert_units will raise. Is that desired? If not, consider interpreting it as “set units” or raising ParameterError with a clearer message.

-            else:
-                value = convert_units(value.magnitude, self.units, value.units)
+            else:
+                if self.units is None:
+                    raise ParameterError("Coordinate has no units; cannot convert input.")
+                value = convert_units(mag, self.units, unit)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

dascore/proc/taper.py (1)

32-35: Percent Quantity handling may bypass scaling; confirm intended behavior.

20percent is a Quantity and will skip the dur scaling path here, relying on coord.select(relative=True) to interpret percent. Please confirm tests cover both float fractions (e.g., 0.1) and Quantity percents (e.g., 10percent) yielding identical indices. If not, normalize percent Quantities to absolute via the same dur used for floats.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

dascore/core/coords.py (1)

509-525: Fix inclusive range for reverse-sorted coords; tighten docs; improve error message.

• Use the magnitude of the step when extending the range so reverse-sorted coords don’t shrink the range.
• Correct “scaler” → “scalar”; “If true” → “If True”; grammar in the error message.

Apply this diff:

 def coord_range(self, extend: bool = True):
     """
-        Return a scaler value for the coordinate range (e.g., number of seconds).
+        Return a scalar value for the coordinate range (e.g., number of seconds).

         Parameters
         ----------
         extend
-            If true, count the end of the range as max() + sample step. This
-            can only work for evenly sampled coordinates.
+            If True, count the end of the range as max() + |step|.
+            This only works for evenly sampled coordinates.
     """
-    if not self.evenly_sampled and extend:
-        raise CoordError("coord_range has to be called on an evenly sampled data.")
+    if not self.evenly_sampled and extend:
+        raise CoordError("coord_range(extend=True) requires an evenly sampled coordinate.")
     coord_range = self.max() - self.min()
     if extend:
-        coord_range += self.step
+        coord_range += np.abs(self.step)
     return coord_range

tests/test_proc/test_correlate.py (1)

73-77: Typo in comment.

“autocorrection” → “autocorrelation”.

-        # normalize energy so autocorrection is 1
+        # normalize energy so autocorrelation is 1

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.