ezmsg-sigproc 1.3.2__tar.gz → 1.4.1__tar.gz

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/PKG-INFO

@@ -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.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.4.1/src/ezmsg/sigproc/math/log.py

@@ -0,0 +1,51 @@
+from dataclasses import replace
+import typing
+
+import numpy as np
+import ezmsg.core as ez
+from ezmsg.util.generator import consumer
+from ezmsg.util.messages.axisarray import AxisArray
+
+from ..base import GenAxisArray
+
+
+@consumer
+def log(
+    base: float = 10.0,
+    clip_zero: bool = False,
+) -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    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: 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)
+
+
+class LogSettings(ez.Settings):
+    base: float = 10.0
+
+
+class Log(GenAxisArray):
+    SETTINGS = LogSettings
+
+    def construct_generator(self):
+        self.STATE.gen = log(base=self.SETTINGS.base)

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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-1.3.2 → ezmsg_sigproc-1.4.1}/src/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 → ezmsg_sigproc-1.4.1}/tests/test_affine_transform.py

@@ -1,5 +1,7 @@
 import copy
+from dataclasses import dataclass, field
 from pathlib import Path
+import typing
 
 import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray
@@ -9,11 +11,33 @@ from ezmsg.sigproc.affinetransform import affine_transform, common_rereference
 from util import assert_messages_equal
 
 
+# Define a custom Axis class that has a `labels` attribute
+@dataclass
+class CustomAxis(AxisArray.Axis):
+    labels: typing.List[str] = field(default_factory=lambda: [])
+
+    @classmethod
+    def SpaceAxis(
+        cls, labels: typing.List[str]
+    ):  # , locs: typing.Optional[npt.NDArray] = None):
+        return cls(unit="mm", labels=labels)
+
+
+# Monkey-patch AxisArray with our customized Axis
+AxisArray.Axis = CustomAxis
+
+
 def test_affine_generator():
     n_times = 13
     n_chans = 64
     in_dat = np.arange(n_times * n_chans).reshape(n_times, n_chans)
-    msg_in = AxisArray(in_dat, dims=["time", "ch"])
+    msg_in = AxisArray(
+        data=in_dat,
+        dims=["time", "ch"],
+        axes={
+            "ch": AxisArray.Axis.SpaceAxis(labels=[f"ch_{i}" for i in range(n_chans)])
+        },
+    )
 
     backup = [copy.deepcopy(msg_in)]
 
@@ -25,33 +49,38 @@ def test_affine_generator():
 
     assert_messages_equal([msg_in], backup)
 
+    # Send again just to make sure the generator doesn't crash
+    _ = gen.send(msg_in)
+
     # Test with weights from a CSV file.
     csv_path = Path(__file__).parent / "resources" / "xform.csv"
     weights = np.loadtxt(csv_path, delimiter=",")
     expected_out = in_dat @ weights.T
     # Same result: expected_out = np.vstack([(step[None, :] * weights).sum(axis=1) for step in in_dat])
 
-    # Send again just to make sure the generator doesn't crash
-    _ = gen.send(msg_in)
-
     gen = affine_transform(weights=csv_path, axis="ch", right_multiply=False)
     msg_out = gen.send(msg_in)
     assert np.allclose(msg_out.data, expected_out)
+    assert len(msg_out.axes["ch"].labels) == weights.shape[0]
+    assert msg_out.axes["ch"].labels[:-1] == msg_in.axes["ch"].labels
 
     # Try again as str, not Path
     gen = affine_transform(weights=str(csv_path), axis="ch", right_multiply=False)
     msg_out = gen.send(msg_in)
     assert np.allclose(msg_out.data, expected_out)
+    assert len(msg_out.axes["ch"].labels) == weights.shape[0]
 
     # Try again as direct ndarray
     gen = affine_transform(weights=weights, axis="ch", right_multiply=False)
     msg_out = gen.send(msg_in)
     assert np.allclose(msg_out.data, expected_out)
+    assert len(msg_out.axes["ch"].labels) == weights.shape[0]
 
     # One more time, but we pre-transpose the weights and do not override right_multiply
     gen = affine_transform(weights=weights.T, axis="ch", right_multiply=True)
     msg_out = gen.send(msg_in)
     assert np.allclose(msg_out.data, expected_out)
