ezmsg-sigproc 1.2.3__py3-none-any.whl → 1.3.2__py3-none-any.whl

ezmsg/sigproc/window.py

@@ -1,121 +1,147 @@
 from dataclasses import replace
 import traceback
-from typing import AsyncGenerator, Optional, Tuple, List, Generator
+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.messages.axisarray import (
+    AxisArray,
+    slice_along_axis,
+    sliding_win_oneaxis,
+)
 from ezmsg.util.generator import consumer
 
+from .base import GenAxisArray
+
 
 @consumer
 def windowing(
-    axis: Optional[str] = None,
-    newaxis: Optional[str] = None,
-    window_dur: Optional[float] = None,
-    window_shift: Optional[float] = None,
-    zero_pad_until: str = "input"
-) -> Generator[AxisArray, List[AxisArray], None]:
+    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]:
     """
-    Window function that generates windows of data from an input `AxisArray`.
-    :param axis: The axis along which to segment windows.
-        If None, defaults to the first dimension of the first seen AxisArray.
-    :param newaxis: Optional new axis for the output. If None, no new axes will be added.
-        If a string, windows will be stacked in a new axis with key `newaxis`, immediately preceding the windowed axis.
-    :param window_dur: The duration of the window in seconds.
-        If None, the function acts as a passthrough and all other parameters are ignored.
-    :param 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.
-    :param 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.
-    :return:
+    Construct a generator that yields windows of data from an input :obj:`AxisArray`.
+
+    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.
+
+    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.
     """
-    # TODO: The return should be an AxisArray. i.e., always add a new axis. The Unit can do a multi-yield-per-pub
-    #  if the parameterization does not expect a newaxis.
-
+    # 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}")
+        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.")
-    axis_arr_in = AxisArray(np.array([]), dims=[""])
-    axis_arr_out = [AxisArray(np.array([]), dims=[""])]
+        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
-    prev_samp_shape: Optional[Tuple[int, ...]] = None
-    prev_fs: Optional[float] = None
-    buffer: Optional[npt.NDArray] = None
-    window_samples: Optional[int] = None
-    window_shift_samples: Optional[int] = None
-    shift_deficit: int = 0  # Number of incoming samples to ignore. Only relevant when shift > window.
-    newaxis_warn_flag: bool = False
-    mod_ax: Optional[str] = None  # The key of the modified axis in the output's .axes
-    out_template: Optional[AxisArray] = None  # Template for building return values.
+    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}
 
     while True:
-        axis_arr_in = yield axis_arr_out
+        msg_in: AxisArray = yield msg_out
 
         if window_dur is None:
-            axis_arr_out = [axis_arr_in]
+            msg_out = msg_in
             continue
 
-        if axis is None:
-            axis = axis_arr_in.dims[0]
-        axis_idx = axis_arr_in.get_axis_idx(axis)
-        axis_info = axis_arr_in.get_axis(axis)
+        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
 
-        if (not newaxis_warn_flag) and newaxis is not None and newaxis in axis_arr_in.dims:
-            ez.logger.warning(f"newaxis {newaxis} present in input dims and will be ignored.")
-            newaxis_warn_flag = True
-        b_newaxis = newaxis is not None and newaxis not in axis_arr_in.dims
+        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 = axis_arr_in.data.shape[:axis_idx] + axis_arr_in.data.shape[axis_idx + 1:]
-        window_samples = int(window_dur * fs)
-        b_1to1 = window_shift is None
-        if not b_1to1:
-            window_shift_samples = int(window_shift * fs)
+        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
-        if buffer is None or samp_shape != prev_samp_shape or fs != prev_fs:
+        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 = axis_arr_in.data.shape[axis_idx]
+                req_samples = msg_in.data.shape[axis_idx]
             n_zero = max(0, window_samples - req_samples)
