ezmsg-sigproc 1.2.2__py3-none-any.whl → 1.3.1__py3-none-any.whl

ezmsg/sigproc/wavelets.py

@@ -0,0 +1,167 @@
+from dataclasses import replace
+import typing
+
+import numpy as np
+import numpy.typing as npt
+import pywt
+import ezmsg.core as ez
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.generator import consumer
+
+from .base import GenAxisArray
+from .filterbank import filterbank, FilterbankMode, MinPhaseMode
+
+
+@consumer
+def cwt(
+    scales: typing.Union[list, tuple, npt.NDArray],
+    wavelet: typing.Union[str, pywt.ContinuousWavelet, pywt.Wavelet],
+    min_phase: MinPhaseMode = MinPhaseMode.NONE,
+    axis: str = "time",
+) -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    Build a generator to perform a continuous wavelet transform on sent AxisArray messages.
+    The function is equivalent to the `pywt.cwt` function, but is designed to work with streaming data.
+
+    Args:
+        scales: The wavelet scales to use.
+        wavelet: Wavelet object or name of wavelet to use.
+        min_phase: See filterbank MinPhaseMode for details.
+        axis: The target axis for operation. Note that this will be moved to the -1th dimension
+          because fft and matrix multiplication is much faster on the last axis.
+
+    Returns:
+        A Generator object that expects `.send(axis_array)` of continuous data
+    """
+    msg_out: typing.Optional[AxisArray] = None
+
+    # Check parameters
+    scales = np.array(scales)
+    assert np.all(scales > 0), "Scales must be positive."
+    assert scales.ndim == 1, "Scales must be a 1D list, tuple, or array."
+    if not isinstance(wavelet, (pywt.ContinuousWavelet, pywt.Wavelet)):
+        wavelet = pywt.DiscreteContinuousWavelet(wavelet)
+    precision = 10
+
+    # State variables
+    neg_rt_scales = -np.sqrt(scales)[:, None]
+    int_psi, wave_xvec = pywt.integrate_wavelet(wavelet, precision=precision)
+    int_psi = np.conj(int_psi) if wavelet.complex_cwt else int_psi
+    template: typing.Optional[AxisArray] = None
+    fbgen: typing.Optional[typing.Generator[AxisArray, AxisArray, None]] = None
+    last_conv_samp: typing.Optional[npt.NDArray] = None
+
+    # Reset if input changed
+    check_input = {
+        "kind": None,  # Need to recalc kernels at same complexity as input
+        "gain": None,  # Need to recalc freqs
+        "shape": None,  # Need to recalc template and buffer
+        "key": None,  # Buffer obsolete
+    }
+
+    while True:
+        msg_in: AxisArray = yield msg_out
+        ax_idx = msg_in.get_axis_idx(axis)
+        in_shape = msg_in.data.shape[:ax_idx] + msg_in.data.shape[ax_idx + 1 :]
+
+        b_reset = msg_in.data.dtype.kind != check_input["kind"]
+        b_reset = b_reset or msg_in.axes[axis].gain != check_input["gain"]
+        b_reset = b_reset or in_shape != check_input["shape"]
+        b_reset = b_reset or msg_in.key != check_input["key"]
+        b_reset = b_reset and msg_in.data.size > 0
+        if b_reset:
+            check_input["kind"] = msg_in.data.dtype.kind
+            check_input["gain"] = msg_in.axes[axis].gain
+            check_input["shape"] = in_shape
+            check_input["key"] = msg_in.key
+
+            # convert int_psi, wave_xvec to the same precision as the data
+            dt_data = msg_in.data.dtype  # _check_dtype(msg_in.data)
+            dt_cplx = np.result_type(dt_data, np.complex64)
+            dt_psi = dt_cplx if int_psi.dtype.kind == "c" else dt_data
+            int_psi = np.asarray(int_psi, dtype=dt_psi)
+            # TODO: Currently int_psi cannot be made non-complex once it is complex.
+
+            # Calculate waves for each scale
+            wave_xvec = np.asarray(wave_xvec, dtype=msg_in.data.real.dtype)
+            wave_range = wave_xvec[-1] - wave_xvec[0]
+            step = wave_xvec[1] - wave_xvec[0]
+            int_psi_scales = []
+            for scale in scales:
+                reix = (np.arange(scale * wave_range + 1) / (scale * step)).astype(int)
+                if reix[-1] >= int_psi.size:
+                    reix = np.extract(reix < int_psi.size, reix)
+                int_psi_scales.append(int_psi[reix][::-1])
+
+            # CONV is probably best because we often get huge kernels.
+            fbgen = filterbank(
+                int_psi_scales, mode=FilterbankMode.CONV, min_phase=min_phase, axis=axis
+            )
+
+            freqs = (
+                pywt.scale2frequency(wavelet, scales, precision)
+                / msg_in.axes[axis].gain
+            )
+            fstep = (freqs[1] - freqs[0]) if len(freqs) > 1 else 1.0
+            # Create output template
+            dummy_shape = in_shape + (len(scales), 0)
+            template = AxisArray(
+                np.zeros(
+                    dummy_shape, dtype=dt_cplx if wavelet.complex_cwt else dt_data
+                ),
+                dims=msg_in.dims[:ax_idx] + msg_in.dims[ax_idx + 1 :] + ["freq", axis],
+                axes={
+                    **msg_in.axes,
+                    "freq": AxisArray.Axis("Hz", offset=freqs[0], gain=fstep),
+                },
+            )
+            last_conv_samp = np.zeros(
+                dummy_shape[:-1] + (1,), dtype=template.data.dtype
+            )
+
+        conv_msg = fbgen.send(msg_in)
+
+        # Prepend with last_conv_samp before doing diff
+        dat = np.concatenate((last_conv_samp, conv_msg.data), axis=-1)
+        coef = neg_rt_scales * np.diff(dat, axis=-1)
+        # Store last_conv_samp for next iteration.
+        last_conv_samp = conv_msg.data[..., -1:]
+
+        if template.data.dtype.kind != "c":
+            coef = coef.real
+
+        # pywt.cwt slices off the beginning and end of the result where the convolution overran. We don't have
+        #  that luxury when streaming.
+        # d = (coef.shape[-1] - msg_in.data.shape[ax_idx]) / 2.
+        # coef = coef[..., math.floor(d):-math.ceil(d)]
+        msg_out = replace(
+            template, data=coef, axes={**template.axes, axis: msg_in.axes[axis]}
+        )
+
+
+class CWTSettings(ez.Settings):
+    """
+    Settings for :obj:`CWT`
+    See :obj:`cwt` for argument details.
+    """
+
+    scales: typing.Union[list, tuple, npt.NDArray]
+    wavelet: typing.Union[str, pywt.ContinuousWavelet, pywt.Wavelet]
+    min_phase: MinPhaseMode = MinPhaseMode.NONE
+    axis: str = "time"
+
+
+class CWT(GenAxisArray):
+    """
+    :obj:`Unit` for :obj:`common_rereference`.
+    """
+
+    SETTINGS = CWTSettings
+
+    def construct_generator(self):
+        self.STATE.gen = cwt(
+            scales=self.SETTINGS.scales,
+            wavelet=self.SETTINGS.wavelet,
+            min_phase=self.SETTINGS.min_phase,
+            axis=self.SETTINGS.axis,
+        )

ezmsg/sigproc/window.py

@@ -1,144 +1,282 @@
 from dataclasses import replace
+import traceback
+import typing
 
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
+from ezmsg.util.messages.axisarray import (
+    AxisArray,
+    slice_along_axis,
+    sliding_win_oneaxis,
+)
+from ezmsg.util.generator import consumer
 
-from ezmsg.util.messages.axisarray import AxisArray
+from .base import GenAxisArray
 
-from typing import AsyncGenerator, Optional, Tuple, List
 
+@consumer
+def windowing(
+    axis: typing.Optional[str] = None,
+    newaxis: str = "win",
+    window_dur: typing.Optional[float] = None,
+    window_shift: typing.Optional[float] = None,
+    zero_pad_until: str = "input",
+) -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    Construct a generator that yields windows of data from an input :obj:`AxisArray`.
 
-class WindowSettings(ez.Settings):
-    axis: Optional[str] = None
-    newaxis: Optional[
-        str
-    ] = None  # Optional new axis for output.  If "None" - no new axes on output
-    window_dur: Optional[
-        float
-    ] = None  # Sec.  If "None" -- passthrough; window_shift is ignored.
-    window_shift: Optional[float] = None  # Sec.  If "None", activate "1:1 mode"
+    Args:
+        axis: The axis along which to segment windows.
+            If None, defaults to the first dimension of the first seen AxisArray.
+        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.
 
-class WindowState(ez.State):
-    cur_settings: WindowSettings
+    Returns:
+        A (primed) generator that accepts .send(an AxisArray object) and yields a list of windowed
+        AxisArray objects. The list will always be length-1 if `newaxis` is not None or `window_shift` is None.
+    """
+    # 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=[""])
 
