ezmsg-sigproc 1.7.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

ezmsg/sigproc/window.py

@@ -1,137 +1,178 @@
+import enum
 import traceback
 import typing
 
 import ezmsg.core as ez
-import numpy as np
 import numpy.typing as npt
+import sparse
+from array_api_compat import get_namespace, is_pydata_sparse_namespace
+from ezmsg.baseproc import (
+    BaseStatefulTransformer,
+    BaseTransformerUnit,
+    processor_state,
+)
 from ezmsg.util.messages.axisarray import (
     AxisArray,
+    replace,
     slice_along_axis,
     sliding_win_oneaxis,
-    replace,
 )
-from ezmsg.util.generator import consumer
 
-from .base import GenAxisArray
+from .util.profile import profile_subpub
+from .util.sparse import sliding_win_oneaxis as sparse_sliding_win_oneaxis
 
 
-@consumer
-def windowing(
-    axis: str | None = None,
-    newaxis: str = "win",
-    window_dur: float | None = None,
-    window_shift: float | None = None,
-    zero_pad_until: str = "input",
-) -> typing.Generator[AxisArray, AxisArray, None]:
-    """
-    Apply a sliding window along the specified axis to input streaming data.
-    The `windowing` method is perhaps the most useful and versatile method in ezmsg.sigproc, but its parameterization
-    can be difficult. Please read the argument descriptions carefully.
+class Anchor(enum.Enum):
+    BEGINNING = "beginning"
+    END = "end"
+    MIDDLE = "middle"
 
-    Args:
-        axis: The axis along which to segment windows.
-            If None, defaults to the first dimension of the first seen AxisArray.
-            Note: The windowed axis must be an AxisArray.LinearAxis, not an AxisArray.CoordinateAxis.
-        newaxis: New axis on which windows are delimited, immediately
-        preceding the target windowed axis. The data length along newaxis may be 0 if
-        this most recent push did not provide enough data for a new window.
-        If window_shift is None then the newaxis length will always be 1.
-        window_dur: The duration of the window in seconds.
-            If None, the function acts as a passthrough and all other parameters are ignored.
-        window_shift: The shift of the window in seconds.
-            If None (default), windowing operates in "1:1 mode", where each input yields exactly one most-recent window.
-        zero_pad_until: Determines how the function initializes the buffer.
-            Can be one of "input" (default), "full", "shift", or "none". If `window_shift` is None then this field is
-            ignored and "input" is always used.
-
-            - "input" (default) initializes the buffer with the input then prepends with zeros to the window size.
-              The first input will always yield at least one output.
-            - "shift" fills the buffer until `window_shift`.
-              No outputs will be yielded until at least `window_shift` data has been seen.
-            - "none" does not pad the buffer. No outputs will be yielded until at least `window_dur` data has been seen.
-
-    Returns:
-        A primed generator that accepts an :obj:`AxisArray` via `.send(axis_array)`
-        and yields an :obj:`AxisArray` with the data payload containing a windowed version of the input data.
-    """
-    # Check arguments
-    if newaxis is None:
-        ez.logger.warning("`newaxis` must not be None. Setting to 'win'.")
-        newaxis = "win"
-    if window_shift is None and zero_pad_until != "input":
-        ez.logger.warning(
-            "`zero_pad_until` must be 'input' if `window_shift` is None. "
-            f"Ignoring received argument value: {zero_pad_until}"
-        )
-        zero_pad_until = "input"
-    elif window_shift is not None and zero_pad_until == "input":
-        ez.logger.warning(
-            "windowing is non-deterministic with `zero_pad_until='input'` as it depends on the size "
-            "of the first input. We recommend using 'shift' when `window_shift` is float-valued."
-        )
-    msg_out = AxisArray(np.array([]), dims=[""])
 
