ezmsg-sigproc 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

ezmsg/sigproc/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.7.0'
-__version_tuple__ = version_tuple = (2, 7, 0)
+__version__ = version = '2.9.0'
+__version_tuple__ = version_tuple = (2, 9, 0)
 
 __commit_id__ = commit_id = None

ezmsg/sigproc/affinetransform.py

@@ -1,3 +1,13 @@
+"""Affine transformations via matrix multiplication: y = Ax or y = Ax + B.
+
+For full matrix transformations where channels are mixed (off-diagonal weights),
+use :obj:`AffineTransformTransformer` or the `AffineTransform` unit.
+
+For simple per-channel scaling and offset (diagonal weights only), use
+:obj:`LinearTransformTransformer` from :mod:`ezmsg.sigproc.linear` instead,
+which is more efficient as it avoids matrix multiplication.
+"""
+
 import os
 from pathlib import Path
 
@@ -17,7 +27,6 @@ from ezmsg.util.messages.util import replace
 class AffineTransformSettings(ez.Settings):
     """
     Settings for :obj:`AffineTransform`.
-    See :obj:`affine_transform` for argument details.
     """
 
     weights: np.ndarray | str | Path
@@ -39,6 +48,19 @@ class AffineTransformState:
 class AffineTransformTransformer(
     BaseStatefulTransformer[AffineTransformSettings, AxisArray, AxisArray, AffineTransformState]
 ):