-    samp_shape: Optional[Tuple[int, ...]] = None  # Shape of individual sample
-    out_fs: Optional[float] = None
-    buffer: Optional[npt.NDArray] = None
-    window_samples: Optional[int] = None
-    window_shift_samples: Optional[int] = None
+    # State variables
+    buffer: typing.Optional[npt.NDArray] = None
+    window_samples: typing.Optional[int] = None
+    window_shift_samples: typing.Optional[int] = 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
+    out_newaxis: typing.Optional[AxisArray.Axis] = None
+    out_dims: typing.typing.Optional[typing.List[str]] = None
 
+    check_inputs = {"samp_shape": None, "fs": None, "key": None}
 
-class Window(ez.Unit):
-    STATE: WindowState
-    SETTINGS: WindowSettings
+    while True:
+        msg_in: AxisArray = yield msg_out
 
-    INPUT_SIGNAL = ez.InputStream(AxisArray)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-    INPUT_SETTINGS = ez.InputStream(WindowSettings)
+        if window_dur is None:
+            msg_out = msg_in
+            continue
 
-    def initialize(self) -> None:
-        self.STATE.cur_settings = self.SETTINGS
+        axis = axis or msg_in.dims[0]
+        axis_idx = msg_in.get_axis_idx(axis)
+        axis_info = msg_in.get_axis(axis)
+        fs = 1.0 / axis_info.gain
 