-    # State variables
-    buffer: npt.NDArray | None = None
+class WindowSettings(ez.Settings):
+    axis: str | None = None
+    newaxis: str | None = None  # new axis for output. No new axes if None
+    window_dur: float | None = None  # Sec. passthrough if None
+    window_shift: float | None = None  # Sec. Use "1:1 mode" if None
+    zero_pad_until: str = "full"  # "full", "shift", "input", "none"
+    anchor: str | Anchor = Anchor.BEGINNING
+
+
+@processor_state
+class WindowState:
+    buffer: npt.NDArray | sparse.SparseArray | None = None
+
     window_samples: int | None = None
+
     window_shift_samples: int | None = None
-    # Number of incoming samples to ignore. Only relevant when shift > window.:
+
     shift_deficit: int = 0
-    b_1to1 = window_shift is None
-    newaxis_warned: bool = b_1to1
+    """ Number of incoming samples to ignore. Only relevant when shift > window."""
+
+    newaxis_warned: bool = False
+
     out_newaxis: AxisArray.LinearAxis | None = None
+
     out_dims: list[str] | None = None
 
-    check_inputs = {"samp_shape": None, "fs": None, "key": None}
 
-    while True:
-        msg_in: AxisArray = yield msg_out
+class WindowTransformer(BaseStatefulTransformer[WindowSettings, AxisArray, AxisArray, WindowState]):
+    """
+    Apply a sliding window along the specified axis to input streaming data.
+    The `windowing` method is perhaps the most useful and versatile method in ezmsg.sigproc, but its parameterization
+    can be difficult. Please read the argument descriptions carefully.
+    """
 
-        if window_dur is None:
-            msg_out = msg_in
-            continue
+    def __init__(self, *args, **kwargs) -> None:
+        """
+
+        Args:
+            axis: The axis along which to segment windows.
+                If None, defaults to the first dimension of the first seen AxisArray.
+                Note: The windowed axis must be an AxisArray.LinearAxis, not an AxisArray.CoordinateAxis.
+            newaxis: New axis on which windows are delimited, immediately
+                preceding the target windowed axis. The data length along newaxis may be 0 if
+                this most recent push did not provide enough data for a new window.
+                If window_shift is None then the newaxis length will always be 1.
+            window_dur: The duration of the window in seconds.
+                If None, the function acts as a passthrough and all other parameters are ignored.
+            window_shift: The shift of the window in seconds.
+                If None (default), windowing operates in "1:1 mode",
+                where each input yields exactly one most-recent window.
+            zero_pad_until: Determines how the function initializes the buffer.
+                Can be one of "input" (default), "full", "shift", or "none".
+                If `window_shift` is None then this field is ignored and "input" is always used.
+
+                - "input" (default) initializes the buffer with the input then prepends with zeros to the window size.
+                  The first input will always yield at least one output.
+                - "shift" fills the buffer until `window_shift`.
+                  No outputs will be yielded until at least `window_shift` data has been seen.
+                - "none" does not pad the buffer. No outputs will be yielded until
+                  at least `window_dur` data has been seen.
+            anchor: Determines the entry in `axis` that gets assigned `0`, which references the
+                value in `newaxis`. Can be of class :obj:`Anchor` or a string representation of an :obj:`Anchor`.
+        """
+        super().__init__(*args, **kwargs)
+
+        # Sanity-check settings
+        # if self.settings.newaxis is None:
+        #     ez.logger.warning("`newaxis=None` will be replaced with `newaxis='win'`.")
+        #     object.__setattr__(self.settings, "newaxis", "win")
+        if self.settings.window_shift is None and self.settings.zero_pad_until != "input":
+            ez.logger.warning(
+                "`zero_pad_until` must be 'input' if `window_shift` is None. "
+                f"Ignoring received argument value: {self.settings.zero_pad_until}"
+            )
+            object.__setattr__(self.settings, "zero_pad_until", "input")
+        elif self.settings.window_shift is not None and self.settings.zero_pad_until == "input":
+            ez.logger.warning(
+                "windowing is non-deterministic with `zero_pad_until='input'` as it depends on the size "
+                "of the first input. We recommend using `zero_pad_until='shift'` when `window_shift` is float-valued."
+            )
+        try:
+            object.__setattr__(self.settings, "anchor", Anchor(self.settings.anchor))
+        except ValueError:
+            raise ValueError(
+                f"Invalid anchor: {self.settings.anchor}. Valid anchor are: {', '.join([e.value for e in Anchor])}"
+            )
 