+    """Apply affine transformation via matrix multiplication: y = Ax or y = Ax + B.
+
+    Use this transformer when you need full matrix transformations that mix
+    channels (off-diagonal weights), such as spatial filters or projections.
+
+    For simple per-channel scaling and offset where each output channel depends
+    only on its corresponding input channel (diagonal weight matrix), use
+    :obj:`LinearTransformTransformer` instead, which is more efficient.
+
+    The weights matrix can include an offset row (stacked as [A|B]) where the
+    input is automatically augmented with a column of ones to compute y = Ax + B.
+    """
+
     def __call__(self, message: AxisArray) -> AxisArray:
         # Override __call__ so we can shortcut if weights are None.
         if self.settings.weights is None or (

ezmsg/sigproc/aggregate.py

@@ -1,3 +1,12 @@
+"""
+Aggregation operations over arrays.
+
+.. note::
+    :obj:`AggregateTransformer` supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+    :obj:`RangedAggregateTransformer` currently requires NumPy arrays.
+"""
+
 import typing
 
 import ezmsg.core as ez

ezmsg/sigproc/butterworthzerophase.py

@@ -4,10 +4,10 @@ import typing
 import ezmsg.core as ez
 import numpy as np
 import scipy.signal
+from ezmsg.baseproc import SettingsType
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ezmsg.sigproc.base import SettingsType
 from ezmsg.sigproc.butterworthfilter import ButterworthFilterSettings, butter_design_fun
 from ezmsg.sigproc.filter import (
     BACoeffs,

ezmsg/sigproc/coordinatespaces.py

@@ -3,6 +3,10 @@ Coordinate space transformations for streaming data.
 
 This module provides utilities and ezmsg nodes for transforming between
 Cartesian (x, y) and polar (r, theta) coordinate systems.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
 """
 
 from enum import Enum
@@ -11,6 +15,7 @@ from typing import Tuple
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
+from array_api_compat import get_namespace, is_array_api_obj
 from ezmsg.baseproc import (
     BaseTransformer,
     BaseTransformerUnit,
@@ -20,14 +25,24 @@ from ezmsg.util.messages.axisarray import AxisArray, replace
 # -- Utility functions for coordinate transformations --
 
 
+def _get_namespace_or_numpy(*args: npt.ArrayLike):
+    """Get array namespace if any arg is an array, otherwise return numpy."""
+    for arg in args:
+        if is_array_api_obj(arg):
+            return get_namespace(arg)
+    return np
+
+
 def polar2z(r: npt.ArrayLike, theta: npt.ArrayLike) -> npt.ArrayLike:
     """Convert polar coordinates to complex number representation."""
-    return r * np.exp(1j * theta)
+    xp = _get_namespace_or_numpy(r, theta)
+    return r * xp.exp(1j * theta)
 
 
 def z2polar(z: npt.ArrayLike) -> Tuple[npt.ArrayLike, npt.ArrayLike]:
     """Convert complex number to polar coordinates (r, theta)."""
-    return np.abs(z), np.angle(z)
+    xp = _get_namespace_or_numpy(z)
+    return xp.abs(z), xp.atan2(xp.imag(z), xp.real(z))
 
 
 def cart2z(x: npt.ArrayLike, y: npt.ArrayLike) -> npt.ArrayLike:
@@ -37,7 +52,8 @@ def cart2z(x: npt.ArrayLike, y: npt.ArrayLike) -> npt.ArrayLike:
 
 def z2cart(z: npt.ArrayLike) -> Tuple[npt.ArrayLike, npt.ArrayLike]:
     """Convert complex number to Cartesian coordinates (x, y)."""
-    return np.real(z), np.imag(z)
+    xp = _get_namespace_or_numpy(z)
+    return xp.real(z), xp.imag(z)
 
 
 def cart2pol(x: npt.ArrayLike, y: npt.ArrayLike) -> Tuple[npt.ArrayLike, npt.ArrayLike]:
@@ -90,6 +106,7 @@ class CoordinateSpacesTransformer(BaseTransformer[CoordinateSpacesSettings, Axis
     """
 
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
         axis = self.settings.axis or message.dims[-1]
         axis_idx = message.get_axis_idx(axis)
 
@@ -116,9 +133,9 @@ class CoordinateSpacesTransformer(BaseTransformer[CoordinateSpacesSettings, Axis
             out_a, out_b = pol2cart(component_a, component_b)
 
         # Stack results back along the same axis
-        result = np.stack([out_a, out_b], axis=axis_idx)
+        result = xp.stack([out_a, out_b], axis=axis_idx)
 
-        # Update axis labels if present
+        # Update axis labels if present (use numpy for string labels)
         axes = message.axes
         if axis in axes and hasattr(axes[axis], "data"):
             if self.settings.mode == CoordinateMode.CART2POL:

ezmsg/sigproc/denormalize.py

@@ -1,14 +1,13 @@
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-
-from ezmsg.sigproc.base import (
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 
 class DenormalizeSettings(ez.Settings):

ezmsg/sigproc/detrend.py

@@ -1,7 +1,7 @@
 import scipy.signal as sps
+from ezmsg.baseproc import BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray, replace
 
-from ezmsg.sigproc.base import BaseTransformerUnit
 from ezmsg.sigproc.ewma import EWMASettings, EWMATransformer
 
 

ezmsg/sigproc/diff.py

@@ -1,14 +1,22 @@
+"""
+Compute differences along an axis.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
+
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-from ezmsg.util.messages.axisarray import AxisArray, slice_along_axis
-from ezmsg.util.messages.util import replace
-
-from ezmsg.sigproc.base import (
+from array_api_compat import get_namespace
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray, slice_along_axis
+from ezmsg.util.messages.util import replace
 
 
 class DiffSettings(ez.Settings):
@@ -40,23 +48,25 @@ class DiffTransformer(BaseStatefulTransformer[DiffSettings, AxisArray, AxisArray
                     self.state.last_time = ax_info.data[0] - 0.001
 
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
         axis = self.settings.axis or message.dims[0]
         ax_idx = message.get_axis_idx(axis)
 
-        diffs = np.diff(
-            np.concatenate((self.state.last_dat, message.data), axis=ax_idx),
+        diffs = xp.diff(
+            xp.concat((self.state.last_dat, message.data), axis=ax_idx),
             axis=ax_idx,
         )
         # Prepare last_dat for next iteration
         self.state.last_dat = slice_along_axis(message.data, slice(-1, None), axis=ax_idx)
-        # Scale by fs if requested. This convers the diff to a derivative. e.g., diff of position becomes velocity.
+        # Scale by fs if requested. This converts the diff to a derivative. e.g., diff of position becomes velocity.
         if self.settings.scale_by_fs:
             ax_info = message.get_axis(axis)
             if hasattr(ax_info, "data"):
+                # ax_info.data is typically numpy for metadata, so use np.diff here
                 dt = np.diff(np.concatenate(([self.state.last_time], ax_info.data)))
                 # Expand dt dims to match diffs
                 exp_sl = (None,) * ax_idx + (Ellipsis,) + (None,) * (message.data.ndim - ax_idx - 1)
-                diffs /= dt[exp_sl]
+                diffs /= xp.asarray(dt[exp_sl])
                 self.state.last_time = ax_info.data[-1]  # For next iteration
             else:
                 diffs /= ax_info.gain

ezmsg/sigproc/ewma.py

@@ -139,8 +139,15 @@ class EWMA_Deprecated:
 
 class EWMASettings(ez.Settings):
     time_constant: float = 1.0
+    """The amount of time for the smoothed response of a unit step function to reach 1 - 1/e approx-eq 63.2%."""
+
     axis: str | None = None
 
+    accumulate: bool = True
+    """If True, update the EWMA state with each sample. If False, only apply
+    the current EWMA estimate without updating state (useful for inference
+    periods where you don't want to adapt statistics)."""
+
 
 @processor_state
 class EWMAState:
@@ -166,15 +173,45 @@ class EWMATransformer(BaseStatefulTransformer[EWMASettings, AxisArray, AxisArray
             return message
         axis = self.settings.axis or message.dims[0]
         axis_idx = message.get_axis_idx(axis)
-        expected, self._state.zi = sps.lfilter(
-            [self._state.alpha],
-            [1.0, self._state.alpha - 1.0],
-            message.data,
-            axis=axis_idx,
-            zi=self._state.zi,
-        )
+        if self.settings.accumulate:
+            # Normal behavior: update state with new samples
+            expected, self._state.zi = sps.lfilter(
+                [self._state.alpha],
+                [1.0, self._state.alpha - 1.0],
+                message.data,
+                axis=axis_idx,
+                zi=self._state.zi,
+            )
+        else:
+            # Process-only: compute output without updating state
+            expected, _ = sps.lfilter(
+                [self._state.alpha],
+                [1.0, self._state.alpha - 1.0],
+                message.data,
+                axis=axis_idx,
+                zi=self._state.zi,
+            )
         return replace(message, data=expected)
 
 
 class EWMAUnit(BaseTransformerUnit[EWMASettings, AxisArray, AxisArray, EWMATransformer]):
     SETTINGS = EWMASettings
+
+    @ez.subscriber(BaseTransformerUnit.INPUT_SETTINGS)
+    async def on_settings(self, msg: EWMASettings) -> None:
+        """
+        Handle settings updates with smart reset behavior.
+
+        Only resets state if `axis` changes (structural change).
+        Changes to `time_constant` or `accumulate` are applied without
+        resetting accumulated state.
+        """
+        old_axis = self.SETTINGS.axis
+        self.apply_settings(msg)
+
+        if msg.axis != old_axis:
+            # Axis changed - need full reset
+            self.create_processor()
+        else:
+            # Only accumulate or time_constant changed - keep state
+            self.processor.settings = msg

ezmsg/sigproc/extract_axis.py

@@ -1,9 +1,8 @@
 import ezmsg.core as ez
 import numpy as np
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray, replace
 
-from ezmsg.sigproc.base import BaseTransformer, BaseTransformerUnit
-
 
 class ExtractAxisSettings(ez.Settings):
     axis: str = "freq"

ezmsg/sigproc/filter.py

@@ -6,10 +6,7 @@ import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
 import scipy.signal
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-
-from ezmsg.sigproc.base import (
+from ezmsg.baseproc import (
     BaseConsumerUnit,
     BaseStatefulTransformer,
     BaseTransformerUnit,
@@ -17,6 +14,8 @@ from ezmsg.sigproc.base import (
     TransformerType,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 
 @dataclass

ezmsg/sigproc/fir_hilbert.py

@@ -4,10 +4,10 @@ import typing
 import ezmsg.core as ez
 import numpy as np
 import scipy.signal as sps
+from ezmsg.baseproc import BaseStatefulTransformer, processor_state
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ezmsg.sigproc.base import BaseStatefulTransformer, processor_state
 from ezmsg.sigproc.filter import (
     BACoeffs,
     BaseFilterByDesignTransformerUnit,

ezmsg/sigproc/linear.py

@@ -0,0 +1,120 @@
+"""
+Apply a linear transformation: output = scale * input + offset.
+
+Supports per-element scale and offset along a specified axis.
+For full matrix transformations, use :obj:`AffineTransformTransformer` instead.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
+
+import ezmsg.core as ez
+import numpy as np
+import numpy.typing as npt
+from array_api_compat import get_namespace
+from ezmsg.baseproc import BaseStatefulTransformer, BaseTransformerUnit, processor_state
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
+
+class LinearTransformSettings(ez.Settings):
+    scale: float | list[float] | npt.ArrayLike = 1.0
+    """Scale factor(s). Can be a scalar (applied to all elements) or an array
+    matching the size of the specified axis for per-element scaling."""
+
+    offset: float | list[float] | npt.ArrayLike = 0.0
+    """Offset value(s). Can be a scalar (applied to all elements) or an array
+    matching the size of the specified axis for per-element offset."""
+
+    axis: str | None = None
+    """Axis along which to apply per-element scale/offset. If None, scalar
+    scale/offset are broadcast to all elements."""
+
+
+@processor_state
+class LinearTransformState:
+    scale: npt.NDArray = None
+    """Prepared scale array for broadcasting."""
+
+    offset: npt.NDArray = None
+    """Prepared offset array for broadcasting."""
+
+
+class LinearTransformTransformer(
+    BaseStatefulTransformer[LinearTransformSettings, AxisArray, AxisArray, LinearTransformState]
+):
+    """Apply linear transformation: output = scale * input + offset.
+
+    This transformer is optimized for element-wise linear operations with
+    optional per-channel (or per-axis) coefficients. For full matrix
+    transformations, use :obj:`AffineTransformTransformer` instead.
+
+    Examples:
+        # Uniform scaling and offset
+        >>> transformer = LinearTransformTransformer(LinearTransformSettings(scale=2.0, offset=1.0))
+
+        # Per-channel scaling (e.g., for 3-channel data along "ch" axis)
+        >>> transformer = LinearTransformTransformer(LinearTransformSettings(
+        ...     scale=[0.5, 1.0, 2.0],
+        ...     offset=[0.0, 0.1, 0.2],
+        ...     axis="ch"
+        ... ))
+    """
+
+    def _hash_message(self, message: AxisArray) -> int:
+        """Hash based on shape and axis to detect when broadcast shapes need recalculation."""
+        axis = self.settings.axis
+        if axis is not None:
+            axis_idx = message.get_axis_idx(axis)
+            return hash((message.data.ndim, axis_idx, message.data.shape[axis_idx]))
+        return hash(message.data.ndim)
+
+    def _reset_state(self, message: AxisArray) -> None:
+        """Prepare scale/offset arrays with proper broadcast shapes."""
+        xp = get_namespace(message.data)
+        ndim = message.data.ndim
+
+        scale = self.settings.scale
+        offset = self.settings.offset
+
+        # Convert settings to arrays
+        if isinstance(scale, (list, np.ndarray)):
+            scale = xp.asarray(scale, dtype=xp.float64)
+        else:
+            # Scalar: create a 0-d array
+            scale = xp.asarray(float(scale), dtype=xp.float64)
+
+        if isinstance(offset, (list, np.ndarray)):
+            offset = xp.asarray(offset, dtype=xp.float64)
+        else:
+            # Scalar: create a 0-d array
+            offset = xp.asarray(float(offset), dtype=xp.float64)
+
+        # If axis is specified and we have 1-d arrays, reshape for proper broadcasting
+        if self.settings.axis is not None and ndim > 0:
+            axis_idx = message.get_axis_idx(self.settings.axis)
+
+            if scale.ndim == 1:
+                # Create shape for broadcasting: all 1s except at axis_idx
+                broadcast_shape = [1] * ndim
+                broadcast_shape[axis_idx] = scale.shape[0]
+                scale = xp.reshape(scale, broadcast_shape)
+
+            if offset.ndim == 1:
+                broadcast_shape = [1] * ndim
+                broadcast_shape[axis_idx] = offset.shape[0]
+                offset = xp.reshape(offset, broadcast_shape)
+
+        self._state.scale = scale
+        self._state.offset = offset
+
+    def _process(self, message: AxisArray) -> AxisArray:
+        result = message.data * self._state.scale + self._state.offset
+        return replace(message, data=result)
+
+
+class LinearTransform(BaseTransformerUnit[LinearTransformSettings, AxisArray, AxisArray, LinearTransformTransformer]):
+    """Unit wrapper for LinearTransformTransformer."""
+
+    SETTINGS = LinearTransformSettings

ezmsg/sigproc/math/abs.py

@@ -1,12 +1,16 @@
-"""Take the absolute value of the data."""
-# TODO: Array API
+"""
+Take the absolute value of the data.
 
-import numpy as np
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
+
+from array_api_compat import get_namespace
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 
 class AbsSettings:
     pass
@@ -14,7 +18,8 @@ class AbsSettings:
 
 class AbsTransformer(BaseTransformer[None, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
-        return replace(message, data=np.abs(message.data))
+        xp = get_namespace(message.data)
+        return replace(message, data=xp.abs(message.data))
 
 
 class Abs(BaseTransformerUnit[None, AxisArray, AxisArray, AbsTransformer]): ...  # SETTINGS = None

ezmsg/sigproc/math/add.py

@@ -5,12 +5,11 @@ import typing
 from dataclasses import dataclass, field
 
 import ezmsg.core as ez
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.baseproc.util.asio import run_coroutine_sync
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 # --- Constant Addition (single input) ---
 
 

ezmsg/sigproc/math/clip.py

@@ -1,27 +1,32 @@
-"""Clips the data to be within the specified range."""
-# TODO: Array API
+"""
+Clips the data to be within the specified range.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
 
 import ezmsg.core as ez
-import numpy as np
+from array_api_compat import get_namespace
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 
 class ClipSettings(ez.Settings):
-    a_min: float
-    """Lower clip bound."""
+    min: float | None = None
+    """Lower clip bound. If None, no lower clipping is applied."""
 
-    a_max: float
-    """Upper clip bound."""
+    max: float | None = None
+    """Upper clip bound. If None, no upper clipping is applied."""
 
 
 class ClipTransformer(BaseTransformer[ClipSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
         return replace(
             message,
-            data=np.clip(message.data, self.settings.a_min, self.settings.a_max),
+            data=xp.clip(message.data, self.settings.min, self.settings.max),
         )
 
 
@@ -29,15 +34,15 @@ class Clip(BaseTransformerUnit[ClipSettings, AxisArray, AxisArray, ClipTransform
     SETTINGS = ClipSettings
 
 
-def clip(a_min: float, a_max: float) -> ClipTransformer:
+def clip(min: float | None = None, max: float | None = None) -> ClipTransformer:
     """
-    Clips the data to be within the specified range. See :obj:`np.clip` for more details.
+    Clips the data to be within the specified range.
 
     Args:
-        a_min: Lower clip bound
-        a_max: Upper clip bound
-
-    Returns: :obj:`ClipTransformer`.
+        min: Lower clip bound. If None, no lower clipping is applied.
+        max: Upper clip bound. If None, no upper clipping is applied.
 
+    Returns:
+        :obj:`ClipTransformer`.
     """
-    return ClipTransformer(ClipSettings(a_min=a_min, a_max=a_max))
+    return ClipTransformer(ClipSettings(min=min, max=max))

ezmsg/sigproc/math/difference.py

@@ -1,16 +1,22 @@
-"""Take the difference between 2 signals or between a signal and a constant value."""
+"""
+Take the difference between 2 signals or between a signal and a constant value.
+
+.. note::
+    :obj:`ConstDifferenceTransformer` supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+    :obj:`DifferenceProcessor` (two-input difference) currently requires NumPy arrays.
+"""
 
 import asyncio
 import typing
 from dataclasses import dataclass, field
 
 import ezmsg.core as ez
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.baseproc.util.asio import run_coroutine_sync
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 
 class ConstDifferenceSettings(ez.Settings):
     value: float = 0.0

ezmsg/sigproc/math/invert.py

@@ -1,10 +1,15 @@
-"""1/data transformer."""
+"""
+Compute the multiplicative inverse (1/x) of the data.
 
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
+
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 
 class InvertTransformer(BaseTransformer[None, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:

ezmsg/sigproc/math/log.py

@@ -1,13 +1,17 @@
-"""Take the logarithm of the data."""
+"""
+Take the logarithm of the data.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
 
-# TODO: Array API
 import ezmsg.core as ez
-import numpy as np
+from array_api_compat import get_namespace
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 
 class LogSettings(ez.Settings):
     base: float = 10.0
@@ -19,10 +23,17 @@ class LogSettings(ez.Settings):
 
 class LogTransformer(BaseTransformer[LogSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
         data = message.data
-        if self.settings.clip_zero and np.any(data <= 0) and np.issubdtype(data.dtype, np.floating):
-            data = np.clip(data, a_min=np.finfo(data.dtype).tiny, a_max=None)
-        return replace(message, data=np.log(data) / np.log(self.settings.base))
+        if self.settings.clip_zero:
+            # Check if any values are <= 0 and dtype is floating point
+            has_non_positive = bool(xp.any(data <= 0))
+            is_floating = xp.isdtype(data.dtype, "real floating")
+            if has_non_positive and is_floating:
+                # Use smallest_normal (Array API equivalent of numpy's finfo.tiny)
+                min_val = xp.finfo(data.dtype).smallest_normal
+                data = xp.clip(data, min_val, None)
+        return replace(message, data=xp.log(data) / xp.log(self.settings.base))
 
 
 class Log(BaseTransformerUnit[LogSettings, AxisArray, AxisArray, LogTransformer]):

ezmsg/sigproc/math/scale.py

@@ -1,11 +1,16 @@
-"""Scale the data by a constant factor."""
+"""
+Scale the data by a constant factor.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
 
 import ezmsg.core as ez
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ..base import BaseTransformer, BaseTransformerUnit
-
 
 class ScaleSettings(ez.Settings):
     scale: float = 1.0

ezmsg/sigproc/rollingscaler.py

@@ -3,14 +3,14 @@ from collections import deque
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-
-from ezmsg.sigproc.base import (
+from ezmsg.baseproc import (
     BaseAdaptiveTransformer,
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
 from ezmsg.sigproc.sampler import SampleMessage
 
 

ezmsg/sigproc/scaler.py

@@ -1,5 +1,6 @@
 import typing
 
+import ezmsg.core as ez
 import numpy as np
 from ezmsg.baseproc import (
     BaseStatefulTransformer,
@@ -82,11 +83,38 @@ class AdaptiveStandardScalerTransformer(
     ]
 ):
     def _reset_state(self, message: AxisArray) -> None:
-        self._state.samps_ewma = EWMATransformer(time_constant=self.settings.time_constant, axis=self.settings.axis)
-        self._state.vars_sq_ewma = EWMATransformer(time_constant=self.settings.time_constant, axis=self.settings.axis)
+        self._state.samps_ewma = EWMATransformer(
+            time_constant=self.settings.time_constant,
+            axis=self.settings.axis,
+            accumulate=self.settings.accumulate,
+        )
+        self._state.vars_sq_ewma = EWMATransformer(
+            time_constant=self.settings.time_constant,
+            axis=self.settings.axis,
+            accumulate=self.settings.accumulate,
+        )
+
+    @property
+    def accumulate(self) -> bool:
+        """Whether to accumulate statistics from incoming samples."""
+        return self.settings.accumulate
+
+    @accumulate.setter
+    def accumulate(self, value: bool) -> None:
+        """
+        Set the accumulate mode and propagate to child EWMA transformers.
+
+        Args:
+            value: If True, update statistics with each sample.
+                   If False, only apply current statistics without updating.
+        """
+        if self._state.samps_ewma is not None:
+            self._state.samps_ewma.settings = replace(self._state.samps_ewma.settings, accumulate=value)
+        if self._state.vars_sq_ewma is not None:
+            self._state.vars_sq_ewma.settings = replace(self._state.vars_sq_ewma.settings, accumulate=value)
 
     def _process(self, message: AxisArray) -> AxisArray:
-        # Update step
+        # Update step (respects accumulate setting via child EWMAs)
         mean_message = self._state.samps_ewma(message)
         var_sq_message = self._state.vars_sq_ewma(replace(message, data=message.data**2))
 
@@ -108,6 +136,27 @@ class AdaptiveStandardScaler(
 ):
     SETTINGS = AdaptiveStandardScalerSettings
 
+    @ez.subscriber(BaseTransformerUnit.INPUT_SETTINGS)
+    async def on_settings(self, msg: AdaptiveStandardScalerSettings) -> None:
+        """
+        Handle settings updates with smart reset behavior.
+
+        Only resets state if `axis` changes (structural change).
+        Changes to `time_constant` or `accumulate` are applied without
+        resetting accumulated statistics.
+        """
+        old_axis = self.SETTINGS.axis
+        self.apply_settings(msg)
+
+        if msg.axis != old_axis:
+            # Axis changed - need full reset
+            self.create_processor()
+        else:
+            # Update accumulate on processor (propagates to child EWMAs)
+            self.processor.accumulate = msg.accumulate
+            # Also update own settings reference
+            self.processor.settings = msg
+
 
 # Backwards compatibility...
 def scaler_np(time_constant: float = 1.0, axis: str | None = None) -> AdaptiveStandardScalerTransformer:

ezmsg/sigproc/transpose.py

@@ -1,7 +1,17 @@
+"""
+Transpose or permute array dimensions.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+    Memory layout optimization (C/F order) only applies to NumPy arrays.
+"""
+
 from types import EllipsisType
 
 import ezmsg.core as ez
 import numpy as np
+from array_api_compat import get_namespace, is_numpy_array
 from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
@@ -84,6 +94,7 @@ class TransposeTransformer(BaseStatefulTransformer[TransposeSettings, AxisArray,
         return super().__call__(message)
 
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
         if self.state.axes_ints is None:
             # No transpose required
             if self.settings.order is None:
@@ -91,15 +102,19 @@ class TransposeTransformer(BaseStatefulTransformer[TransposeSettings, AxisArray,
                 # Note: We should not be able to reach here because it should be shortcutted at passthrough.
                 msg_out = message
             else:
-                # If the memory is already contiguous in the correct order, np.require won't do anything.
-                msg_out = replace(
-                    message,
-                    data=np.require(message.data, requirements=self.settings.order.upper()[0]),
-                )
+                # Memory layout optimization only applies to numpy arrays
+                if is_numpy_array(message.data):
+                    msg_out = replace(
+                        message,
+                        data=np.require(message.data, requirements=self.settings.order.upper()[0]),
+                    )
+                else:
+                    msg_out = message
         else:
             dims_out = [message.dims[ix] for ix in self.state.axes_ints]
-            data_out = np.transpose(message.data, axes=self.state.axes_ints)
-            if self.settings.order is not None:
+            data_out = xp.permute_dims(message.data, axes=self.state.axes_ints)
+            if self.settings.order is not None and is_numpy_array(data_out):
+                # Memory layout optimization only applies to numpy arrays
                 data_out = np.require(data_out, requirements=self.settings.order.upper()[0])
             msg_out = replace(
                 message,

{ezmsg_sigproc-2.7.0.dist-info → ezmsg_sigproc-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 2.7.0
+Version: 2.9.0
 Summary: Timeseries signal processing implementations in ezmsg
 Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>, Kyle McGraw <kmcgraw@blackrockneuro.com>
 License-Expression: MIT

{ezmsg_sigproc-2.7.0.dist-info → ezmsg_sigproc-2.9.0.dist-info}/RECORD

@@ -1,55 +1,56 @@
 ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
-ezmsg/sigproc/__version__.py,sha256=egp6dAw7S80JrGAUNYGJNY3iqzeSzC4Vs5c3SnC3SIY,704
+ezmsg/sigproc/__version__.py,sha256=24D27WSWcO2HaMUGCrVCG6Zbd76BrLDh2qQ1KbGX6Hc,704
 ezmsg/sigproc/activation.py,sha256=83vnTa3ZcC4Q3VSWcGfaqhCEqYRNySUOyVpMHZXfz-c,2755
 ezmsg/sigproc/adaptive_lattice_notch.py,sha256=ThUR48mbSHuThkimtD0j4IXNMrOVcpZgGhE7PCYfXhU,8818
-ezmsg/sigproc/affinetransform.py,sha256=umEsbEcuiCI02oljWueJnKaI0aJxJ0wqOjH5yXclEM0,8414
-ezmsg/sigproc/aggregate.py,sha256=yc3Hnak0yhucqlTCv9Isg6BKR24s6rMZqbZKpayyBgM,9048
+ezmsg/sigproc/affinetransform.py,sha256=jl7DiSa5Yb0qsmFJbfSiSeGmvK1SGoBgycFC5JU5DVY,9434
+ezmsg/sigproc/aggregate.py,sha256=7Hdz1m-S6Cl9h0oRQHeS_UTGBemhOB4XdFyX6cGcdHo,9362
 ezmsg/sigproc/bandpower.py,sha256=dAhH56sUrXNhcRFymTTwjdM_KcU5OxFzrR_sxIPAxyw,2264
 ezmsg/sigproc/base.py,sha256=SJvKEb8gw6mUMwlV5sH0iPG0bXrgS8tvkPwhI-j89MQ,3672
 ezmsg/sigproc/butterworthfilter.py,sha256=NKTGkgjvlmC1Dc9gD2Z6UBzUq12KicfnczrzM5ZTosk,5255
-ezmsg/sigproc/butterworthzerophase.py,sha256=QbJ_gGXrIfVOl_OybD07orO460owSMP5yTDMcGgASP0,4109
+ezmsg/sigproc/butterworthzerophase.py,sha256=Df3F1QBBE39FBjNi67wvTsb1bSdTRTSTZXbZiKFlxC4,4105
 ezmsg/sigproc/cheby.py,sha256=B8pGt5_pOBpNZCmaibNl_NKkyuasd8ZEJXeTDCTaino,3711
 ezmsg/sigproc/combfilter.py,sha256=MSxr1I-jBePW_9AuCiv3RQ1HUNxIsNhLk0q1Iu8ikAw,4766
-ezmsg/sigproc/coordinatespaces.py,sha256=NWbQVvizmiU4F3AIwHHhiZ30Kg2IeSW0fRaa-yXkn-c,4610
+ezmsg/sigproc/coordinatespaces.py,sha256=bp_0fTS9b27OQqLoFzgE3f9rb287P8y0S1dWWGrS08o,5298
 ezmsg/sigproc/decimate.py,sha256=DCX9p4ZrcGoQ9di-jmPKqiKERTkvTAtSqLg8chQLp84,2336
-ezmsg/sigproc/denormalize.py,sha256=CaH34QJ3OvsnhZT7bhCw2KVxVKvaU24ui6BS5-oe_x0,3040
-ezmsg/sigproc/detrend.py,sha256=TxqZ41AdjsH_yOTj8fBoKTnbKCbdyzVibpCHWkFARYU,898
-ezmsg/sigproc/diff.py,sha256=PC8KJAqaXMsdS_kPlDSEtXpcQ5rk92Ze_TeUjsVwbN0,2782
+ezmsg/sigproc/denormalize.py,sha256=OACzoINCISNUmZcR2pqWfxi3p8uuBLCz1PMw4XNwOCs,3035
+ezmsg/sigproc/detrend.py,sha256=2C-dhVy-ty4b22aE07kIF3VjqCoFitoZqyrX6hAjXYQ,894
+ezmsg/sigproc/diff.py,sha256=nDf9-XywZKlfeainIeubl_NccmkuAdLjYMcWSPMquss,3179
 ezmsg/sigproc/downsample.py,sha256=Jqxt1Va1FrQLH1wUQpP0U79iQARTTHEKklKHy7yGL2o,3679
-ezmsg/sigproc/ewma.py,sha256=I6WZkf6yf8jnpLdeEAWfAcpui5erVcVMZo6hTMMvDvg,6247
+ezmsg/sigproc/ewma.py,sha256=ecLq1ZlON85NWdW_5cz9chWirxjf4y9zCPMOt3IqQuk,7723
 ezmsg/sigproc/ewmfilter.py,sha256=9AuvVn3TDdf5R4bVolYNM46AtDVHFJa8MLGltY6mYPE,4795
-ezmsg/sigproc/extract_axis.py,sha256=4beqJ0EyUkT9Pa1FdYa9IteHGaxkh87j5_rYiZlvIG4,1598
+ezmsg/sigproc/extract_axis.py,sha256=T2e9zW8N0bwOj4_zlB3I0oT0iwaBijpzF6wrFsCfD24,1593
 ezmsg/sigproc/fbcca.py,sha256=JYFWsMDRJEWwUNujr4EsFL5t1ux-cnBGamNVrCRO_RA,12043
-ezmsg/sigproc/filter.py,sha256=rLmJCgPevoODTL3g_D6czwVvcCD4uK8hJJ0tKfTH5_w,11609
+ezmsg/sigproc/filter.py,sha256=IWg3J5IGVdv7kfp4zaKRzfjEuRa5xNzcq6fHtq4tPCM,11604
 ezmsg/sigproc/filterbank.py,sha256=tD7fn4dZzEvsmp_sSn16VVJ4WcJ5sN5lsSuNTLDCQZ8,13056
 ezmsg/sigproc/filterbankdesign.py,sha256=vLXQVJwoFEK4V6umqzcr1PJKcwv6pGO29klSWQXk7y0,4712
-ezmsg/sigproc/fir_hilbert.py,sha256=aurBCcpvsG69qD6Du2aHMye4HCBXF4RXzACdSxIy_Z8,10859
+ezmsg/sigproc/fir_hilbert.py,sha256=ByZDsDFjbJx-EgLZF85vZCPQbprQaiMEuG2dyvTPiDY,10855
 ezmsg/sigproc/fir_pmc.py,sha256=Ze2pd9K8XrdDhgJZG2E7x-5C2hfd6kIns4bYjTJsBvc,6997
 ezmsg/sigproc/firfilter.py,sha256=7r_I476nYuixJsuwc_hQ0Fbq8WB0gnYBZUKs3zultOQ,3790
 ezmsg/sigproc/gaussiansmoothing.py,sha256=BfXm9YQoOtieM4ABK2KRgxeQz055rd7mqtTVqmjT3Rk,2672
 ezmsg/sigproc/kaiser.py,sha256=dIwgHbLXUHPtdotsGNLE9VG_clhcMgvVnSoFkMVgF9M,3483
+ezmsg/sigproc/linear.py,sha256=b3NRzQNBvdU2jqenZT9XXFHax9Mavbj2xFiVxOwl1Ms,4662
 ezmsg/sigproc/messages.py,sha256=KQczHTeifn4BZycChN8ZcpfZoQW3lC_xuFmN72QT97s,925
 ezmsg/sigproc/quantize.py,sha256=uSM2z2xXwL0dgSltyzLEmlKjaJZ2meA3PDWX8_bM0Hs,2195
 ezmsg/sigproc/resample.py,sha256=3mm9pvxryNVhQuTCIMW3ToUkUfbVOCsIgvXUiurit1Y,11389
-ezmsg/sigproc/rollingscaler.py,sha256=j5hoWgJMbeDST7FXE6UBLSeR2hhfACIqQvFKr92ZTZA,8503
+ezmsg/sigproc/rollingscaler.py,sha256=e-smSKDhmDD2nWIf6I77CtRxQp_7sHS268SGPi7aXp8,8499
 ezmsg/sigproc/sampler.py,sha256=iOk2YoUX22u9iTjFKimzP5V074RDBVcmswgfyxvZRZo,10761
-ezmsg/sigproc/scaler.py,sha256=n0aGo272vs_MnFRtT1b3vVCQOzY-UEAxnqZKlpIldX8,4041
+ezmsg/sigproc/scaler.py,sha256=oBZa6uzyftChvk6aqBD5clil6pedx3IF-dptrb74EA0,5888
 ezmsg/sigproc/signalinjector.py,sha256=mB62H2b-ScgPtH1jajEpxgDHqdb-RKekQfgyNncsE8Y,2874
 ezmsg/sigproc/slicer.py,sha256=xLXxWf722V08ytVwvPimYjDKKj0pkC2HjdgCVaoaOvs,5195
 ezmsg/sigproc/spectral.py,sha256=wFzuihS7qJZMQcp0ds_qCG-zCbvh5DyhFRjn2wA9TWQ,322
 ezmsg/sigproc/spectrogram.py,sha256=g8xYWENzle6O5uEF-vfjsF5gOSDnJTwiu3ZudicO470,2893
 ezmsg/sigproc/spectrum.py,sha256=AAxrywIYpAPENRWvaaM2VjcKEaqMt6ra1E3Ao26jdZs,9523
-ezmsg/sigproc/transpose.py,sha256=Yx4losN7tKCacUt2GmFvjOSqJ0b3XhEepXzq_Z_iMCI,4381
+ezmsg/sigproc/transpose.py,sha256=uRGieeYRFTO9gAhWzkq49f-Qo49rpDQhn9r3nLuwx4I,4983
 ezmsg/sigproc/wavelets.py,sha256=mN9TrZencyvKBfnuMiGZ_lzrE1O7DhVo05EYgCjXncg,7428
 ezmsg/sigproc/window.py,sha256=ZlawY4TPbLc46qIgcKhP4X7dpMDo4zNlnfzgV1eFaGU,15335
 ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ezmsg/sigproc/math/abs.py,sha256=_omQP4baHGu8MgKzNDMUsjrmA_yeXWNqKyTU7BiHCSE,741
-ezmsg/sigproc/math/add.py,sha256=lR4lB8-QdUfyARJcdf5sMQhbHtFpRNYt8_1zYzkVEhU,3659
-ezmsg/sigproc/math/clip.py,sha256=vJ8zpzVlTVPlkElsqyPVMOwyKBrgym8RD8BEOvf8g1o,1131
-ezmsg/sigproc/math/difference.py,sha256=TtAURz9TsW_Vk39sMJOT84P0xw0xDrgE3ToRi8MWVv4,4491
-ezmsg/sigproc/math/invert.py,sha256=SYJDNEb7snkVODnItfkkp8rhMrHEdyBmzg6qZkZLX2c,630
-ezmsg/sigproc/math/log.py,sha256=K8bZSm-ubTDY0oqwuc0IOMkdPIwpw1yysjTOG657kkQ,1488
-ezmsg/sigproc/math/scale.py,sha256=Zpzlz1NSLyvmggjs0pPypUKgXX99z2S3VXJ06fHok5M,942
+ezmsg/sigproc/math/abs.py,sha256=Zrt0xhGnhf90Vk00S1PYkbeCOQshqkvh1HLj26N4AL0,979
+ezmsg/sigproc/math/add.py,sha256=UikpS_vhaY58ssf46C1r4_tnRUFMl86xCmd5Y8GFZ1Q,3666
+ezmsg/sigproc/math/clip.py,sha256=1D6mUlOzBB7L35G_KKYZmfg7nYlbuDdITV4EH0R-yUo,1529
+ezmsg/sigproc/math/difference.py,sha256=uUYZgbLe-GrFSN6EOFjs9fQZllp827IluxL6m8TJuH8,4791
+ezmsg/sigproc/math/invert.py,sha256=nz8jbfvDoez6s9NmAprBtTAI5oSDj0wNUPk8j13XiVk,855
+ezmsg/sigproc/math/log.py,sha256=JhjSqLnQnvx_3F4txRYHuUPSJ12Yj2HvRTsCMNvlxpo,2022
+ezmsg/sigproc/math/scale.py,sha256=4_xHcHNuf13E1fxIF5vbkPfkN4En6zkfPIKID7lCERk,1133
 ezmsg/sigproc/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ezmsg/sigproc/util/asio.py,sha256=aAj0e7OoBvkRy28k05HL2s9YPCTxOddc05xMN-qd4lQ,577
 ezmsg/sigproc/util/axisarray_buffer.py,sha256=TGDeC6CXmmp7OUuiGd6xYQijRGYDE4QGdWxjK5Vs3nE,14057
@@ -58,7 +59,7 @@ ezmsg/sigproc/util/message.py,sha256=ppN3IYtIAwrxWG9JOvgWFn1wDdIumkEzYFfqpH9VQkY
 ezmsg/sigproc/util/profile.py,sha256=eVOo9pXgusrnH1yfRdd2RsM7Dbe2UpyC0LJ9MfGpB08,416
 ezmsg/sigproc/util/sparse.py,sha256=NjbJitCtO0B6CENTlyd9c-lHEJwoCan-T3DIgPyeShw,4834
 ezmsg/sigproc/util/typeresolution.py,sha256=fMFzLi63dqCIclGFLcMdM870OYxJnkeWw6aWKNMk718,362
-ezmsg_sigproc-2.7.0.dist-info/METADATA,sha256=QtI9FWw5pFVEqs1Ma6tooyGj73dZ6IOnM0QueJnzeSY,1908
-ezmsg_sigproc-2.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ezmsg_sigproc-2.7.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
-ezmsg_sigproc-2.7.0.dist-info/RECORD,,
+ezmsg_sigproc-2.9.0.dist-info/METADATA,sha256=H7aJdYvhCekfdihzdsPbvT1a942faGRIlcoeDd_23HI,1908
+ezmsg_sigproc-2.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ezmsg_sigproc-2.9.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-2.9.0.dist-info/RECORD,,