-    @ez.subscriber(INPUT_SETTINGS)
-    async def on_settings(self, msg: WindowSettings) -> None:
-        self.STATE.cur_settings = msg
-        self.STATE.out_fs = None  # This should trigger a reallocation
+        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"
 
-    @ez.subscriber(INPUT_SIGNAL)
-    @ez.publisher(OUTPUT_SIGNAL)
-    async def on_signal(self, msg: AxisArray) -> AsyncGenerator:
-        if self.STATE.cur_settings.window_dur is None:
-            yield self.OUTPUT_SIGNAL, msg
-            return
-
-        axis_name = self.STATE.cur_settings.axis
-        if axis_name is None:
-            axis_name = msg.dims[0]
-        axis_idx = msg.get_axis_idx(axis_name)
-        axis = msg.get_axis(axis_name)
-        fs = 1.0 / axis.gain
-
-        # Create a view of data with time axis at dim 0
-        time_view = np.moveaxis(msg.data, axis_idx, 0)
-        samp_shape = time_view.shape[1:]
-
-        # Pre(re?)allocate buffer
-        window_samples = int(self.STATE.cur_settings.window_dur * fs)
-        if (
-            (self.STATE.samp_shape != samp_shape)
-            or (self.STATE.out_fs != fs)
-            or self.STATE.buffer is None
-        ):
-            self.STATE.buffer = np.zeros(tuple([window_samples] + list(samp_shape)))
-
-        self.STATE.window_samples = window_samples
-        self.STATE.samp_shape = samp_shape
-        self.STATE.out_fs = fs
-
-        self.STATE.window_shift_samples = None
-        if self.STATE.cur_settings.window_shift is not None:
-            self.STATE.window_shift_samples = int(
-                fs * self.STATE.cur_settings.window_shift
+        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)
+            buffer = np.zeros(
+                msg_in.data.shape[:axis_idx]
+                + (n_zero,)
+                + msg_in.data.shape[axis_idx + 1 :]
             )
 