-            buffer_shape = axis_arr_in.data.shape[:axis_idx] + (n_zero,) + axis_arr_in.data.shape[axis_idx + 1:]
-            buffer = np.zeros(buffer_shape)
-            prev_samp_shape = samp_shape
-            prev_fs = fs
+            buffer = np.zeros(
+                msg_in.data.shape[:axis_idx]
+                + (n_zero,)
+                + msg_in.data.shape[axis_idx + 1 :]
+            )
 
         # Add new data to buffer.
-        # 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
+        # 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.
-        buffer = np.concatenate((buffer, axis_arr_in.data), axis=axis_idx)
-        # Note: if we ever move to using a circular buffer without copies then we need to create copies somewhere,
-        #  because currently the outputs are merely views into the buffer.
+        # A circular buffer might be faster.
+        buffer = np.concatenate((buffer, msg_in.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[-axis_arr_in.data.shape[axis_idx]]
+        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
@@ -123,123 +149,133 @@ def windowing(
         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, np.s_[n_skip:], axis_idx)
+                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_template is None:
-            out_dims = axis_arr_in.dims
-            if newaxis is None:
-                out_axes = {
-                    **axis_arr_in.axes,
-                    axis: replace(axis_info, offset=0.0)  # offset modified below.
-                }
-                mod_ax = axis
-            else:
-                out_dims = out_dims[:axis_idx] + [newaxis] + out_dims[axis_idx:]
-                out_axes = {
-                    **axis_arr_in.axes,
-                    newaxis: AxisArray.Axis(
-                        unit=axis_info.unit,
-                        gain=0.0 if b_1to1 else axis_info.gain * window_shift_samples,
-                        offset=0.0  # offset modified below
-                    )
-                }
-                mod_ax = newaxis
-            out_template = replace(axis_arr_in, data=np.zeros([0 for _ in out_dims]), dims=out_dims)
+        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.
-        axis_arr_out: List[AxisArray] = []
+        # 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, np.s_[-window_samples:], axis_idx)
-            axis_arr_out.append(replace(
-                    out_template,
-                    data=np.expand_dims(buffer, axis=axis_idx) if b_newaxis else buffer,
-                    axes={
-                        **out_axes,
-                        mod_ax: replace(out_axes[mod_ax], offset=buffer_offset[-window_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.
-            win_view = sliding_win_oneaxis(buffer, window_samples, axis_idx)
-            win_view = slice_along_axis(win_view, np.s_[::window_shift_samples], axis_idx)
-            offset_view = sliding_win_oneaxis(buffer_offset, window_samples, 0)[::window_shift_samples]
-            # Place in output
-            if b_newaxis:
-                axis_arr_out.append(replace(
-                    out_template,
-                    data=win_view,
-                    axes={**out_axes, mod_ax: replace(out_axes[mod_ax], offset=offset_view[0, 0])}
-                ))
-            else:
-                for win_ix in range(win_view.shape[axis_idx]):
-                    axis_arr_out.append(replace(
-                        out_template,
-                        data=slice_along_axis(win_view, win_ix, axis_idx),
-                        axes={
-                            **out_axes,
-                            mod_ax: replace(out_axes[mod_ax], offset=offset_view[win_ix, 0])
-                        }
-                    ))
+            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 * win_view.shape[axis_idx]
+            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, np.s_[multi_shift:], axis_idx)
+            buffer = slice_along_axis(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 :]
+            )
+            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: Optional[str] = None
-    newaxis: Optional[str] = None  # new axis for output. No new axes if None
-    window_dur: Optional[float] = None  # Sec. passthrough if None
-    window_shift: Optional[float] = None  # Sec. Use "1:1 mode" if None
+    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: Generator
+    gen: typing.Generator
 
 
-class Window(ez.Unit):
-    STATE: WindowState
-    SETTINGS: WindowSettings
+class Window(GenAxisArray):
+    """:obj:`Unit` for :obj:`bandpower`."""
+
+    SETTINGS = WindowSettings
 
     INPUT_SIGNAL = ez.InputStream(AxisArray)
     OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-    INPUT_SETTINGS = ez.InputStream(WindowSettings)
-
-    def initialize(self) -> None:
-        self.STATE.cur_settings = self.SETTINGS
-        self.construct_generator()
-
-    @ez.subscriber(INPUT_SETTINGS)
-    async def on_settings(self, msg: WindowSettings) -> None:
-        self.STATE.cur_settings = msg
-        self.construct_generator()
 
     def construct_generator(self):
         self.STATE.gen = windowing(
-            axis=self.STATE.cur_settings.axis,
-            newaxis=self.STATE.cur_settings.newaxis,
-            window_dur=self.STATE.cur_settings.window_dur,
-            window_shift=self.STATE.cur_settings.window_shift,
-            zero_pad_until=self.STATE.cur_settings.zero_pad_until
+            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)
+    @ez.subscriber(INPUT_SIGNAL, zero_copy=True)
     @ez.publisher(OUTPUT_SIGNAL)
-    async def on_signal(self, msg: AxisArray) -> AsyncGenerator:
+    async def on_signal(self, msg: AxisArray) -> typing.AsyncGenerator:
         try:
-            # TODO: Refactor window generator so it always returns an axis array.
-            #  Then, if the configuration is such that a new "win" axis is not expected,
-            #  then iterate over the "win" axis -- dropping the "win" axis in the process.
-            out_msgs = self.STATE.gen.send(msg)
-            for out_msg in out_msgs:
-                yield self.OUTPUT_SIGNAL, out_msg
+            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:
+                    # 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:

ezmsg_sigproc-1.3.2.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.3
+Name: ezmsg-sigproc
+Version: 1.3.2
+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>=1.26.0
+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`

ezmsg_sigproc-1.3.2.dist-info/RECORD

@@ -0,0 +1,35 @@
+ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
+ezmsg/sigproc/__version__.py,sha256=ik9WUFYTvRcmzFEUSqkI2H_62uw0XFdUT3mTLq8-_RY,411
+ezmsg/sigproc/activation.py,sha256=-KgDSVmgYx8QhHM5UQHkMN6rHudeasuWOYhmM2_aWH0,2068
+ezmsg/sigproc/affinetransform.py,sha256=pJlg07sXf-o-Rv-pSD1_M_kH0xWBM9vYKGcJ7HCGndU,8938
+ezmsg/sigproc/aggregate.py,sha256=8kVs2S2MUuTZkRwn-vh4utv8uoWwWrIkgalxcBdT39M,5490
+ezmsg/sigproc/bandpower.py,sha256=l_R_qcrRTLGYjg40VAinIHz24pdwET4AS4RXd2Ctcig,2126
+ezmsg/sigproc/base.py,sha256=VtlneWR0GAsWzAfqMzFy-WYPbeF8C3qVenqj7h_Cfek,1224
+ezmsg/sigproc/butterworthfilter.py,sha256=busvcDtVJx2ZHgenM4o0SDTeBbtXbPEXrClCRty0iF0,5233
+ezmsg/sigproc/decimate.py,sha256=zNxJXauE4Z54Yy7tpN9_oJuW0I0ppQRWhSpwb3Ri2gc,1473
+ezmsg/sigproc/downsample.py,sha256=Zuk_sCTk3eYOmyVsKGk9P6s-yUkfim_neBBc61ZVUKY,3304
+ezmsg/sigproc/ewmfilter.py,sha256=XzTmouRa7AnPjTiI32-oumwm4ZfOl6uPPUSldExNpAs,4516
+ezmsg/sigproc/filter.py,sha256=DHF-4CvxhNCGaAuVpn64wCxYuq5TpMH7bi0KKQNaOk0,8161
+ezmsg/sigproc/filterbank.py,sha256=K3Y2SJ7kfEp-CiNNSgzEM7sq1hbYaXOvufKSVyYnUEw,12252
+ezmsg/sigproc/messages.py,sha256=KpYCWWRD5itVAq0-Lf8qd7ErEE1A9qdm2p7O8Y4zEFA,955
+ezmsg/sigproc/sampler.py,sha256=3-O5nplutDcojb0CCbkTQsH8cZ8yKxqYts_02LryIKM,12762
+ezmsg/sigproc/scaler.py,sha256=eQuF3DL4NvxuEBjDgf2k4qqoctw5hIS_NIOfbOjOY0k,5823
+ezmsg/sigproc/signalinjector.py,sha256=HzQvI6jvkuX7miGHy6h0yXVRz_wvM3ecpQvquCV0H7g,2408
+ezmsg/sigproc/slicer.py,sha256=TcTI464UH9y1abCwT6eEMaqo7B1geuwJNNYScMUyyFM,4609
+ezmsg/sigproc/spectral.py,sha256=_2qO6as4Nesmc9V1WW2EXNMH5pPz8aVTEcIPOi4-g2o,322
+ezmsg/sigproc/spectrogram.py,sha256=osaqIhC04RbMnpHy5ecAxnYhQOn022oTvF2wbz-lKec,2977
+ezmsg/sigproc/spectrum.py,sha256=AmoPObVVvuXkUSClCExvKzLoasLyTlIwtRsrz1XFOLI,9366
+ezmsg/sigproc/synth.py,sha256=ygJRI9Seqhrg13lUhcA6XSpxcEr3LL1NupviSQLrC9o,18351
+ezmsg/sigproc/wavelets.py,sha256=sccj7xsIyHmsUL7XWYm7wxnNvIGEcpCZ8qsfRXSObiA,6488
+ezmsg/sigproc/window.py,sha256=bzOJDQRxDfcHNHrTgWkILGH9uYk4z0jy-JkCb8zguFQ,12599
+ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/math/abs.py,sha256=8rtcdyMSGtnMQgGwbcW8Ky-3uRspkYD7lRdpcFl6uEE,608
+ezmsg/sigproc/math/clip.py,sha256=WBKe6wPTcqb041OwuUB5OGK-s_R3gc95qKBJY2Aspgo,779
+ezmsg/sigproc/math/difference.py,sha256=tacbt3KKQOhoYaFMlrASC2GhYQG1J6Hdaa9J1zg_Aw8,1735
+ezmsg/sigproc/math/invert.py,sha256=X6Pp0oYg5A3tpDxfI513xjYg2yXjsosR048AxCWzIwI,667
+ezmsg/sigproc/math/log.py,sha256=T3DST5gpva3lTHmbJkDWVpJyqEVeydUuZSOQCThbvIg,757
+ezmsg/sigproc/math/scale.py,sha256=Ge99e43m1tYoxwQEZ2y-jPq6XQn_IvuKLPaTT2y5vPI,746
+ezmsg_sigproc-1.3.2.dist-info/METADATA,sha256=zFIJ6FXjyBXOcJLjgGE0OO8R_IPKnAIWT8AEQ9SS_io,2376
+ezmsg_sigproc-1.3.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ezmsg_sigproc-1.3.2.dist-info/licenses/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-1.3.2.dist-info/RECORD,,

{ezmsg_sigproc-1.2.3.dist-info → ezmsg_sigproc-1.3.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any

ezmsg_sigproc-1.2.3.dist-info/METADATA

@@ -1,38 +0,0 @@
-Metadata-Version: 2.1
-Name: ezmsg-sigproc
-Version: 1.2.3
-Summary: Timeseries signal processing implementations in ezmsg
-License: MIT
-Author: Milsap, Griffin
-Author-email: griffin.milsap@gmail.com
-Requires-Python: >=3.8,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: ezmsg (>=3.3.0,<4.0.0)
-Requires-Dist: numpy (>=1.19.5,<2.0.0)
-Requires-Dist: scipy (>=1.6.3,<2.0.0)
-Description-Content-Type: text/markdown
-
-# ezmsg.sigproc
-
-Timeseries signal processing implementations for ezmsg
-
-## Installation
-`pip install ezmsg-sigproc`
-
-## Dependencies
-* `ezmsg`
-* `numpy`
-* `scipy`
-
-## Setup (Development)
-1. Install `ezmsg` either using `pip install ezmsg` or set up the repo for development as described in the `ezmsg` readme.
-2. `cd` to this directory (`ezmsg-sigproc`) and run `pip install -e .`
-3. Signal processing modules are available under `import ezmsg.sigproc`
-
-

ezmsg_sigproc-1.2.3.dist-info/RECORD

@@ -1,23 +0,0 @@
-ezmsg/sigproc/__init__.py,sha256=0GC1NyV5G-wC90N72vxdMdq8IjbroUkcgfzkEq8mtas,86
-ezmsg/sigproc/affinetransform.py,sha256=fmSqu26d_GnHU2LtvgdACOcsyJbTqQUurY75CbXiJ54,4547
-ezmsg/sigproc/aggregate.py,sha256=rrcn9Zt5BneOMN6nzdbSPggTwOJm43Z_faLn5CEZJpI,3549
-ezmsg/sigproc/bandpower.py,sha256=7Bc1vPZb9VMYQvcaDRBlTuoUzG5n9etfJ0ATv0j3T-Y,1708
-ezmsg/sigproc/butterworthfilter.py,sha256=roA-EoxxMiKZsrh9UGomZ9HQab7zs7iH0CK4_LkpVs0,3322
-ezmsg/sigproc/decimate.py,sha256=xQgyGSrje9hiNjMpEpGOyAUluTxm5zgY66GcKur7oYs,1328
-ezmsg/sigproc/downsample.py,sha256=ffLW4waASy9zRjq1y39Iuag_r5thejLB_zvqYEco738,2968
-ezmsg/sigproc/ewmfilter.py,sha256=IBorlWd9YXRIgDWYwgTCBtkjSv3YzhH0f4D-gqX-8kc,4097
-ezmsg/sigproc/filter.py,sha256=8GrgF_HNfTfW9WOXnNYt0bJMFkfr47yJJY_G6GuSg90,7584
-ezmsg/sigproc/messages.py,sha256=JU9l_QNL7SKY54ac9SARKf5tSxWqSAyUqvfvoamHzKs,963
-ezmsg/sigproc/sampler.py,sha256=Bo4On8jKZ1AF5-RH4pn_HWJnx1E6OobTZ5w1qf3zLiw,10761
-ezmsg/sigproc/scaler.py,sha256=nE2YVK_pxOSnjLm1w7sOpmC69sHIgze81XBuwntfuhM,4387
-ezmsg/sigproc/signalinjector.py,sha256=_hYtLNNC2uSr7nz2dg9Ne8W-02Y10o0RJL9lDluR9gY,2408
-ezmsg/sigproc/slicer.py,sha256=khmmMDHjiAk5G5iOS0z9oHrjoTLPGE1bcZiae7qf7as,3249
-ezmsg/sigproc/spectral.py,sha256=KvM4pwqd2YYt2zsiLw8PgDDh5GVTjbUeUJxVbL2K8-A,160
-ezmsg/sigproc/spectrogram.py,sha256=tOQ4MjAIs7orvd5qaW6ZmFHxRW1TSr_hHauL18Bo9Rk,2471
-ezmsg/sigproc/spectrum.py,sha256=Cni5HZaeu-RaDWkLMyXBBAdtSwKpxXESONfl1AUsmHQ,5398
-ezmsg/sigproc/synth.py,sha256=mcBd1H1quoB5PxKzpuDDBfJYYRs0Sbi7icajabXhv1s,16229
-ezmsg/sigproc/window.py,sha256=OZF8LjPHu5FK3jRBhelKs-aBdeSKT_3qxZNDaMiws08,11742
-ezmsg_sigproc-1.2.3.dist-info/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
-ezmsg_sigproc-1.2.3.dist-info/METADATA,sha256=wKa6rW06PJYh0da1xjINzOvc0ixSoki9Uy8juys9NwM,1188
-ezmsg_sigproc-1.2.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ezmsg_sigproc-1.2.3.dist-info/RECORD,,