-        axis = axis or msg_in.dims[0]
-        axis_idx = msg_in.get_axis_idx(axis)
-        axis_info = msg_in.get_axis(axis)
+    def _hash_message(self, message: AxisArray) -> int:
+        axis = self.settings.axis or message.dims[0]
+        axis_idx = message.get_axis_idx(axis)
+        axis_info = message.get_axis(axis)
         fs = 1.0 / axis_info.gain
+        samp_shape = message.data.shape[:axis_idx] + message.data.shape[axis_idx + 1 :]
 
-        if not newaxis_warned and newaxis in msg_in.dims:
-            ez.logger.warning(
-                f"newaxis {newaxis} present in input dims. Using {newaxis}_win instead"
-            )
-            newaxis_warned = True
-            newaxis = f"{newaxis}_win"
-
-        samp_shape = msg_in.data.shape[:axis_idx] + msg_in.data.shape[axis_idx + 1 :]
-
-        # If buffer unset or input stats changed, create a new buffer
-        b_reset = buffer is None
-        b_reset = b_reset or samp_shape != check_inputs["samp_shape"]
-        b_reset = b_reset or fs != check_inputs["fs"]
-        b_reset = b_reset or msg_in.key != check_inputs["key"]
-        if b_reset:
-            # Update check variables
-            check_inputs["samp_shape"] = samp_shape
-            check_inputs["fs"] = fs
-            check_inputs["key"] = msg_in.key
-
-            window_samples = int(window_dur * fs)
-            if not b_1to1:
-                window_shift_samples = int(window_shift * fs)
-            if zero_pad_until == "none":
-                req_samples = window_samples
-            elif zero_pad_until == "shift" and not b_1to1:
-                req_samples = window_shift_samples
-            else:  # i.e. zero_pad_until == "input"
-                req_samples = msg_in.data.shape[axis_idx]
-            n_zero = max(0, window_samples - req_samples)
-            init_buffer_shape = (
-                msg_in.data.shape[:axis_idx]
-                + (n_zero,)
-                + msg_in.data.shape[axis_idx + 1 :]
+        return hash(samp_shape + (fs, message.key))
+
+    def _reset_state(self, message: AxisArray) -> None:
+        _newaxis = self.settings.newaxis or "win"
+        if not self._state.newaxis_warned and _newaxis in message.dims:
+            ez.logger.warning(f"newaxis {_newaxis} present in input dims. Using {_newaxis}_win instead")
+            self._state.newaxis_warned = True
+            self.settings.newaxis = f"{_newaxis}_win"
+
+        axis = self.settings.axis or message.dims[0]
+        axis_idx = message.get_axis_idx(axis)
+        axis_info = message.get_axis(axis)
+        fs = 1.0 / axis_info.gain
+
+        xp = get_namespace(message.data)
+
+        self._state.window_samples = int(self.settings.window_dur * fs)
+        if self.settings.window_shift is not None:
+            # If window_shift is None, we are in "1:1 mode" and window_shift_samples is not used.
+            self._state.window_shift_samples = int(self.settings.window_shift * fs)
+        if self.settings.zero_pad_until == "none":
+            req_samples = self._state.window_samples
+        elif self.settings.zero_pad_until == "shift" and self.settings.window_shift is not None:
+            req_samples = self._state.window_shift_samples
+        else:  # i.e. zero_pad_until == "input"
+            req_samples = message.data.shape[axis_idx]
+        n_zero = max(0, self._state.window_samples - req_samples)
+        init_buffer_shape = message.data.shape[:axis_idx] + (n_zero,) + message.data.shape[axis_idx + 1 :]
+        self._state.buffer = xp.zeros(init_buffer_shape, dtype=message.data.dtype)
+
+        # Prepare reusable parts of output
+        if self._state.out_newaxis is None:
+            self._state.out_dims = list(message.dims[:axis_idx]) + [_newaxis] + list(message.dims[axis_idx:])
+            self._state.out_newaxis = replace(
+                axis_info,
+                gain=0.0 if self.settings.window_shift is None else axis_info.gain * self._state.window_shift_samples,
+                offset=0.0,  # offset modified per-msg below
             )
-            buffer = np.zeros(init_buffer_shape, dtype=msg_in.data.dtype)
+
+    def __call__(self, message: AxisArray) -> AxisArray:
+        if self.settings.window_dur is None:
+            # Shortcut for no windowing
+            return message
+        return super().__call__(message)
+
+    def _process(self, message: AxisArray) -> AxisArray:
+        axis = self.settings.axis or message.dims[0]
+        axis_idx = message.get_axis_idx(axis)
+        axis_info = message.get_axis(axis)
+
+        xp = get_namespace(message.data)
 
         # Add new data to buffer.
         # Currently, we concatenate the new time samples and clip the output.
@@ -140,151 +181,148 @@ def windowing(
         # is generally faster than np.roll and slicing anyway, but this could still
         # be a performance bottleneck for large memory arrays.
         # A circular buffer might be faster.
-        buffer = np.concatenate((buffer, msg_in.data), axis=axis_idx)
+        self._state.buffer = xp.concatenate((self._state.buffer, message.data), axis=axis_idx)
 
         # Create a vector of buffer timestamps to track axis `offset` in output(s)
-        buffer_offset = np.arange(buffer.shape[axis_idx]).astype(float)
-        # Adjust so first _new_ sample at index 0
-        buffer_offset -= buffer_offset[-msg_in.data.shape[axis_idx]]
+        buffer_t0 = 0.0
+        buffer_tlen = self._state.buffer.shape[axis_idx]
+
+        # Adjust so first _new_ sample at index 0.
+        buffer_t0 -= self._state.buffer.shape[axis_idx] - message.data.shape[axis_idx]
+
         # Convert form indices to 'units' (probably seconds).
-        buffer_offset *= axis_info.gain
-        buffer_offset += axis_info.offset
+        buffer_t0 *= axis_info.gain
+        buffer_t0 += axis_info.offset
 
-        if not b_1to1 and shift_deficit > 0:
-            n_skip = min(buffer.shape[axis_idx], shift_deficit)
+        if self.settings.window_shift is not None and self._state.shift_deficit > 0:
+            n_skip = min(self._state.buffer.shape[axis_idx], self._state.shift_deficit)
             if n_skip > 0:
-                buffer = slice_along_axis(buffer, slice(n_skip, None), axis_idx)
-                buffer_offset = buffer_offset[n_skip:]
-                shift_deficit -= n_skip
-
-        # Prepare reusable parts of output
-        if out_newaxis is None:
-            out_dims = msg_in.dims[:axis_idx] + [newaxis] + msg_in.dims[axis_idx:]
-            out_newaxis = replace(
-                axis_info,
-                gain=0.0 if b_1to1 else axis_info.gain * window_shift_samples,
-                offset=0.0,  # offset modified per-msg below
-            )
+                self._state.buffer = slice_along_axis(self._state.buffer, slice(n_skip, None), axis_idx)
+                buffer_t0 += n_skip * axis_info.gain
+                buffer_tlen -= n_skip
+                self._state.shift_deficit -= n_skip
 
         # Generate outputs.
         # Preliminary copy of axes without the axes that we are modifying.
-        out_axes = {k: v for k, v in msg_in.axes.items() if k not in [newaxis, axis]}
+        _newaxis = self.settings.newaxis or "win"
+        out_axes = {k: v for k, v in message.axes.items() if k not in [_newaxis, axis]}
 
         # Update targeted (windowed) axis so that its offset is relative to the new axis
-        # TODO: If we have `anchor_newest=True` then offset should be -win_dur
-        out_axes[axis] = replace(axis_info, offset=0.0)
+        if self.settings.anchor == Anchor.BEGINNING:
+            out_axes[axis] = replace(axis_info, offset=0.0)
+        elif self.settings.anchor == Anchor.END:
+            out_axes[axis] = replace(axis_info, offset=-self.settings.window_dur)
+        elif self.settings.anchor == Anchor.MIDDLE:
+            out_axes[axis] = replace(axis_info, offset=-self.settings.window_dur / 2)
 
         # How we update .data and .axes[newaxis] depends on the windowing mode.
-        if b_1to1:
+        if self.settings.window_shift is None:
             # one-to-one mode -- Each send yields exactly one window containing only the most recent samples.
-            buffer = slice_along_axis(buffer, slice(-window_samples, None), axis_idx)
-            out_dat = buffer.reshape(
-                buffer.shape[:axis_idx] + (1,) + buffer.shape[axis_idx:]
+            self._state.buffer = slice_along_axis(
+                self._state.buffer, slice(-self._state.window_samples, None), axis_idx
+            )
+            out_dat = self._state.buffer.reshape(
+                self._state.buffer.shape[:axis_idx] + (1,) + self._state.buffer.shape[axis_idx:]
             )
-            out_newaxis = replace(out_newaxis, offset=buffer_offset[-window_samples])
-        elif buffer.shape[axis_idx] >= window_samples:
+            win_offset = buffer_t0 + axis_info.gain * (buffer_tlen - self._state.window_samples)
+        elif self._state.buffer.shape[axis_idx] >= self._state.window_samples:
             # Deterministic window shifts.
-            # Note: After https://github.com/ezmsg-org/ezmsg/pull/152, add `window_shift_samples` as the last arg
-            #  to `sliding_win_oneaxis` and remove the call to `slice_along_axis`.
-            out_dat = sliding_win_oneaxis(buffer, window_samples, axis_idx)
-            out_dat = slice_along_axis(
-                out_dat, slice(None, None, window_shift_samples), axis_idx
+            sliding_win_fun = sparse_sliding_win_oneaxis if is_pydata_sparse_namespace(xp) else sliding_win_oneaxis
+            out_dat = sliding_win_fun(
+                self._state.buffer,
+                self._state.window_samples,
+                axis_idx,
+                step=self._state.window_shift_samples,
             )
-            offset_view = sliding_win_oneaxis(buffer_offset, window_samples, 0)[
-                ::window_shift_samples
-            ]
-            out_newaxis = replace(out_newaxis, offset=offset_view[0, 0])
+            win_offset = buffer_t0
 
             # Drop expired beginning of buffer and update shift_deficit
-            multi_shift = window_shift_samples * out_dat.shape[axis_idx]
-            shift_deficit = max(0, multi_shift - buffer.shape[axis_idx])
-            buffer = slice_along_axis(buffer, slice(multi_shift, None), axis_idx)
+            multi_shift = self._state.window_shift_samples * out_dat.shape[axis_idx]
+            self._state.shift_deficit = max(0, multi_shift - self._state.buffer.shape[axis_idx])
+            self._state.buffer = slice_along_axis(self._state.buffer, slice(multi_shift, None), axis_idx)
         else:
             # Not enough data to make a new window. Return empty data.
             empty_data_shape = (
-                msg_in.data.shape[:axis_idx]
-                + (0, window_samples)
-                + msg_in.data.shape[axis_idx + 1 :]
+                message.data.shape[:axis_idx] + (0, self._state.window_samples) + message.data.shape[axis_idx + 1 :]
             )
-            out_dat = np.zeros(empty_data_shape, dtype=msg_in.data.dtype)
+            out_dat = xp.zeros(empty_data_shape, dtype=message.data.dtype)
             # out_newaxis will have first timestamp in input... but mostly meaningless because output is size-zero.
-            out_newaxis = replace(out_newaxis, offset=axis_info.offset)
+            win_offset = axis_info.offset
+
+        if self.settings.anchor == Anchor.END:
+            win_offset += self.settings.window_dur
+        elif self.settings.anchor == Anchor.MIDDLE:
+            win_offset += self.settings.window_dur / 2
+        self._state.out_newaxis = replace(self._state.out_newaxis, offset=win_offset)
 
         msg_out = replace(
-            msg_in, data=out_dat, dims=out_dims, axes={**out_axes, newaxis: out_newaxis}
+            message,
+            data=out_dat,
+            dims=self._state.out_dims,
+            axes={**out_axes, _newaxis: self._state.out_newaxis},
         )
+        return msg_out
 
 
-class WindowSettings(ez.Settings):
-    axis: str | None = None
-    newaxis: str | None = None  # new axis for output. No new axes if None
-    window_dur: float | None = None  # Sec. passthrough if None
-    window_shift: float | None = None  # Sec. Use "1:1 mode" if None
-    zero_pad_until: str = "full"  # "full", "shift", "input", "none"
-
-
-class WindowState(ez.State):
-    cur_settings: WindowSettings
-    gen: typing.Generator
-
-
-class Window(GenAxisArray):
-    """:obj:`Unit` for :obj:`bandpower`."""
-
+class Window(BaseTransformerUnit[WindowSettings, AxisArray, AxisArray, WindowTransformer]):
     SETTINGS = WindowSettings
-
     INPUT_SIGNAL = ez.InputStream(AxisArray)
     OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
 
-    def construct_generator(self):
-        self.STATE.gen = windowing(
-            axis=self.SETTINGS.axis,
-            newaxis=self.SETTINGS.newaxis,
-            window_dur=self.SETTINGS.window_dur,
-            window_shift=self.SETTINGS.window_shift,
-            zero_pad_until=self.SETTINGS.zero_pad_until,
-        )
-
     @ez.subscriber(INPUT_SIGNAL, zero_copy=True)
     @ez.publisher(OUTPUT_SIGNAL)
-    async def on_signal(self, msg: AxisArray) -> typing.AsyncGenerator:
+    @profile_subpub(trace_oldest=False)
+    async def on_signal(self, message: AxisArray) -> typing.AsyncGenerator:
+        """
+        override superclass on_signal so we can opt to yield once or multiple times after dropping the win axis.
+        """
+        # TODO: The transfomer overwrites settings.newaxis from None to "win",
+        #  then we no longer know if the user wants to trim out the newaxis from the unit.
+        xp = get_namespace(message.data)
         try:
-            out_msg = self.STATE.gen.send(msg)
-            if out_msg.data.size > 0:
-                if (
-                    self.SETTINGS.newaxis is not None
-                    or self.SETTINGS.window_dur is None
-                ):
+            ret = self.processor(message)
+            if ret.data.size > 0:
+                if self.SETTINGS.newaxis is not None or self.SETTINGS.window_dur is None:
                     # Multi-win mode or pass-through mode.
-                    yield self.OUTPUT_SIGNAL, out_msg
+                    yield self.OUTPUT_SIGNAL, ret
                 else:
                     # We need to split out_msg into multiple yields, dropping newaxis.
-                    axis_idx = out_msg.get_axis_idx("win")
-                    win_axis = out_msg.axes["win"]
-                    offsets = (
-                        np.arange(out_msg.data.shape[axis_idx]) * win_axis.gain
-                        + win_axis.offset
-                    )
-                    for msg_ix in range(out_msg.data.shape[axis_idx]):
+                    axis_idx = ret.get_axis_idx("win")
+                    win_axis = ret.axes["win"]
+                    offsets = win_axis.value(xp.asarray(range(ret.data.shape[axis_idx])))
+                    for msg_ix in range(ret.data.shape[axis_idx]):
                         # Need to drop 'win' and replace self.SETTINGS.axis from axes.
                         _out_axes = {
-                            **{
-                                k: v
-                                for k, v in out_msg.axes.items()
-                                if k not in ["win", self.SETTINGS.axis]
-                            },
-                            self.SETTINGS.axis: replace(
-                                out_msg.axes[self.SETTINGS.axis], offset=offsets[msg_ix]
-                            ),
+                            **{k: v for k, v in ret.axes.items() if k not in ["win", self.SETTINGS.axis]},
+                            self.SETTINGS.axis: replace(ret.axes[self.SETTINGS.axis], offset=offsets[msg_ix]),
                         }
-                        _out_msg = replace(
-                            out_msg,
-                            data=slice_along_axis(out_msg.data, msg_ix, axis_idx),
-                            dims=out_msg.dims[:axis_idx] + out_msg.dims[axis_idx + 1 :],
+                        _ret = replace(
+                            ret,
+                            data=slice_along_axis(ret.data, msg_ix, axis_idx),
+                            dims=ret.dims[:axis_idx] + ret.dims[axis_idx + 1 :],
                             axes=_out_axes,
                         )
-                        yield self.OUTPUT_SIGNAL, _out_msg
-        except (StopIteration, GeneratorExit):
-            ez.logger.debug(f"Window closed in {self.address}")
+                        yield self.OUTPUT_SIGNAL, _ret
+
         except Exception:
             ez.logger.info(traceback.format_exc())
+
+
+def windowing(
+    axis: str | None = None,
+    newaxis: str | None = None,
+    window_dur: float | None = None,
+    window_shift: float | None = None,
+    zero_pad_until: str = "full",
+    anchor: str | Anchor = Anchor.BEGINNING,
+) -> WindowTransformer:
+    return WindowTransformer(
+        WindowSettings(
+            axis=axis,
+            newaxis=newaxis,
+            window_dur=window_dur,
+            window_shift=window_shift,
+            zero_pad_until=zero_pad_until,
+            anchor=anchor,
+        )
+    )

ezmsg_sigproc-2.10.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ezmsg-sigproc
+Version: 2.10.0
+Summary: Timeseries signal processing implementations in ezmsg
+Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>, Kyle McGraw <kmcgraw@blackrockneuro.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10.15
+Requires-Dist: array-api-compat>=1.11.1
+Requires-Dist: ezmsg-baseproc>=1.1.0
+Requires-Dist: ezmsg>=3.6.0
+Requires-Dist: numba>=0.61.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pywavelets>=1.6.0
+Requires-Dist: scipy>=1.13.1
+Requires-Dist: sparse>=0.15.4
+Description-Content-Type: text/markdown
+
+# ezmsg-sigproc
+
+Signal processing primitives for the [ezmsg](https://www.ezmsg.org) message-passing framework.
+
+## Features
+
+* **Filtering** - Chebyshev, comb filters, and more
+* **Spectral analysis** - Spectrogram, spectrum, and wavelet transforms
+* **Resampling** - Downsample, decimate, and resample operations
+* **Windowing** - Sliding windows and buffering utilities
+* **Math operations** - Arithmetic, log, abs, difference, and more
+* **Signal generation** - Synthetic signal generators
+
+All modules use `AxisArray` as the primary data structure for passing signals between components.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install ezmsg-sigproc
+```
+
+Or install from GitHub for the latest development version:
+
+```bash
+pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev
+```
+
+## Documentation
+
+Full documentation is available at [ezmsg.org](https://www.ezmsg.org).
+
+## Development
+
+We use [`uv`](https://docs.astral.sh/uv/) for development.
+
+1. Fork and clone the repository
+2. `uv sync` to create a virtual environment and install dependencies
+3. `uv run pre-commit install` to set up linting and formatting hooks
+4. `uv run pytest tests` to run the test suite
+5. Submit a PR against the `dev` branch