+    assert len(msg_out.axes["ch"].labels) == weights.shape[0]
 
 
 def test_affine_passthrough():

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/tests/test_aggregate.py

@@ -37,7 +37,12 @@ def get_msg_gen(n_chans=20, n_freqs=100, data_dur=30.0, fs=1024.0, key=""):
 
 @pytest.mark.parametrize(
     "agg_func",
-    [AggregationFunction.MEAN, AggregationFunction.MEDIAN, AggregationFunction.STD],
+    [
+        AggregationFunction.MEAN,
+        AggregationFunction.MEDIAN,
+        AggregationFunction.STD,
+        AggregationFunction.SUM,
+    ],
 )
 def test_aggregate(agg_func: AggregationFunction):
     bands = [(5.0, 20.0), (30.0, 50.0)]
@@ -74,6 +79,7 @@ def test_aggregate(agg_func: AggregationFunction):
         AggregationFunction.MEAN: partial(np.mean, axis=-1, keepdims=True),
         AggregationFunction.MEDIAN: partial(np.median, axis=-1, keepdims=True),
         AggregationFunction.STD: partial(np.std, axis=-1, keepdims=True),
+        AggregationFunction.SUM: partial(np.sum, axis=-1, keepdims=True),
     }[agg_func]
     expected_data = np.concatenate(
         [

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/tests/test_butter.py

@@ -138,3 +138,20 @@ def test_butterworth(
 
     result = np.concatenate([gen.send(_).data for _ in messages], axis=time_ax)
     assert np.allclose(result, out_dat)
+
+
+def test_butterworth_empty_msg():
+    proc = butter(
+        axis="time",
+        order=2,
+        cuton=0.1,
+        cutoff=1.0,
+        coef_type="sos",
+    )
+    msg_in = AxisArray(
+        data=np.zeros((0, 2)),
+        dims=["time", "ch"],
+        axes={"time": AxisArray.Axis.TimeAxis(fs=19.0, offset=0)},
+    )
+    res = proc.send(msg_in)
+    assert res.data.size == 0

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/tests/test_filterbank.py

@@ -63,6 +63,7 @@ def test_filterbank(mode: str, kernel_type: str):
                 data=chirp[:, idx : idx + step_size],
                 dims=["ch", "time"],
                 axes={"time": AxisArray.Axis.TimeAxis(offset=tvec[idx], fs=fs)},
+                key="test_filterbank",
             )
         )
 
@@ -91,6 +92,7 @@ def test_filterbank(mode: str, kernel_type: str):
     # Pass the messages
     out_messages = [gen.send(msg_in) for msg_in in in_messages]
     result = AxisArray.concatenate(*out_messages, dim="time")
+    assert result.key == "test_filterbank"
 
     # Compare to sps.oaconvolve(chirp), with the following differences:
     #  - conv has transients at the beginning that we need to skip over

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/tests/test_math.py

@@ -62,13 +62,17 @@ def test_invert():
 
 
 @pytest.mark.parametrize("base", [np.e, 2, 10])
-def test_log(base: float):
+@pytest.mark.parametrize("dtype", [int, float])
+@pytest.mark.parametrize("clip", [False, True])
+def test_log(base: float, dtype, clip: bool):
     n_times = 130
     n_chans = 255
-    in_dat = np.arange(n_times * n_chans).reshape(n_times, n_chans)
+    in_dat = np.arange(n_times * n_chans).reshape(n_times, n_chans).astype(dtype)
     msg_in = AxisArray(in_dat, dims=["time", "ch"])
-    proc = log(base)
+    proc = log(base, clip_zero=clip)
     msg_out = proc.send(msg_in)
+    if clip and dtype is float:
+        in_dat = np.clip(in_dat, a_min=np.finfo(msg_in.data.dtype).tiny, a_max=None)
     assert np.array_equal(msg_out.data, np.log(in_dat) / np.log(base))
 
 

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/tests/test_slicer.py

@@ -1,13 +1,31 @@
 import copy
+from dataclasses import dataclass, field
+import typing
 
 import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray
+import pytest
 
 from ezmsg.sigproc.slicer import slicer, parse_slice
 
 from util import assert_messages_equal
 
 
+@dataclass
+class CustomAxis(AxisArray.Axis):
+    labels: typing.List[str] = field(default_factory=lambda: [])
+
+    @classmethod
+    def SpaceAxis(
+        cls, labels: typing.List[str]
+    ):  # , locs: typing.Optional[npt.NDArray] = None):
+        return cls(unit="mm", labels=labels)
+
+
+# Monkey-patch AxisArray with our customized Axis
+AxisArray.Axis = CustomAxis
+
+
 def test_parse_slice():
     assert parse_slice("") == (slice(None),)
     assert parse_slice(":") == (slice(None),)
@@ -76,3 +94,31 @@ def test_slicer_gen_drop_dim():
     assert_messages_equal([msg_in], backup)
     assert msg_out.data.shape == (n_times,)
     assert np.array_equal(msg_out.data, msg_in.data[:, 5])
+
+
+@pytest.mark.parametrize("selection", [":3", "0, 1, 2"])
+def test_slicer_label(selection: str):
+    """
+    We use the monkey-patched AxisArray `labels` field that exists in several other ezmsg
+    modules that generate data.
+    """
+    n_times = 50
+    n_chans = 10
+    in_dat = np.arange(n_times * n_chans).reshape(n_times, n_chans)
+    msg_in = AxisArray(
+        in_dat,
+        dims=["time", "ch"],
+        axes={
+            "time": AxisArray.Axis.TimeAxis(fs=100.0, offset=0.1),
+            "ch": CustomAxis.SpaceAxis(labels=[str(_) for _ in range(n_chans)]),
+        },
+    )
+    backup = [copy.deepcopy(msg_in)]
+
+    gen = slicer(selection=selection, axis="ch")
+    # gen = slicer(selection=":3", axis="ch")
+    msg_out = gen.send(msg_in)
+    assert_messages_equal([msg_in], backup)
+    assert msg_out.data.shape == (n_times, 3)
+    assert np.array_equal(msg_out.data, msg_in.data[:, :3])
+    assert msg_out.axes["ch"].labels == msg_in.axes["ch"].labels[:3]

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/tests/test_wavelets.py

@@ -89,6 +89,7 @@ def test_cwt():
                 data=chirp[:, idx : idx + step_size],
                 dims=["ch", "time"],
                 axes={"time": AxisArray.Axis.TimeAxis(offset=tvec[idx], fs=fs)},
+                key="test_cwt",
             )
         )
 