-        # Currently we just concatenate the new time samples and clip the output
-        # np.roll actually returns a copy, and there's no way to construct a
-        # rolling view of the data.  In current numpy implementations, np.concatenate
+        # Add new data to buffer.
+        # Currently, we concatenate the new time samples and clip the output.
+        # np.roll is not preferred as it returns a copy, and there's no way to construct a
+        # rolling view of the data. In current numpy implementations, np.concatenate
         # is generally faster than np.roll and slicing anyway, but this could still
         # be a performance bottleneck for large memory arrays.
-        self.STATE.buffer = np.concatenate((self.STATE.buffer, time_view), axis=0)
+        # A circular buffer might be faster.
+        buffer = np.concatenate((buffer, msg_in.data), axis=axis_idx)
 
-        buffer_offset = np.arange(self.STATE.buffer.shape[0] + time_view.shape[0])
-        buffer_offset -= self.STATE.buffer.shape[0] + 1
-        buffer_offset = (buffer_offset * axis.gain) + axis.offset
+        # 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]]
+        # Convert form indices to 'units' (probably seconds).
+        buffer_offset *= axis_info.gain
+        buffer_offset += axis_info.offset
 
-        outputs: List[Tuple[npt.NDArray, float]] = []
+        if not b_1to1 and shift_deficit > 0:
+            n_skip = min(buffer.shape[axis_idx], 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
 
-        if self.STATE.window_shift_samples is None:  # one-to-one mode
-            self.STATE.buffer = self.STATE.buffer[-self.STATE.window_samples :, ...]
-            buffer_offset = buffer_offset[-self.STATE.window_samples :]
-            outputs.append((self.STATE.buffer, buffer_offset[0]))
+        # 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
+            )
+
+        # 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]}
+
+        # 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)
+
+        # How we update .data and .axes[newaxis] depends on the windowing mode.
+        if b_1to1:
+            # 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 = np.expand_dims(buffer, axis=axis_idx)
+            out_newaxis = replace(out_newaxis, offset=buffer_offset[-window_samples])
+        elif buffer.shape[axis_idx] >= window_samples:
+            # Deterministic window shifts.
+            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
+            )
+            offset_view = sliding_win_oneaxis(buffer_offset, window_samples, 0)[
+                ::window_shift_samples
+            ]
+            out_newaxis = replace(out_newaxis, 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)
         else:
