ezmsg-sigproc 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

ezmsg/sigproc/window.py

@@ -3,19 +3,23 @@ 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 is_pydata_sparse_namespace, get_namespace
 from ezmsg.util.messages.axisarray import (
     AxisArray,
     slice_along_axis,
     sliding_win_oneaxis,
     replace,
 )
-from ezmsg.util.generator import consumer
 
-from .base import GenAxisArray
+from .base import (
+    BaseStatefulTransformer,
+    BaseTransformerUnit,
+    processor_state,
+)
 from .util.sparse import sliding_win_oneaxis as sparse_sliding_win_oneaxis
+from .util.profile import profile_subpub
 
 
 class Anchor(enum.Enum):
@@ -24,142 +28,174 @@ class Anchor(enum.Enum):
     MIDDLE = "middle"
 
 
-@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",
-    anchor: str | Anchor = Anchor.BEGINNING,
-) -> 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.
-
-    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`.
-
-    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."
-        )
-    try:
-        anchor = Anchor(anchor)
-    except ValueError:
-        raise ValueError(f"Invalid anchor: {anchor}. Valid anchor are: {', '.join([e.value for e in Anchor])}")
+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
 
-    msg_out = AxisArray(np.array([]), dims=[""])
 
-    # State variables
+@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}
-    concat_fun = np.concatenate
-    sliding_win_fun = sliding_win_oneaxis
 
-    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 :]
+
+        return hash(samp_shape + (fs, message.key))
 
-        if not newaxis_warned and newaxis in msg_in.dims:
+    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"
+                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
-
-            if isinstance(msg_in.data, sparse.SparseArray):
-                concat_fun = sparse.concatenate
-                sliding_win_fun = sparse_sliding_win_oneaxis
-                zero_fun = sparse.zeros
-            else:
-                concat_fun = np.concatenate
-                sliding_win_fun = sliding_win_oneaxis  # Requires updated signature in ezmsg dev.
-                zero_fun = np.zeros
-
-            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 :]
+            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 = zero_fun(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.
@@ -168,155 +204,177 @@ 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 = concat_fun((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_tvec = np.arange(buffer.shape[axis_idx]).astype(float)
+        buffer_tvec = xp.asarray(range(self._state.buffer.shape[axis_idx]), dtype=float)
+
         # Adjust so first _new_ sample at index 0.
-        buffer_tvec -= buffer_tvec[-msg_in.data.shape[axis_idx]]
+        buffer_tvec -= buffer_tvec[-message.data.shape[axis_idx]]
         # Convert form indices to 'units' (probably seconds).
         buffer_tvec *= axis_info.gain
         buffer_tvec += 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)
+                self._state.buffer = slice_along_axis(
+                    self._state.buffer, slice(n_skip, None), axis_idx
+                )
                 buffer_tvec = buffer_tvec[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.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
-        if anchor == Anchor.BEGINNING:
+        if self.settings.anchor == Anchor.BEGINNING:
             out_axes[axis] = replace(axis_info, offset=0.0)
-        elif anchor == Anchor.END:
-            out_axes[axis] = replace(axis_info, offset=-window_dur)
-        elif anchor == Anchor.MIDDLE:
-            out_axes[axis] = replace(axis_info, offset=-window_dur / 2)
+        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
             )
-            win_offset = buffer_tvec[-window_samples]
-        elif buffer.shape[axis_idx] >= window_samples:
+            out_dat = self._state.buffer.reshape(
+                self._state.buffer.shape[:axis_idx]
+                + (1,)
+                + self._state.buffer.shape[axis_idx:]
+            )
+            win_offset = buffer_tvec[-self._state.window_samples]
+        elif self._state.buffer.shape[axis_idx] >= self._state.window_samples:
             # Deterministic window shifts.
-            out_dat = sliding_win_fun(buffer, window_samples, axis_idx, step=window_shift_samples)
-            offset_view = sliding_win_oneaxis(buffer_tvec, window_samples, 0)[
-                ::window_shift_samples
+            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_fun(buffer_tvec, self._state.window_samples, 0)[
+                :: self._state.window_shift_samples
             ]
             win_offset = offset_view[0, 0]
 
             # 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.
             win_offset = axis_info.offset
 
-        if anchor == Anchor.END:
-            win_offset += window_dur
-        elif anchor == Anchor.MIDDLE:
-            win_offset += window_dur / 2
-        out_newaxis = replace(out_newaxis, offset=win_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"
-    anchor: str | Anchor = Anchor.BEGINNING
-
-
-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,
-            anchor=self.SETTINGS.anchor,
-        )
-
     @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:
+            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 = win_axis.value(np.arange(out_msg.data.shape[axis_idx]))
-                    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()
+                                for k, v in ret.axes.items()
                                 if k not in ["win", self.SETTINGS.axis]
                             },
                             self.SETTINGS.axis: replace(
-                                out_msg.axes[self.SETTINGS.axis], offset=offsets[msg_ix]
+                                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-1.8.2.dist-info → ezmsg_sigproc-2.0.0.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 1.8.2
+Version: 2.0.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>
 License-Expression: MIT
 License-File: LICENSE.txt
 Requires-Python: >=3.10.15
+Requires-Dist: array-api-compat>=1.11.1
 Requires-Dist: ezmsg>=3.6.0
 Requires-Dist: numba>=0.61.0
 Requires-Dist: numpy>=1.26.0

ezmsg_sigproc-2.0.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
+ezmsg/sigproc/__version__.py,sha256=2thmcF9DS_Zp1zHI3N0kjBeMAuCP9mdDGnL0clqQpS8,511
+ezmsg/sigproc/activation.py,sha256=qWAhpbFBxSoqbGy4P9JKE5LY-5v8rQI1U81OvNxBG2Y,2820
+ezmsg/sigproc/adaptive_lattice_notch.py,sha256=3M65PrZpdgBlQtE7Ph4Gu2ISIyWw4j8Xxhm5PpSkLFw,9102
+ezmsg/sigproc/affinetransform.py,sha256=WU495KoDKZfHPS3Dumh65rgf639koNlfDIx_torIByg,8662
+ezmsg/sigproc/aggregate.py,sha256=sdVzSXDg9BUNT-ljyvrWLeoZtRTlfisP0OxEchbgyMM,6111
+ezmsg/sigproc/bandpower.py,sha256=N9pDz1X6ZTNP6VpCcfoXhj32j_9KpMaMuVYimoS6Jpc,2083
+ezmsg/sigproc/base.py,sha256=PQr03O2P1v9LzcSR0GJLvPpBCLtnmGaz76gUeXphcH4,48753
+ezmsg/sigproc/butterworthfilter.py,sha256=7ZP4CRsXBt3-5dzyUjD45vc0J3Fhpm4CLrk-ps28jhc,5305
+ezmsg/sigproc/cheby.py,sha256=-aSauAwxJmmSSiRaw5qGY9rvYFOmk1bZlS4gGrS0jls,3737
+ezmsg/sigproc/combfilter.py,sha256=5UCfzGESpS5LSx6rxZv8_n25ZUvOOmws-mM_gpTZNhU,4777
+ezmsg/sigproc/decimate.py,sha256=Lz46fBllWagu17QeQzgklm6GWCV-zPysiydiby2IElU,2347
+ezmsg/sigproc/detrend.py,sha256=7bpjFKdk2b6FdVn2GEtMbWtCuk7ToeiYKEBHVbN4Gd0,903
+ezmsg/sigproc/diff.py,sha256=P5BBjR7KdaCL9aD3GG09cmC7a-3cxDeEUw4nKdQ1HY8,2895
+ezmsg/sigproc/downsample.py,sha256=0X6EwPZ_XTwA2-nx5w-2HmMZUEDFuGAYF5EmPSuuVj8,3721
+ezmsg/sigproc/ewma.py,sha256=W_VS2MxiO1J7z2XS6rtnLnCEXxdRPQbMKtZduBwqTEQ,6369
+ezmsg/sigproc/ewmfilter.py,sha256=EPlocRdKORj575VV1YUzcNsVcq-pYgdEJ7_m9WfpVnY,4795
+ezmsg/sigproc/extract_axis.py,sha256=Gl8Hl_Ho2pPzchPjfseVHVRAqxj6eOvUQZlzfYRA7eI,1603
+ezmsg/sigproc/filter.py,sha256=i5adfND0NATrk2RewkWQ0C3RKRGiElr5AIB2eZE4Dr8,11225
+ezmsg/sigproc/filterbank.py,sha256=pJzv_G6chgWa1ARmRjMAMgt9eEGnA-ZbMSge4EWrcYY,13633
+ezmsg/sigproc/messages.py,sha256=y_twVPK7TxRj8ajmuSuBuxwvLTgyv9OF7Y7v9bw1tfs,926
+ezmsg/sigproc/quantize.py,sha256=VzaqE6PatibEjkk7XrGO-ubAXYurAed9FYOn4bcQZQk,2193
+ezmsg/sigproc/resample.py,sha256=XQzEbUq44qTx5tXX2QXd14hkMb7C3LXT3CqbC161X1M,11600
+ezmsg/sigproc/sampler.py,sha256=qrw-7US3mqrGS7lOio7P_za0MSPgBhSxinIrMf1P3Os,11026
+ezmsg/sigproc/scaler.py,sha256=fCLHvCNUSgv0XChf8iS9s5uHCSCVjCasM2TCvyG5BwQ,4111
+ezmsg/sigproc/signalinjector.py,sha256=hGC837JyDLtAGrfsdMwzEoOqWXiwP7r7sGlUC9nahTY,2948
+ezmsg/sigproc/slicer.py,sha256=QKiq8wOTXf3kwWSCiZEGn9rA9HaM_q6PbXvtfpgjTXw,5417
+ezmsg/sigproc/spectral.py,sha256=_2qO6as4Nesmc9V1WW2EXNMH5pPz8aVTEcIPOi4-g2o,322
+ezmsg/sigproc/spectrogram.py,sha256=TXbn8oXhBHCV-Ut8HRRUXJBYB-LbUxzTHpSgR0UnqtM,2941
+ezmsg/sigproc/spectrum.py,sha256=xTSP8QFCG9M3NHveFkcks_wI-RzD7kM_fR1dmaLtiEQ,9737
+ezmsg/sigproc/synth.py,sha256=DdE9yEXGrDRb745cOgKNpY2frI5uM2VHmCsaZO-UkBk,24547
+ezmsg/sigproc/transpose.py,sha256=AIwz8X2AS7Tf1_aidND132uDuB04M4f3-0iRYq0ysC8,4530
+ezmsg/sigproc/wavelets.py,sha256=g9nYRF4oVov2uLC0tfzPOLjaQah_HhM0ckhQ4m23mms,7507
+ezmsg/sigproc/window.py,sha256=VAFqZsHu-J3hfBnbbUk9d7MIsbbPIgrqg3OSz7uhl_o,16242
+ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/math/abs.py,sha256=9E0A-p_Qa1SVzqbr1sesjgpu6-XGUZkcRJVK5jcNc0U,685
+ezmsg/sigproc/math/clip.py,sha256=bBGfy45CKsUIhrznYZdpgUa0Lz7GsOuFl87IeL0qNA8,1057
+ezmsg/sigproc/math/difference.py,sha256=Mr7lA_JZ8ix-FK_4s7zfA7IAJgj7SkWonDNZ5k2DZg4,2321
+ezmsg/sigproc/math/invert.py,sha256=OTiT5gXs088-tvZe8piqxLoInYf1SMY4Ph62cu6DCGM,609
+ezmsg/sigproc/math/log.py,sha256=bx0om3Qi3ZShExEZ-IH5Xrg3XFjNEmjVygWlXWjyrv8,1479
+ezmsg/sigproc/math/scale.py,sha256=kMQRPYnm1o_9lC1EtIkoZOWaAWOWWbeT4ri1q7Hs7Fc,898
+ezmsg/sigproc/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/util/asio.py,sha256=PQew73hB1oRmp7pfTqx-c4uo1zqgjxvZcTZCROQrEP4,5270
+ezmsg/sigproc/util/message.py,sha256=l_b1b6bXX8N6VF9RbUELzsHs73cKkDURBdIr0lt3CY0,909
+ezmsg/sigproc/util/profile.py,sha256=KNJ_QkKelQHNEp2C8MhqzdhYydMNULc_NQq3ccMfzIk,5775
+ezmsg/sigproc/util/sparse.py,sha256=8Ke0jh3jRPi_TwIdLTwLdojQiaqPs6QV-Edqpx81VoI,1036
+ezmsg/sigproc/util/typeresolution.py,sha256=5R7xmG-F4CkdqQ5aoQnqM-htQb-VwAJl58jJgxtClys,3146
+ezmsg_sigproc-2.0.0.dist-info/METADATA,sha256=6QpdeS-5kMO5DogCy7LpB6ho0sQN5rnpfRwF7TwgXg4,2479
+ezmsg_sigproc-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ezmsg_sigproc-2.0.0.dist-info/licenses/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-2.0.0.dist-info/RECORD,,