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

ezmsg/sigproc/__version__.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.3.2'
-__version_tuple__ = version_tuple = (1, 3, 2)
+__version__ = version = '1.4.1'
+__version_tuple__ = version_tuple = (1, 4, 1)

ezmsg/sigproc/activation.py

@@ -43,6 +43,18 @@ ACTIVATIONS = {
 def activation(
     function: typing.Union[str, ActivationFunction],
 ) -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    Transform the data with a simple activation function.
+
+    Args:
+        function: An enum value from ActivationFunction or a string representing the activation function.
+         Possible values are: SIGMOID, EXPIT, LOGIT, LOGEXPIT, "sigmoid", "expit", "logit", "log_expit".
+         SIGMOID and EXPIT are equivalent. See :obj:`scipy.special.expit` for more details.
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an AxisArray
+     with the data payload containing a transformed version of the input data.
+
+    """
     if type(function) is ActivationFunction:
         func = ACTIVATIONS[function]
     else:

ezmsg/sigproc/affinetransform.py

@@ -24,7 +24,7 @@ def affine_transform(
     Args:
         weights: An array of weights or a path to a file with weights compatible with np.loadtxt.
         axis: The name of the axis to apply the transformation to. Defaults to the leading (0th) axis in the array.
-        right_multiply: Set False to tranpose the weights before applying.
+        right_multiply: Set False to transpose the weights before applying.
 
     Returns:
         A primed generator object that yields an :obj:`AxisArray` object for every
@@ -76,16 +76,15 @@ def affine_transform(
             ):
                 in_labels = msg_in.axes[axis].labels
                 new_labels = []
-                n_in = weights.shape[1 if right_multiply else 0]
-                n_out = weights.shape[0 if right_multiply else 1]
+                n_in, n_out = weights.shape
                 if len(in_labels) != n_in:
                     # Something upstream did something it wasn't supposed to. We will drop the labels.
                     ez.logger.warning(
                         f"Received {len(in_labels)} for {n_in} inputs. Check upstream labels."
                     )
                 else:
-                    b_used_inputs = np.any(weights, axis=0 if right_multiply else 1)
-                    b_filled_outputs = np.any(weights, axis=1 if right_multiply else 0)
+                    b_filled_outputs = np.any(weights, axis=0)
+                    b_used_inputs = np.any(weights, axis=1)
                     if np.all(b_used_inputs) and np.all(b_filled_outputs):
                         # All inputs are used and all outputs are used, but n_in != n_out.
                         # Mapping cannot be determined.

ezmsg/sigproc/aggregate.py

@@ -20,11 +20,13 @@ class AggregationFunction(OptionsEnum):
     MEAN = "mean"
     MEDIAN = "median"
     STD = "std"
+    SUM = "sum"
     NANMAX = "nanmax"
     NANMIN = "nanmin"
     NANMEAN = "nanmean"
     NANMEDIAN = "nanmedian"
     NANSTD = "nanstd"
+    NANSUM = "nansum"
     ARGMIN = "argmin"
     ARGMAX = "argmax"
 
@@ -36,11 +38,13 @@ AGGREGATORS = {
     AggregationFunction.MEAN: np.mean,
     AggregationFunction.MEDIAN: np.median,
     AggregationFunction.STD: np.std,
+    AggregationFunction.SUM: np.sum,
     AggregationFunction.NANMAX: np.nanmax,
     AggregationFunction.NANMIN: np.nanmin,
     AggregationFunction.NANMEAN: np.nanmean,
     AggregationFunction.NANMEDIAN: np.nanmedian,
     AggregationFunction.NANSTD: np.nanstd,
+    AggregationFunction.NANSUM: np.nansum,
     AggregationFunction.ARGMIN: np.argmin,
     AggregationFunction.ARGMAX: np.argmax,
 }
@@ -62,7 +66,7 @@ def ranged_aggregate(
         operation: :obj:`AggregationFunction` to apply to each band.
 
     Returns:
-        A primed generator object ready to yield an AxisArray for each .send(axis_array)
+        A primed generator object ready to yield an :obj:`AxisArray` for each .send(axis_array)
     """
     msg_out = AxisArray(np.array([]), dims=[""])
 

ezmsg/sigproc/bandpower.py

@@ -27,7 +27,8 @@ def bandpower(
         bands: (min, max) tuples of band limits in Hz.
 
     Returns:
-        A primed generator object ready to yield an AxisArray for each .send(axis_array)
+        A primed generator object ready to yield an :obj:`AxisArray` for each .send(axis_array)
+        with the data payload being the average spectral power in each band of the input data.
     """
     msg_out = AxisArray(np.array([]), dims=[""])
 

ezmsg/sigproc/base.py

@@ -1,3 +1,4 @@
+import math
 import traceback
 import typing
 
@@ -30,7 +31,7 @@ class GenAxisArray(ez.Unit):
     async def on_signal(self, message: AxisArray) -> typing.AsyncGenerator:
         try:
             ret = self.STATE.gen.send(message)
-            if ret.data.size > 0:
+            if math.prod(ret.data.shape) > 0:
                 yield self.OUTPUT_SIGNAL, ret
         except (StopIteration, GeneratorExit):
             ez.logger.debug(f"Generator closed in {self.address}")

ezmsg/sigproc/butterworthfilter.py

@@ -13,19 +13,22 @@ class ButterworthFilterSettings(FilterSettingsBase):
     """Settings for :obj:`ButterworthFilter`."""
 
     order: int = 0
+    """
+    Filter order
+    """
 
     cuton: typing.Optional[float] = None
     """
-    Cuton frequency (Hz). If cutoff is not specified then this is the highpass corner, otherwise
-    if it is lower than cutoff then this is the beginning of the bandpass
-    or if it is greater than cuton then it is the end of the bandstop. 
+    Cuton frequency (Hz). If `cutoff` is not specified then this is the highpass corner. Otherwise,
+    if this is lower than `cutoff` then this is the beginning of the bandpass
+    or if this is greater than `cutoff` then this is the end of the bandstop. 
     """
 
     cutoff: typing.Optional[float] = None
     """
-    Cutoff frequency (Hz). If cuton is not specified then this is the lowpass corner, otherwise
-    if it is greater than cuton then this is the end of the bandpass,
-    or if it is less than cuton then it is the beginning of the bandstop. 
+    Cutoff frequency (Hz). If `cuton` is not specified then this is the lowpass corner. Otherwise,
+    if this is greater than `cuton` then this is the end of the bandpass,
+    or if this is less than `cuton` then this is the beginning of the bandstop. 
     """
 
     def filter_specs(
@@ -76,7 +79,8 @@ def butter(
         coef_type: "ba" or "sos"
 
     Returns:
-        A primed generator object which accepts .send(axis_array) and yields filtered axis array.
+        A primed generator object which accepts an :obj:`AxisArray` via .send(axis_array)
+         and yields an :obj:`AxisArray` with filtered data.
 
     """
     # IO

ezmsg/sigproc/downsample.py

@@ -25,10 +25,10 @@ def downsample(
         factor: Downsampling factor.
 
     Returns:
-        A primed generator object ready to receive a `.send(axis_array)`
-        and yields the downsampled data.
+        A primed generator object ready to receive an :obj:`AxisArray` via `.send(axis_array)`
+        and yields an :obj:`AxisArray` with its data downsampled.
         Note that if a send chunk does not have sufficient samples to reach the
-        next downsample interval then `None` is yielded.
+        next downsample interval then an :obj:`AxisArray` with size-zero data is yielded.
 
     """
     msg_out = AxisArray(np.array([]), dims=[""])

ezmsg/sigproc/filter.py

@@ -38,7 +38,7 @@ def filtergen(
     axis: str, coefs: typing.Optional[typing.Tuple[np.ndarray]], coef_type: str
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
-    Construct a generic filter generator function.
+    Filter data using the provided coefficients.
 
     Args:
         axis: The name of the axis to operate on.
@@ -46,7 +46,8 @@ def filtergen(
         coef_type: The type of filter coefficients. One of "ba" or "sos".
 
     Returns:
-        A generator that expects .send(axis_array) and yields the filtered :obj:`AxisArray`.
+        A primed generator that, when passed an :obj:`AxisArray` via `.send(axis_array)`,
+         yields an :obj:`AxisArray` with the data filtered.
     """
     # Massage inputs
     if coefs is not None and not isinstance(coefs, tuple):
@@ -97,7 +98,10 @@ def filtergen(
                 n_tile = (1,) + n_tile
             zi = np.tile(zi[zi_expand], n_tile)
 
-        dat_out, zi = filt_func(*coefs, msg_in.data, axis=axis_idx, zi=zi)
+        if msg_in.data.size > 0:
+            dat_out, zi = filt_func(*coefs, msg_in.data, axis=axis_idx, zi=zi)
+        else:
+            dat_out = msg_in.data
         msg_out = replace(msg_in, data=dat_out)
 
 

ezmsg/sigproc/filterbank.py

@@ -43,9 +43,9 @@ def filterbank(
     new_axis: str = "kernel",
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
-    Returns a generator that perform multiple (direct or fft) convolutions on a signal using a bank of kernels.
-    This generator is intended to be used during online processing, therefore both direct and fft convolutions
-    use the overlap-add method.
+    Perform multiple (direct or fft) convolutions on a signal using a bank of kernels.
+     This is intended to be used during online processing, therefore both direct and fft convolutions
+     use the overlap-add method.
     Args:
         kernels:
         mode: "conv", "fft", or "auto". If "auto", the mode is determined by the size of the input data.
@@ -59,7 +59,8 @@ def filterbank(
         axis: The name of the axis to operate on. This should usually be "time".
         new_axis: The name of the new axis corresponding to the kernel index.
 
-    Returns:
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the absolute value of the input :obj:`AxisArray` data.
 
     """
     msg_out: typing.Optional[AxisArray] = None
@@ -133,6 +134,7 @@ def filterbank(
                 + msg_in.dims[targ_ax_ix + 1 :]
                 + [new_axis, axis],
                 axes=msg_in.axes.copy(),  # We do not have info for kernel/filter axis :(.
+                key=msg_in.key,
             )
 
             # Determine optimal mode. Assumes 100 msec chunks.

ezmsg/sigproc/math/abs.py

@@ -11,9 +11,15 @@ from ..base import GenAxisArray
 
 @consumer
 def abs() -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    Take the absolute value of the data. See :obj:`np.abs` for more details.
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the absolute value of the input :obj:`AxisArray` data.
+    """
     msg_out = AxisArray(np.array([]), dims=[""])
     while True:
-        msg_in = yield msg_out
+        msg_in: AxisArray = yield msg_out
         msg_out = replace(msg_in, data=np.abs(msg_in.data))
 
 

ezmsg/sigproc/math/clip.py

@@ -11,10 +11,20 @@ from ..base import GenAxisArray
 
 @consumer
 def clip(a_min: float, a_max: float) -> typing.Generator[AxisArray, AxisArray, None]:
-    msg_in = AxisArray(np.array([]), dims=[""])
+    """
+    Clips the data to be within the specified range. See :obj:`np.clip` for more details.
+
+    Args:
+        a_min: Lower clip bound
+        a_max: Upper clip bound
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the clipped version of the input :obj:`AxisArray` data.
+
+    """
     msg_out = AxisArray(np.array([]), dims=[""])
     while True:
-        msg_in = yield msg_out
+        msg_in: AxisArray = yield msg_out
         msg_out = replace(msg_in, data=np.clip(msg_in.data, a_min, a_max))
 
 

ezmsg/sigproc/math/difference.py

@@ -16,6 +16,15 @@ def const_difference(
     """
     result = (in_data - value) if subtrahend else (value - in_data)
     https://en.wikipedia.org/wiki/Template:Arithmetic_operations
+
+    Args:
+        value: number to subtract or be subtracted from the input data
+        subtrahend: If True (default) then value is subtracted from the input data.
+         If False, the input data is subtracted from value.
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the difference between the input :obj:`AxisArray` data and the value.
+
     """
     msg_out = AxisArray(np.array([]), dims=[""])
     while True:

ezmsg/sigproc/math/invert.py

@@ -11,10 +11,16 @@ from ..base import GenAxisArray
 
 @consumer
 def invert() -> typing.Generator[AxisArray, AxisArray, None]:
-    msg_in = AxisArray(np.array([]), dims=[""])
+    """
+    Take the inverse of the data.
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the inversion of the input :obj:`AxisArray` data.
+
+    """
     msg_out = AxisArray(np.array([]), dims=[""])
     while True:
-        msg_in = yield msg_out
+        msg_in: AxisArray = yield msg_out
         msg_out = replace(msg_in, data=1 / msg_in.data)
 
 

ezmsg/sigproc/math/log.py

@@ -12,12 +12,31 @@ from ..base import GenAxisArray
 @consumer
 def log(
     base: float = 10.0,
+    clip_zero: bool = False,
 ) -> typing.Generator[AxisArray, AxisArray, None]:
-    msg_in = AxisArray(np.array([]), dims=[""])
+    """
+    Take the logarithm of the data. See :obj:`np.log` for more details.
+
+    Args:
+        base: The base of the logarithm. Default is 10.
+        clip_zero: If True, clip the data to the minimum positive value of the data type before taking the log.
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the logarithm of the input :obj:`AxisArray` data.
+
+    """
     msg_out = AxisArray(np.array([]), dims=[""])
     log_base = np.log(base)
     while True:
-        msg_in = yield msg_out
+        msg_in: AxisArray = yield msg_out
+        if (
+            clip_zero
+            and np.any(msg_in.data <= 0)
+            and np.issubdtype(msg_in.data.dtype, np.floating)
+        ):
+            msg_in.data = np.clip(
+                msg_in.data, a_min=np.finfo(msg_in.data.dtype).tiny, a_max=None
+            )
         msg_out = replace(msg_in, data=np.log(msg_in.data) / log_base)
 
 

ezmsg/sigproc/math/scale.py

@@ -11,10 +11,19 @@ from ..base import GenAxisArray
 
 @consumer
 def scale(scale: float = 1.0) -> typing.Generator[AxisArray, AxisArray, None]:
-    msg_in = AxisArray(np.array([]), dims=[""])
+    """
+    Scale the data by a constant factor.
+
+    Args:
+        scale: Factor by which to scale the data magnitude.
+
+    Returns: A primed generator that, when passed an input message via `.send(msg)`, yields an :obj:`AxisArray`
+     with the data payload containing the input :obj:`AxisArray` data scaled by a constant factor.
+
+    """
     msg_out = AxisArray(np.array([]), dims=[""])
     while True:
-        msg_in = yield msg_out
+        msg_in: AxisArray = yield msg_out
         msg_out = replace(msg_in, data=scale * msg_in.data)
 
 

ezmsg/sigproc/sampler.py

@@ -43,7 +43,7 @@ def sampler(
     typing.List[SampleMessage], typing.Union[AxisArray, SampleTriggerMessage], None
 ]:
     """
-    A generator function that samples data into a buffer, accepts triggers, and returns slices of sampled
+    Sample data into a buffer, accept triggers, and return slices of sampled
     data around the trigger time.
 
     Args:

ezmsg/sigproc/scaler.py

@@ -33,8 +33,7 @@ def scaler(
     time_constant: float = 1.0, axis: typing.Optional[str] = None
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
-    Create a generator function that applies the
-    adaptive standard scaler from https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/
+    Apply the adaptive standard scaler from https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/
     This is faster than :obj:`scaler_np` for single-channel data.
 
     Args:
@@ -42,8 +41,8 @@ def scaler(
         axis: The name of the axis to accumulate statistics over.
 
     Returns:
-        A primed generator object that expects `.send(axis_array)` and yields a
-        standardized, or "Z-scored" version of the input.
+        A primed generator object that expects to be sent a :obj:`AxisArray` via `.send(axis_array)`
+         and yields an :obj:`AxisArray` with its data being a standardized, or "Z-scored" version of the input data.
     """
     from river import preprocessing
 
@@ -90,8 +89,8 @@ def scaler_np(
         axis: The name of the axis to accumulate statistics over.
 
     Returns:
-        A primed generator object that expects `.send(axis_array)` and yields a
-        standardized, or "Z-scored" version of the input.
+        A primed generator object that expects to be sent a :obj:`AxisArray` via `.send(axis_array)`
+         and yields an :obj:`AxisArray` with its data being a standardized, or "Z-scored" version of the input data.
     """
     msg_out = AxisArray(np.array([]), dims=[""])
 

ezmsg/sigproc/signalinjector.py

@@ -22,6 +22,11 @@ class SignalInjectorState(ez.State):
 
 
 class SignalInjector(ez.Unit):
+    """
+    Add a sinusoidal signal to the input signal. Each feature gets a different amplitude of the sinusoid.
+    All features get the same frequency sinusoid. The frequency and base amplitude can be changed while running.
+    """
+
     SETTINGS = SignalInjectorSettings
     STATE = SignalInjectorState
 

ezmsg/sigproc/slicer.py

@@ -48,6 +48,18 @@ def parse_slice(s: str) -> typing.Tuple[typing.Union[slice, int], ...]:
 def slicer(
     selection: str = "", axis: typing.Optional[str] = None
 ) -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    Slice along a particular axis.
+
+    Args:
+        selection: See :obj:`ezmsg.sigproc.slicer.parse_slice` for details.
+        axis: The name of the axis to slice along. If None, the last axis is used.
+
+    Returns:
+        A primed generator object ready to yield an :obj:`AxisArray` for each .send(axis_array)
+        with the data payload containing a sliced view of the input data.
+
+    """
     msg_out = AxisArray(np.array([]), dims=[""])
 
     # State variables
@@ -98,7 +110,8 @@ def slicer(
                 and hasattr(msg_in.axes[axis], "labels")
                 and len(msg_in.axes[axis].labels) > 0
             ):
-                new_labels = msg_in.axes[axis].labels[_slice]
+                in_labels = np.array(msg_in.axes[axis].labels)
+                new_labels = in_labels[_slice].tolist()
                 new_axis = replace(msg_in.axes[axis], labels=new_labels)
 
         replace_kwargs = {}

ezmsg/sigproc/spectrogram.py

@@ -33,13 +33,17 @@ def spectrogram(
         output: See :obj:`ezmsg.sigproc.spectrum.spectrum`
 
     Returns:
-        A primed generator object that expects `.send(axis_array)` of continuous data
-        and yields an AxisArray of time-frequency power values.
+        A primed generator object that expects an :obj:`AxisArray` via `.send(axis_array)`
+        with continuous data in its .data payload, and yields an :obj:`AxisArray` of time-frequency power values.
     """
 
     pipeline = compose(
         windowing(
-            axis="time", newaxis="win", window_dur=window_dur, window_shift=window_shift
+            axis="time",
+            newaxis="win",
+            window_dur=window_dur,
+            window_shift=window_shift,
+            zero_pad_until="shift" if window_shift is not None else "input",
         ),
         spectrum(axis="time", window=window, transform=transform, output=output),
         modify_axis(name_map={"win": "time"}),

ezmsg/sigproc/spectrum.py

@@ -92,8 +92,8 @@ def spectrum(
         nfft: The number of points to use for the FFT. If None, the length of the input data is used.
 
     Returns:
-        A primed generator object that expects `.send(axis_array)` of continuous data
-        and yields an AxisArray of spectral magnitudes or powers.
+        A primed generator object that expects an :obj:`AxisArray` via `.send(axis_array)` containing continuous data
+        and yields an :obj:`AxisArray` with data of spectral magnitudes or powers.
     """
     msg_out = AxisArray(np.array([]), dims=[""])
 

ezmsg/sigproc/wavelets.py

@@ -20,8 +20,8 @@ def cwt(
     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.
+    Perform a continuous wavelet transform.
+    The function is equivalent to the :obj:`pywt.cwt` function, but is designed to work with streaming data.
 
     Args:
         scales: The wavelet scales to use.
@@ -31,7 +31,8 @@ def cwt(
           because fft and matrix multiplication is much faster on the last axis.
 
     Returns:
-        A Generator object that expects `.send(axis_array)` of continuous data
+        A primed Generator object that expects an :obj:`AxisArray` via `.send(axis_array)` of continuous data
+        and yields an :obj:`AxisArray` with a continuous wavelet transform in its data.
     """
     msg_out: typing.Optional[AxisArray] = None
 
@@ -114,6 +115,7 @@ def cwt(
                     **msg_in.axes,
                     "freq": AxisArray.Axis("Hz", offset=freqs[0], gain=fstep),
                 },
+                key=msg_in.key,
             )
             last_conv_samp = np.zeros(
                 dummy_shape[:-1] + (1,), dtype=template.data.dtype

ezmsg/sigproc/window.py

@@ -24,7 +24,9 @@ def windowing(
     zero_pad_until: str = "input",
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
-    Construct a generator that yields windows of data from an input :obj:`AxisArray`.
+    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.
@@ -48,8 +50,8 @@ def windowing(
             - "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.
+        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:
@@ -77,7 +79,7 @@ def windowing(
     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
+    out_dims: typing.Optional[typing.List[str]] = None
 
     check_inputs = {"samp_shape": None, "fs": None, "key": None}
 
@@ -123,11 +125,12 @@ def windowing(
             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(
+            init_buffer_shape = (
                 msg_in.data.shape[:axis_idx]
                 + (n_zero,)
                 + msg_in.data.shape[axis_idx + 1 :]
             )
+            buffer = np.zeros(init_buffer_shape, dtype=msg_in.data.dtype)
 
         # Add new data to buffer.
         # Currently, we concatenate the new time samples and clip the output.
@@ -174,10 +177,14 @@ def windowing(
         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_dat = buffer.reshape(
+                buffer.shape[:axis_idx] + (1,) + buffer.shape[axis_idx:]
+            )
             out_newaxis = replace(out_newaxis, offset=buffer_offset[-window_samples])
         elif buffer.shape[axis_idx] >= 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

{ezmsg_sigproc-1.3.2.dist-info → ezmsg_sigproc-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ezmsg-sigproc
-Version: 1.3.2
+Version: 1.4.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

ezmsg_sigproc-1.4.1.dist-info/RECORD

@@ -0,0 +1,35 @@
+ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
+ezmsg/sigproc/__version__.py,sha256=oFZsPxoSsCY6D2DiWMSueNvMDRRQN5ssWrPdQtlLJ_o,411
+ezmsg/sigproc/activation.py,sha256=amvVjO-1BcChgK0VQi44i7-Tmz_2FK1xb-BTC52_DO0,2642
+ezmsg/sigproc/affinetransform.py,sha256=a5xt6LSymlV3gNSdCjWdtUoi9kOkWiYx6oeiGEIphYI,8802
+ezmsg/sigproc/aggregate.py,sha256=Wnvz1xXDQhdVkTfVPOmhdmjgIhR_YQhioo8Dwh4BaoE,5615
+ezmsg/sigproc/bandpower.py,sha256=QPktf3v7sojDHhwUVcK3UNPU-Dm4sf2QQw3qmYWZ1r0,2228
+ezmsg/sigproc/base.py,sha256=vut0BLjgc0mxYRbs7tDd9XzwRFA2_GcsgXZmIYovR0Y,1248
+ezmsg/sigproc/butterworthfilter.py,sha256=vTESZAAcQhWLI8yIMOApsGAYgjv2ekCZsTIliFjEkc8,5345
+ezmsg/sigproc/decimate.py,sha256=zNxJXauE4Z54Yy7tpN9_oJuW0I0ppQRWhSpwb3Ri2gc,1473
+ezmsg/sigproc/downsample.py,sha256=0TOhWkg7B9g3FDcewHINZiNuo28JyXRtgTYvZ7C8ImM,3384
+ezmsg/sigproc/ewmfilter.py,sha256=XzTmouRa7AnPjTiI32-oumwm4ZfOl6uPPUSldExNpAs,4516
+ezmsg/sigproc/filter.py,sha256=x3ytFowxg4O0QFQeMDFmQieV86H-6Q3Mkt3ThRIOh60,8301
+ezmsg/sigproc/filterbank.py,sha256=Rhs7AKWy36lrMlzftEbYPXPW-FwZZ-QUCEp_QFG9mFU,12443
+ezmsg/sigproc/messages.py,sha256=KpYCWWRD5itVAq0-Lf8qd7ErEE1A9qdm2p7O8Y4zEFA,955
+ezmsg/sigproc/sampler.py,sha256=Zv5eq9CLpE8ui4HyZzBEqxwqBf--IbexS7zBx3qKp3w,12733
+ezmsg/sigproc/scaler.py,sha256=2Hi4XWWvUtPOVOfIyX0Dr0cZEdbTobZOoMXKh9Vszlk,5944
+ezmsg/sigproc/signalinjector.py,sha256=T1yvigk9WYujYqubd15UAF6hNmSqS9J7rCzaPYENoEA,2644
+ezmsg/sigproc/slicer.py,sha256=ffawSqhO06lC5TXg_Ujg0eP2EuF98McQiUdlwxn3psI,5072
+ezmsg/sigproc/spectral.py,sha256=_2qO6as4Nesmc9V1WW2EXNMH5pPz8aVTEcIPOi4-g2o,322
+ezmsg/sigproc/spectrogram.py,sha256=16By4VWln7UvZ8IV_TdNAFaJDgkzvVKXWpnsoZoiW1M,3146
+ezmsg/sigproc/spectrum.py,sha256=a75d6q6o3dAuqX6ZuFv6AfHYDOMuhA01OVCugzFMUSQ,9415
+ezmsg/sigproc/synth.py,sha256=ygJRI9Seqhrg13lUhcA6XSpxcEr3LL1NupviSQLrC9o,18351
+ezmsg/sigproc/wavelets.py,sha256=_3jI52NzksD1WNnHx03F2p4V2uGN_MtBbLsJGRjeyoE,6596
+ezmsg/sigproc/window.py,sha256=A697XG2YyR9ywmzfxJIXovi6wPwDhBI9UUeShNJFKgM,13094
+ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/math/abs.py,sha256=hqS_sbLqAKSlguj3_rsfeWzOe6233tMxXfjDPg1fi2g,918
+ezmsg/sigproc/math/clip.py,sha256=xIfc6fEfiNh7ILG3IYxcuCd5VBqmWXmDliGi_dKVJpM,1131
+ezmsg/sigproc/math/difference.py,sha256=s3al1WzUZXsG2XYzOprRcKP-VD9J5FwYx578_SKG0vg,2183
+ezmsg/sigproc/math/invert.py,sha256=H8df1u8OVb5TOkRC8p5EW7R17kHdLOYqXVH_axy5bkI,882
+ezmsg/sigproc/math/log.py,sha256=1wuPvdjiI29tC_gRSntfpAebJ0rDhlapyLjG5QwXRpo,1496
+ezmsg/sigproc/math/scale.py,sha256=iIQuJAr5pzCiMqzi2YdzLc1agQBKBOcngdNZlLO3X_o,1050
+ezmsg_sigproc-1.4.1.dist-info/METADATA,sha256=ba6ETetMm_XUgNkyMcGTgeVItvVZWd9QEzPpYkh0e3s,2376
+ezmsg_sigproc-1.4.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ezmsg_sigproc-1.4.1.dist-info/licenses/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-1.4.1.dist-info/RECORD,,

ezmsg_sigproc-1.3.2.dist-info/RECORD

@@ -1,35 +0,0 @@
-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,,