@@ -106,6 +107,7 @@ def test_cwt():
     out_messages = [gen.send(in_messages[0])]
     out_messages += [gen.send(msg_in) for msg_in in in_messages[1:]]
     result = AxisArray.concatenate(*out_messages, dim="time")
+    assert result.key == "test_cwt"
 
     # TODO: Compare result to expected
 

{ezmsg_sigproc-1.3.2 → ezmsg_sigproc-1.4.1}/uv.lock

@@ -125,7 +125,7 @@ wheels = [
 
 [[package]]
 name = "ezmsg-sigproc"
-version = "1.3.2.dev0+g021511b.d20240926"
+version = "1.3.3.dev10+g5aaad7f.d20241101"
 source = { editable = "." }
 dependencies = [
     { name = "ezmsg" },

ezmsg_sigproc-1.3.2/src/ezmsg/sigproc/math/log.py

@@ -1,32 +0,0 @@
-from dataclasses import replace
-import typing
-
-import numpy as np
-import ezmsg.core as ez
-from ezmsg.util.generator import consumer
-from ezmsg.util.messages.axisarray import AxisArray
-
-from ..base import GenAxisArray
-
-
-@consumer
-def log(
-    base: float = 10.0,
-) -> typing.Generator[AxisArray, AxisArray, None]:
-    msg_in = AxisArray(np.array([]), dims=[""])
-    msg_out = AxisArray(np.array([]), dims=[""])
-    log_base = np.log(base)
-    while True:
-        msg_in = yield msg_out
-        msg_out = replace(msg_in, data=np.log(msg_in.data) / log_base)
-
-
-class LogSettings(ez.Settings):
-    base: float = 10.0
-
-
-class Log(GenAxisArray):
-    SETTINGS = LogSettings
-
-    def construct_generator(self):
-        self.STATE.gen = log(base=self.SETTINGS.base)