-            yieldable_size = self.STATE.window_samples + self.STATE.window_shift_samples
-            while self.STATE.buffer.shape[0] >= yieldable_size:
-                outputs.append(
-                    (
-                        self.STATE.buffer[: self.STATE.window_samples, ...],
-                        buffer_offset[0],
-                    )
-                )
-                self.STATE.buffer = self.STATE.buffer[
-                    self.STATE.window_shift_samples :, ...
-                ]
-                buffer_offset = buffer_offset[self.STATE.window_shift_samples :]
-
-        for out_view, offset in outputs:
-            out_view = np.moveaxis(out_view, 0, axis_idx)
-
-            if (
-                self.STATE.cur_settings.newaxis is not None
-                and self.STATE.cur_settings.newaxis != self.STATE.cur_settings.axis
-            ):
-                new_gain = 0.0
-                if self.STATE.window_shift_samples is not None:
-                    new_gain = axis.gain * self.STATE.window_shift_samples
-
-                out_axis = replace(axis, unit=axis.unit, gain=new_gain, offset=offset)
-                out_axes = {**msg.axes, **{self.STATE.cur_settings.newaxis: out_axis}}
-                out_dims = [self.STATE.cur_settings.newaxis] + msg.dims
-                out_view = out_view[np.newaxis, ...]
-
-                yield self.OUTPUT_SIGNAL, replace(
-                    msg, data=out_view, dims=out_dims, axes=out_axes
-                )
-
-            else:
-                if axis_name in msg.axes:
-                    out_axes = msg.axes
-                    out_axes[axis_name] = replace(axis, offset=offset)
-                    yield self.OUTPUT_SIGNAL, replace(msg, data=out_view, axes=out_axes)
+            # 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 :]
+            )
+            out_dat = np.zeros(empty_data_shape, dtype=msg_in.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)
+
+        msg_out = replace(
+            msg_in, data=out_dat, dims=out_dims, axes={**out_axes, newaxis: out_newaxis}
+        )
+
+
+class WindowSettings(ez.Settings):
+    axis: typing.Optional[str] = None
+    newaxis: typing.Optional[str] = None  # new axis for output. No new axes if None
+    window_dur: typing.Optional[float] = None  # Sec. passthrough if None
+    window_shift: typing.Optional[float] = 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`."""
+
+    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:
+        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
+                ):
+                    # Multi-win mode or pass-through mode.
+                    yield self.OUTPUT_SIGNAL, out_msg
                 else:
-                    yield self.OUTPUT_SIGNAL, replace(msg, data=out_view)
+                    # 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]):
+                        # 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]
+                            ),
+                        }
+                        _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 :],
+                            axes=_out_axes,
+                        )
+                        yield self.OUTPUT_SIGNAL, _out_msg
+        except (StopIteration, GeneratorExit):
+            ez.logger.debug(f"Window closed in {self.address}")
+        except Exception:
+            ez.logger.info(traceback.format_exc())

ezmsg_sigproc-1.3.1.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.3
+Name: ezmsg-sigproc
+Version: 1.3.1
+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.9
+Requires-Dist: ezmsg>=3.5.0
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pywavelets>=1.6.0
+Requires-Dist: scipy>=1.13.1
+Provides-Extra: test
+Requires-Dist: flake8>=7.1.1; extra == 'test'
+Requires-Dist: frozendict>=2.4.4; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'test'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
+Requires-Dist: pytest>=8.3.3; extra == 'test'
+Description-Content-Type: text/markdown
+
+# ezmsg.sigproc
+
+Timeseries signal processing implementations for ezmsg
+
+## Dependencies
+
+* `ezmsg`
+* `numpy`
+* `scipy`
+* `pywavelets`
+
+## Installation
+
+### Release
+
+Install the latest release from pypi with: `pip install ezmsg-sigproc` (or `uv add ...` or `poetry add ...`).
+
+### Development Version
+
+You can add the development version of `ezmsg-sigproc` to your project's dependencies in one of several ways.
+
+You can clone it and add its path to your project dependencies. You may wish to do this if you intend to edit `ezmsg-sigproc`. If so, please refer to the [Developers](#developers) section below.
+
+You can also add it directly from GitHub:
+
+* Using `pip`: `pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev`
+* Using `poetry`: `poetry add "git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev"`
+* Using `uv`: `uv add git+https://github.com/ezmsg-org/ezmsg-sigproc --branch dev`
+
+## Developers
+
+We use [`uv`](https://docs.astral.sh/uv/getting-started/installation/) for development. It is not strictly required, but if you intend to contribute to ezmsg-sigproc then using `uv` will lead to the smoothest collaboration.
+
+1. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if not already installed.
+2. Fork ezmsg-sigproc and clone your fork to your local computer.
+3. Open a terminal and `cd` to the cloned folder.
+4. `uv sync` to create a .venv and install dependencies.
+5. `uv run pre-commit install` to install pre-commit hooks to do linting and formatting.
+6. After editing code and making commits, Run the test suite before making a PR: `uv run pytest tests`