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

ezmsg/sigproc/butterworthfilter.py

@@ -5,11 +5,11 @@ import scipy.signal
 from scipy.signal import normalize
 
 from .filter import (
-    FilterBaseSettings,
     BACoeffs,
-    SOSCoeffs,
-    FilterByDesignTransformer,
     BaseFilterByDesignTransformerUnit,
+    FilterBaseSettings,
+    FilterByDesignTransformer,
+    SOSCoeffs,
 )
 
 
@@ -27,14 +27,14 @@ class ButterworthFilterSettings(FilterBaseSettings):
     """
     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. 
+    or if this is greater than `cutoff` then this is the end of the bandstop.
     """
 
     cutoff: float | None = None
     """
     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. 
+    or if this is less than `cuton` then this is the beginning of the bandstop.
     """
 
     wn_hz: bool = True
@@ -96,9 +96,7 @@ def butter_design_fun(
     """
     coefs = None
     if order > 0:
-        btype, cutoffs = ButterworthFilterSettings(
-            order=order, cuton=cuton, cutoff=cutoff
-        ).filter_specs()
+        btype, cutoffs = ButterworthFilterSettings(order=order, cuton=cuton, cutoff=cutoff).filter_specs()
         coefs = scipy.signal.butter(
             order,
             Wn=cutoffs,
@@ -111,9 +109,7 @@ def butter_design_fun(
     return coefs
 
 
-class ButterworthFilterTransformer(
-    FilterByDesignTransformer[ButterworthFilterSettings, BACoeffs | SOSCoeffs]
-):
+class ButterworthFilterTransformer(FilterByDesignTransformer[ButterworthFilterSettings, BACoeffs | SOSCoeffs]):
     def get_design_function(
         self,
     ) -> typing.Callable[[float], BACoeffs | SOSCoeffs | None]:
@@ -127,11 +123,7 @@ class ButterworthFilterTransformer(
         )
 
 
-class ButterworthFilter(
-    BaseFilterByDesignTransformerUnit[
-        ButterworthFilterSettings, ButterworthFilterTransformer
-    ]
-):
+class ButterworthFilter(BaseFilterByDesignTransformerUnit[ButterworthFilterSettings, ButterworthFilterTransformer]):
     SETTINGS = ButterworthFilterSettings
 
 

ezmsg/sigproc/butterworthzerophase.py

@@ -4,6 +4,9 @@ import typing
 import ezmsg.core as ez
 import numpy as np
 import scipy.signal
+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 (
@@ -12,8 +15,6 @@ from ezmsg.sigproc.filter import (
     FilterByDesignTransformer,
     SOSCoeffs,
 )
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
 
 
 class ButterworthZeroPhaseSettings(ButterworthFilterSettings):
@@ -34,9 +35,7 @@ class ButterworthZeroPhaseSettings(ButterworthFilterSettings):
     """
 
 
-class ButterworthZeroPhaseTransformer(
-    FilterByDesignTransformer[ButterworthZeroPhaseSettings, BACoeffs | SOSCoeffs]
-):
+class ButterworthZeroPhaseTransformer(FilterByDesignTransformer[ButterworthZeroPhaseSettings, BACoeffs | SOSCoeffs]):
     """Zero-phase (filtfilt) Butterworth using your design function."""
 
     def get_design_function(
@@ -51,9 +50,7 @@ class ButterworthZeroPhaseTransformer(
             wn_hz=self.settings.wn_hz,
         )
 
-    def update_settings(
-        self, new_settings: typing.Optional[SettingsType] = None, **kwargs
-    ) -> None:
+    def update_settings(self, new_settings: typing.Optional[SettingsType] = None, **kwargs) -> None:
         """
         Update settings and mark that filter coefficients need to be recalculated.
 
@@ -91,11 +88,7 @@ class ButterworthZeroPhaseTransformer(
             self._fs_cache = fs
             self.state.needs_redesign = False
 
-        if (
-            self._coefs_cache is None
-            or self.settings.order <= 0
-            or message.data.size <= 0
-        ):
+        if self._coefs_cache is None or self.settings.order <= 0 or message.data.size <= 0:
             return message
 
         x = message.data
@@ -125,8 +118,6 @@ class ButterworthZeroPhaseTransformer(
 
 
 class ButterworthZeroPhase(
-    BaseFilterByDesignTransformerUnit[
-        ButterworthZeroPhaseSettings, ButterworthZeroPhaseTransformer
-    ]
+    BaseFilterByDesignTransformerUnit[ButterworthZeroPhaseSettings, ButterworthZeroPhaseTransformer]
 ):
     SETTINGS = ButterworthZeroPhaseSettings

ezmsg/sigproc/cheby.py

@@ -5,11 +5,11 @@ import scipy.signal
 from scipy.signal import normalize
 
 from .filter import (
+    BACoeffs,
+    BaseFilterByDesignTransformerUnit,
     FilterBaseSettings,
     FilterByDesignTransformer,
-    BACoeffs,
     SOSCoeffs,
-    BaseFilterByDesignTransformerUnit,
 )
 
 
@@ -104,9 +104,7 @@ def cheby_design_fun(
     return coefs
 
 
-class ChebyshevFilterTransformer(
-    FilterByDesignTransformer[ChebyshevFilterSettings, BACoeffs | SOSCoeffs]
-):
+class ChebyshevFilterTransformer(FilterByDesignTransformer[ChebyshevFilterSettings, BACoeffs | SOSCoeffs]):
     def get_design_function(
         self,
     ) -> typing.Callable[[float], BACoeffs | SOSCoeffs | None]:
@@ -123,9 +121,5 @@ class ChebyshevFilterTransformer(
         )
 
 
-class ChebyshevFilter(
-    BaseFilterByDesignTransformerUnit[
-        ChebyshevFilterSettings, ChebyshevFilterTransformer
-    ]
-):
+class ChebyshevFilter(BaseFilterByDesignTransformerUnit[ChebyshevFilterSettings, ChebyshevFilterTransformer]):
     SETTINGS = ChebyshevFilterSettings

ezmsg/sigproc/combfilter.py

@@ -1,15 +1,16 @@
 import functools
 import typing
+
 import numpy as np
 import scipy.signal
 from scipy.signal import normalize
 
 from .filter import (
+    BACoeffs,
+    BaseFilterByDesignTransformerUnit,
     FilterBaseSettings,
     FilterByDesignTransformer,
-    BACoeffs,
     SOSCoeffs,
-    BaseFilterByDesignTransformerUnit,
 )
 
 
@@ -103,9 +104,7 @@ def comb_design_fun(
     return combined_sos
 
 
-class CombFilterTransformer(
-    FilterByDesignTransformer[CombFilterSettings, BACoeffs | SOSCoeffs]
-):
+class CombFilterTransformer(FilterByDesignTransformer[CombFilterSettings, BACoeffs | SOSCoeffs]):
     def get_design_function(
         self,
     ) -> typing.Callable[[float], BACoeffs | SOSCoeffs | None]:
@@ -120,9 +119,7 @@ class CombFilterTransformer(
         )
 
 
-class CombFilterUnit(
-    BaseFilterByDesignTransformerUnit[CombFilterSettings, CombFilterTransformer]
-):
+class CombFilterUnit(BaseFilterByDesignTransformerUnit[CombFilterSettings, CombFilterTransformer]):
     SETTINGS = CombFilterSettings
 
 

ezmsg/sigproc/coordinatespaces.py

@@ -0,0 +1,142 @@
+"""
+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.
+"""
+
+from enum import Enum
+from typing import Tuple
+
+import ezmsg.core as ez
+import numpy as np
+import numpy.typing as npt
+from ezmsg.baseproc import (
+    BaseTransformer,
+    BaseTransformerUnit,
+)
+from ezmsg.util.messages.axisarray import AxisArray, replace
+
+# -- Utility functions for coordinate transformations --
+
+
+def polar2z(r: npt.ArrayLike, theta: npt.ArrayLike) -> npt.ArrayLike:
+    """Convert polar coordinates to complex number representation."""
+    return r * np.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)
+
+
+def cart2z(x: npt.ArrayLike, y: npt.ArrayLike) -> npt.ArrayLike:
+    """Convert Cartesian coordinates to complex number representation."""
+    return x + 1j * y
+
+
+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)
+
+
+def cart2pol(x: npt.ArrayLike, y: npt.ArrayLike) -> Tuple[npt.ArrayLike, npt.ArrayLike]:
+    """Convert Cartesian coordinates (x, y) to polar coordinates (r, theta)."""
+    return z2polar(cart2z(x, y))
+
+
+def pol2cart(r: npt.ArrayLike, theta: npt.ArrayLike) -> Tuple[npt.ArrayLike, npt.ArrayLike]:
+    """Convert polar coordinates (r, theta) to Cartesian coordinates (x, y)."""
+    return z2cart(polar2z(r, theta))
+
+
+# -- ezmsg transformer classes --
+
+
+class CoordinateMode(str, Enum):
+    """Transformation mode for coordinate conversion."""
+
+    CART2POL = "cart2pol"
+    """Convert Cartesian (x, y) to polar (r, theta)."""
+
+    POL2CART = "pol2cart"
+    """Convert polar (r, theta) to Cartesian (x, y)."""
+
+
+class CoordinateSpacesSettings(ez.Settings):
+    """
+    Settings for :obj:`CoordinateSpaces`.
+
+    See :obj:`coordinate_spaces` for argument details.
+    """
+
+    mode: CoordinateMode = CoordinateMode.CART2POL
+    """The transformation mode: 'cart2pol' or 'pol2cart'."""
+
+    axis: str | None = None
+    """
+    The name of the axis containing the coordinate components.
+    Defaults to the last axis. Must have exactly 2 elements (x,y or r,theta).
+    """
+
+
+class CoordinateSpacesTransformer(BaseTransformer[CoordinateSpacesSettings, AxisArray, AxisArray]):
+    """
+    Transform between Cartesian and polar coordinate systems.
+
+    The input must have exactly 2 elements along the specified axis:
+    - For cart2pol: expects (x, y), outputs (r, theta)
+    - For pol2cart: expects (r, theta), outputs (x, y)
+    """
+
+    def _process(self, message: AxisArray) -> AxisArray:
+        axis = self.settings.axis or message.dims[-1]
+        axis_idx = message.get_axis_idx(axis)
+
+        if message.data.shape[axis_idx] != 2:
+            raise ValueError(
+                f"Coordinate transformation requires exactly 2 elements along axis '{axis}', "
+                f"got {message.data.shape[axis_idx]}."
+            )
+
+        # Extract components along the specified axis
+        slices_a = [slice(None)] * message.data.ndim
+        slices_b = [slice(None)] * message.data.ndim
+        slices_a[axis_idx] = 0
+        slices_b[axis_idx] = 1
+
+        component_a = message.data[tuple(slices_a)]
+        component_b = message.data[tuple(slices_b)]
+
+        if self.settings.mode == CoordinateMode.CART2POL:
+            # Input: x, y -> Output: r, theta
+            out_a, out_b = cart2pol(component_a, component_b)
+        else:
+            # Input: r, theta -> Output: x, y
+            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)
+
+        # Update axis labels if present
+        axes = message.axes
+        if axis in axes and hasattr(axes[axis], "data"):
+            if self.settings.mode == CoordinateMode.CART2POL:
+                new_labels = np.array(["r", "theta"])
+            else:
+                new_labels = np.array(["x", "y"])
+            axes = {**axes, axis: replace(axes[axis], data=new_labels)}
+
+        return replace(message, data=result, axes=axes)
+
+
+class CoordinateSpaces(
+    BaseTransformerUnit[CoordinateSpacesSettings, AxisArray, AxisArray, CoordinateSpacesTransformer]
+):
+    """
+    Unit for transforming between Cartesian and polar coordinate systems.
+
+    See :obj:`CoordinateSpacesSettings` for configuration options.
+    """
+
+    SETTINGS = CoordinateSpacesSettings

ezmsg/sigproc/decimate.py

@@ -1,10 +1,10 @@
 import typing
 
 import ezmsg.core as ez
+from ezmsg.baseproc import BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 
-from .base import BaseTransformerUnit
-from .cheby import ChebyshevFilterTransformer, ChebyshevFilterSettings
+from .cheby import ChebyshevFilterSettings, ChebyshevFilterTransformer
 from .downsample import Downsample, DownsampleSettings
 from .filter import BACoeffs, SOSCoeffs
 
@@ -30,11 +30,7 @@ class ChebyForDecimateTransformer(ChebyshevFilterTransformer[BACoeffs | SOSCoeff
         return cheby_opt_design_fun
 
 
-class ChebyForDecimate(
-    BaseTransformerUnit[
-        ChebyshevFilterSettings, AxisArray, AxisArray, ChebyForDecimateTransformer
-    ]
-):
+class ChebyForDecimate(BaseTransformerUnit[ChebyshevFilterSettings, AxisArray, AxisArray, ChebyForDecimateTransformer]):
     SETTINGS = ChebyshevFilterSettings
 
 

ezmsg/sigproc/denormalize.py

@@ -1,13 +1,14 @@
 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 (
-    BaseTransformerUnit,
     BaseStatefulTransformer,
+    BaseTransformerUnit,
     processor_state,
 )
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
 
 
 class DenormalizeSettings(ez.Settings):
@@ -27,9 +28,7 @@ class DenormalizeState:
     offsets: npt.NDArray | None = None
 
 
-class DenormalizeTransformer(
-    BaseStatefulTransformer[DenormalizeSettings, AxisArray, AxisArray, DenormalizeState]
-):
+class DenormalizeTransformer(BaseStatefulTransformer[DenormalizeSettings, AxisArray, AxisArray, DenormalizeState]):
     """
     Scales data from a normalized distribution (mean=0, std=1) to a denormalized
     distribution using random per-channel offsets and gains designed to keep the
@@ -76,9 +75,5 @@ class DenormalizeTransformer(
         )
 
 
-class DenormalizeUnit(
-    BaseTransformerUnit[
-        DenormalizeSettings, AxisArray, AxisArray, DenormalizeTransformer
-    ]
-):
+class DenormalizeUnit(BaseTransformerUnit[DenormalizeSettings, AxisArray, AxisArray, DenormalizeTransformer]):
     SETTINGS = DenormalizeSettings

ezmsg/sigproc/detrend.py

@@ -1,7 +1,8 @@
 import scipy.signal as sps
 from ezmsg.util.messages.axisarray import AxisArray, replace
-from ezmsg.sigproc.ewma import EWMATransformer, EWMASettings
+
 from ezmsg.sigproc.base import BaseTransformerUnit
+from ezmsg.sigproc.ewma import EWMASettings, EWMATransformer
 
 
 class DetrendTransformer(EWMATransformer):
@@ -23,7 +24,5 @@ class DetrendTransformer(EWMATransformer):
         return replace(message, data=message.data - means)
 
 
-class DetrendUnit(
-    BaseTransformerUnit[EWMASettings, AxisArray, AxisArray, DetrendTransformer]
-):
+class DetrendUnit(BaseTransformerUnit[EWMASettings, AxisArray, AxisArray, DetrendTransformer]):
     SETTINGS = EWMASettings

ezmsg/sigproc/diff.py

@@ -1,13 +1,14 @@
 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 (
+    BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
-    BaseStatefulTransformer,
 )
-from ezmsg.util.messages.axisarray import AxisArray, slice_along_axis
-from ezmsg.util.messages.util import replace
 
 
 class DiffSettings(ez.Settings):
@@ -21,9 +22,7 @@ class DiffState:
     last_time: float | None = None
 
 
-class DiffTransformer(
-    BaseStatefulTransformer[DiffSettings, AxisArray, AxisArray, DiffState]
-):
+class DiffTransformer(BaseStatefulTransformer[DiffSettings, AxisArray, AxisArray, DiffState]):
     def _hash_message(self, message: AxisArray) -> int:
         ax_idx = message.get_axis_idx(self.settings.axis)
         sample_shape = message.data.shape[:ax_idx] + message.data.shape[ax_idx + 1 :]
@@ -49,20 +48,14 @@ class DiffTransformer(
             axis=ax_idx,
         )
         # Prepare last_dat for next iteration
-        self.state.last_dat = slice_along_axis(
-            message.data, slice(-1, None), axis=ax_idx
-        )
+        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.
         if self.settings.scale_by_fs:
             ax_info = message.get_axis(axis)
             if hasattr(ax_info, "data"):
                 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)
-                )
+                exp_sl = (None,) * ax_idx + (Ellipsis,) + (None,) * (message.data.ndim - ax_idx - 1)
                 diffs /= dt[exp_sl]
                 self.state.last_time = ax_info.data[-1]  # For next iteration
             else:
@@ -71,9 +64,7 @@ class DiffTransformer(
         return replace(message, data=diffs)
 
 
-class DiffUnit(
-    BaseTransformerUnit[DiffSettings, AxisArray, AxisArray, DiffTransformer]
-):
+class DiffUnit(BaseTransformerUnit[DiffSettings, AxisArray, AxisArray, DiffTransformer]):
     SETTINGS = DiffSettings
 
 

ezmsg/sigproc/downsample.py

@@ -1,16 +1,15 @@
-import numpy as np
-from ezmsg.util.messages.axisarray import (
-    AxisArray,
-    slice_along_axis,
-    replace,
-)
 import ezmsg.core as ez
-
-from .base import (
+import numpy as np
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import (
+    AxisArray,
+    replace,
+    slice_along_axis,
+)
 
 
 class DownsampleSettings(ez.Settings):
@@ -38,9 +37,7 @@ class DownsampleState:
     """Index of the next msg's first sample into the virtual rotating ds_factor counter."""
 
 
-class DownsampleTransformer(
-    BaseStatefulTransformer[DownsampleSettings, AxisArray, AxisArray, DownsampleState]
-):
+class DownsampleTransformer(BaseStatefulTransformer[DownsampleSettings, AxisArray, AxisArray, DownsampleState]):
     """
     Downsampled data simply comprise every `factor`th sample.
     This should only be used following appropriate lowpass filtering.
@@ -75,9 +72,7 @@ class DownsampleTransformer(
         axis_idx = message.get_axis_idx(axis)
 
         n_samples = message.data.shape[axis_idx]
-        samples = (
-            np.arange(self.state.s_idx, self.state.s_idx + n_samples) % self._state.q
-        )
+        samples = np.arange(self.state.s_idx, self.state.s_idx + n_samples) % self._state.q
         if n_samples > 0:
             # Update state for next iteration.
             self._state.s_idx = samples[-1] + 1
@@ -104,9 +99,7 @@ class DownsampleTransformer(
         return msg_out
 
 
-class Downsample(
-    BaseTransformerUnit[DownsampleSettings, AxisArray, AxisArray, DownsampleTransformer]
-):
+class Downsample(BaseTransformerUnit[DownsampleSettings, AxisArray, AxisArray, DownsampleTransformer]):
     SETTINGS = DownsampleSettings
 
 
@@ -115,6 +108,4 @@ def downsample(
     target_rate: float | None = None,
     factor: int | None = None,
 ) -> DownsampleTransformer:
-    return DownsampleTransformer(
-        DownsampleSettings(axis=axis, target_rate=target_rate, factor=factor)
-    )
+    return DownsampleTransformer(DownsampleSettings(axis=axis, target_rate=target_rate, factor=factor))

ezmsg/sigproc/ewma.py

@@ -1,15 +1,14 @@
-from dataclasses import field
 import functools
+from dataclasses import field
 
+import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
 import scipy.signal as sps
-import ezmsg.core as ez
+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
 
-from .base import BaseStatefulTransformer, processor_state, BaseTransformerUnit
-
 
 def _tau_from_alpha(alpha: float, dt: float) -> float:
     """
@@ -29,9 +28,7 @@ def _alpha_from_tau(tau: float, dt: float) -> float:
     return 1 - np.exp(-dt / tau)
 
 
-def ewma_step(
-    sample: npt.NDArray, zi: npt.NDArray, alpha: float, beta: float | None = None
-):
+def ewma_step(sample: npt.NDArray, zi: npt.NDArray, alpha: float, beta: float | None = None):
     """
     Do an exponentially weighted moving average step.
 
@@ -97,9 +94,7 @@ class EWMA_Deprecated:
         if self.prev is None:
             self.prev = arr[:1]
 
-        out += self.prev * np.expand_dims(
-            self.weights[1 : n + 1], list(range(1, arr.ndim))
-        )
+        out += self.prev * np.expand_dims(self.weights[1 : n + 1], list(range(1, arr.ndim)))
 
         self.prev = out[-1:]
 
@@ -128,9 +123,7 @@ class EWMA_Deprecated:
         if self.prev is None:
             self.prev = arr[:1]
 
-        result += self.prev * np.expand_dims(
-            self.weights[1 : n + 1], list(range(1, arr.ndim))
-        )
+        result += self.prev * np.expand_dims(self.weights[1 : n + 1], list(range(1, arr.ndim)))
 
         # Store the result back into prev
         self.prev = result[-1]
@@ -155,25 +148,17 @@ class EWMAState:
     zi: npt.NDArray | None = None
 
 
-class EWMATransformer(
-    BaseStatefulTransformer[EWMASettings, AxisArray, AxisArray, EWMAState]
-):
+class EWMATransformer(BaseStatefulTransformer[EWMASettings, AxisArray, AxisArray, EWMAState]):
     def _hash_message(self, message: AxisArray) -> int:
         axis = self.settings.axis or message.dims[0]
         axis_idx = message.get_axis_idx(axis)
-        sample_shape = (
-            message.data.shape[:axis_idx] + message.data.shape[axis_idx + 1 :]
-        )
+        sample_shape = message.data.shape[:axis_idx] + message.data.shape[axis_idx + 1 :]
         return hash((sample_shape, message.axes[axis].gain, message.key))
 
     def _reset_state(self, message: AxisArray) -> None:
         axis = self.settings.axis or message.dims[0]
-        self._state.alpha = _alpha_from_tau(
-            self.settings.time_constant, message.axes[axis].gain
-        )
-        sub_dat = slice_along_axis(
-            message.data, slice(None, 1, None), axis=message.get_axis_idx(axis)
-        )
+        self._state.alpha = _alpha_from_tau(self.settings.time_constant, message.axes[axis].gain)
+        sub_dat = slice_along_axis(message.data, slice(None, 1, None), axis=message.get_axis_idx(axis))
         self._state.zi = (1 - self._state.alpha) * sub_dat
 
     def _process(self, message: AxisArray) -> AxisArray:
@@ -191,7 +176,5 @@ class EWMATransformer(
         return replace(message, data=expected)
 
 
-class EWMAUnit(
-    BaseTransformerUnit[EWMASettings, AxisArray, AxisArray, EWMATransformer]
-):
+class EWMAUnit(BaseTransformerUnit[EWMASettings, AxisArray, AxisArray, EWMATransformer]):
     SETTINGS = EWMASettings

ezmsg/sigproc/ewmfilter.py

@@ -2,9 +2,9 @@ import asyncio
 import typing
 
 import ezmsg.core as ez
+import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
-import numpy as np
 
 from .window import Window, WindowSettings
 

ezmsg/sigproc/extract_axis.py

@@ -1,6 +1,7 @@
-import numpy as np
 import ezmsg.core as ez
+import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray, replace
+
 from ezmsg.sigproc.base import BaseTransformer, BaseTransformerUnit
 
 
@@ -35,7 +36,5 @@ class ExtractAxisData(BaseTransformer[ExtractAxisSettings, AxisArray, AxisArray]
             )
 
 
-class ExtractAxisDataUnit(
-    BaseTransformerUnit[ExtractAxisSettings, AxisArray, AxisArray, ExtractAxisData]
-):
+class ExtractAxisDataUnit(BaseTransformerUnit[ExtractAxisSettings, AxisArray, AxisArray, ExtractAxisData]):
     SETTINGS = ExtractAxisSettings