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

ezmsg/sigproc/math/log.py

@@ -1,5 +1,8 @@
-import numpy as np
+"""Take the logarithm of the data."""
+
+# TODO: Array API
 import ezmsg.core as ez
+import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -17,11 +20,7 @@ class LogSettings(ez.Settings):
 class LogTransformer(BaseTransformer[LogSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
         data = message.data
-        if (
-            self.settings.clip_zero
-            and np.any(data <= 0)
-            and np.issubdtype(data.dtype, np.floating)
-        ):
+        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))
 

ezmsg/sigproc/math/scale.py

@@ -1,3 +1,5 @@
+"""Scale the data by a constant factor."""
+
 import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace

ezmsg/sigproc/messages.py

@@ -1,10 +1,9 @@
-import warnings
 import time
+import warnings
 
 import numpy.typing as npt
 from ezmsg.util.messages.axisarray import AxisArray
 
-
 # UPCOMING: TSMessage Deprecation
 # TSMessage is deprecated because it doesn't handle multiple time axes well.
 # AxisArray has an incompatible API but supports a superset of functionality.

ezmsg/sigproc/quantize.py

@@ -1,9 +1,8 @@
-import numpy as np
 import ezmsg.core as ez
+import numpy as np
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray, replace
 
-from .base import BaseTransformer, BaseTransformerUnit
-
 
 class QuantizeSettings(ez.Settings):
     """
@@ -65,7 +64,5 @@ class QuantizeTransformer(BaseTransformer[QuantizeSettings, AxisArray, AxisArray
         return replace(message, data=data)
 
 
-class QuantizerUnit(
-    BaseTransformerUnit[QuantizeSettings, AxisArray, AxisArray, QuantizeTransformer]
-):
+class QuantizerUnit(BaseTransformerUnit[QuantizeSettings, AxisArray, AxisArray, QuantizeTransformer]):
     SETTINGS = QuantizeSettings

ezmsg/sigproc/resample.py

@@ -2,17 +2,17 @@ import asyncio
 import math
 import time
 
+import ezmsg.core as ez
 import numpy as np
 import scipy.interpolate
-import ezmsg.core as ez
-from ezmsg.util.messages.axisarray import AxisArray, LinearAxis
-from ezmsg.util.messages.util import replace
-
-from .base import (
-    BaseStatefulProcessor,
+from ezmsg.baseproc import (
     BaseConsumerUnit,
+    BaseStatefulProcessor,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray, LinearAxis
+from ezmsg.util.messages.util import replace
+
 from .util.axisarray_buffer import HybridAxisArrayBuffer, HybridAxisBuffer
 from .util.buffer import UpdateStrategy
 
@@ -29,7 +29,7 @@ class ResampleSettings(ez.Settings):
     fill_value: str = "extrapolate"
     """
     Value to use for out-of-bounds samples.
-    If 'extrapolate', the transformer will extrapolate. 
+    If 'extrapolate', the transformer will extrapolate.
     If 'last', the transformer will use the last sample.
     See scipy.interpolate.interp1d for more options.
     """
@@ -57,9 +57,9 @@ class ResampleState:
     """
     The buffer for the reference axis (usually a time axis). The interpolation function
     will be evaluated at the reference axis values.
-    When resample_rate is None, this buffer will be filled with the axis from incoming 
+    When resample_rate is None, this buffer will be filled with the axis from incoming
     _reference_ messages.
-    When resample_rate is not None (i.e., prescribed float resample_rate), this buffer 
+    When resample_rate is not None (i.e., prescribed float resample_rate), this buffer
     is filled with a synthetic axis that is generated from the incoming signal messages.
     """
 
@@ -67,7 +67,7 @@ class ResampleState:
     """
     The last value of the reference axis that was returned. This helps us to know
     what the _next_ returned value should be, and to avoid returning the same value.
-    TODO: We can eliminate this variable if we maintain "by convention" that the 
+    TODO: We can eliminate this variable if we maintain "by convention" that the
     reference axis always has 1 value at its start that we exclude from the resampling.
     """
 
@@ -79,9 +79,7 @@ class ResampleState:
     """
 
 
-class ResampleProcessor(
-    BaseStatefulProcessor[ResampleSettings, AxisArray, AxisArray, ResampleState]
-):
+class ResampleProcessor(BaseStatefulProcessor[ResampleSettings, AxisArray, AxisArray, ResampleState]):
     def _hash_message(self, message: AxisArray) -> int:
         ax_idx: int = message.get_axis_idx(self.settings.axis)
         sample_shape = message.data.shape[:ax_idx] + message.data.shape[ax_idx + 1 :]
@@ -135,17 +133,11 @@ class ResampleProcessor(
         ax_idx = message.get_axis_idx(self.settings.axis)
         if self.settings.resample_rate is not None and message.data.shape[ax_idx] > 0:
             in_ax = message.axes[self.settings.axis]
-            in_t_end = (
-                in_ax.data[-1]
-                if hasattr(in_ax, "data")
-                else in_ax.value(message.data.shape[ax_idx] - 1)
-            )
+            in_t_end = in_ax.data[-1] if hasattr(in_ax, "data") else in_ax.value(message.data.shape[ax_idx] - 1)
             out_gain = 1 / self.settings.resample_rate
             prev_t_end = self.state.last_ref_ax_val
             n_synth = math.ceil((in_t_end - prev_t_end) * self.settings.resample_rate)
-            synth_ref_axis = LinearAxis(
-                unit="s", gain=out_gain, offset=prev_t_end + out_gain
-            )
+            synth_ref_axis = LinearAxis(unit="s", gain=out_gain, offset=prev_t_end + out_gain)
             self.state.ref_axis_buffer.write(synth_ref_axis, n_samples=n_synth)
 
         self.state.last_write_time = time.time()
@@ -193,11 +185,7 @@ class ResampleProcessor(
         # Get source to train interpolation
         src_axarr = src.peek()
         src_axis = src_axarr.axes[self.settings.axis]
-        x = (
-            src_axis.data
-            if hasattr(src_axis, "data")
-            else src_axis.value(np.arange(src_axarr.data.shape[0]))
-        )
+        x = src_axis.data if hasattr(src_axis, "data") else src_axis.value(np.arange(src_axarr.data.shape[0]))
 
         # Only resample at reference values that have not been interpolated over previously.
         b_ref = ref_xvec > self.state.last_ref_ax_val
@@ -208,11 +196,7 @@ class ResampleProcessor(
 
         if len(ref_idx) == 0:
             # Nothing to interpolate over; return empty data
-            null_ref = (
-                replace(ref_ax, data=ref_ax.data[:0])
-                if hasattr(ref_ax, "data")
-                else ref_ax
-            )
+            null_ref = replace(ref_ax, data=ref_ax.data[:0]) if hasattr(ref_ax, "data") else ref_ax
             return replace(
                 src_axarr,
                 data=src_axarr.data[:0, ...],
@@ -222,17 +206,12 @@ class ResampleProcessor(
         xnew = ref_xvec[ref_idx]
 
         # Identify source data indices around ref tvec with some padding for better interpolation.
-        src_start_ix = max(
-            0, np.where(x > xnew[0])[0][0] - 2 if np.any(x > xnew[0]) else 0
-        )
+        src_start_ix = max(0, np.where(x > xnew[0])[0][0] - 2 if np.any(x > xnew[0]) else 0)
 
         x = x[src_start_ix:]
         y = src_axarr.data[src_start_ix:]
 
-        if (
-            isinstance(self.settings.fill_value, str)
-            and self.settings.fill_value == "last"
-        ):
+        if isinstance(self.settings.fill_value, str) and self.settings.fill_value == "last":
             fill_value = (y[0], y[-1])
         else:
             fill_value = self.settings.fill_value

ezmsg/sigproc/rollingscaler.py

@@ -3,14 +3,15 @@ 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 (
     BaseAdaptiveTransformer,
     BaseAdaptiveTransformerUnit,
     processor_state,
 )
 from ezmsg.sigproc.sampler import SampleMessage
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
 
 
 class RollingScalerSettings(ez.Settings):
@@ -71,11 +72,7 @@ class RollingScalerState:
     min_samples: int | None = None
 
 
-class RollingScalerProcessor(
-    BaseAdaptiveTransformer[
-        RollingScalerSettings, AxisArray, AxisArray, RollingScalerState
-    ]
-):
+class RollingScalerProcessor(BaseAdaptiveTransformer[RollingScalerSettings, AxisArray, AxisArray, RollingScalerState]):
     """
     Processor for rolling z-score normalization of input `AxisArray` messages.
 
@@ -119,40 +116,23 @@ class RollingScalerProcessor(
         self._state.N = 0
         self._state.M2 = np.zeros(ch)
         self._state.k_samples = (
-            int(
-                np.ceil(
-                    self.settings.window_size / message.axes[self.settings.axis].gain
-                )
-            )
+            int(np.ceil(self.settings.window_size / message.axes[self.settings.axis].gain))
             if self.settings.window_size is not None
             else self.settings.k_samples
         )
         if self._state.k_samples is not None and self._state.k_samples < 1:
-            ez.logger.warning(
-                "window_size smaller than sample gain; setting k_samples to 1."
-            )
+            ez.logger.warning("window_size smaller than sample gain; setting k_samples to 1.")
             self._state.k_samples = 1
         elif self._state.k_samples is None:
-            ez.logger.warning(
-                "k_samples is None; z-score accumulation will be unbounded."
-            )
+            ez.logger.warning("k_samples is None; z-score accumulation will be unbounded.")
         self._state.samples = deque(maxlen=self._state.k_samples)
         self._state.min_samples = (
-            int(
-                np.ceil(
-                    self.settings.min_seconds / message.axes[self.settings.axis].gain
-                )
-            )
+            int(np.ceil(self.settings.min_seconds / message.axes[self.settings.axis].gain))
             if self.settings.window_size is not None
             else self.settings.min_samples
         )
-        if (
-            self._state.k_samples is not None
-            and self._state.min_samples > self._state.k_samples
-        ):
-            ez.logger.warning(
-                "min_samples is greater than k_samples; adjusting min_samples to k_samples."
-            )
+        if self._state.k_samples is not None and self._state.min_samples > self._state.k_samples:
+            ez.logger.warning("min_samples is greater than k_samples; adjusting min_samples to k_samples.")
             self._state.min_samples = self._state.k_samples
 
     def _add_batch_stats(self, x: npt.NDArray) -> None:
@@ -161,10 +141,7 @@ class RollingScalerProcessor(
         mean_b = np.mean(x, axis=0)
         M2_b = np.sum((x - mean_b) ** 2, axis=0)
 
-        if (
-            self._state.k_samples is not None
-            and len(self._state.samples) == self._state.k_samples
-        ):
+        if self._state.k_samples is not None and len(self._state.samples) == self._state.k_samples:
             n_old, mean_old, M2_old = self._state.samples.popleft()
             N_T = self._state.N
             N_new = N_T - n_old
@@ -177,9 +154,7 @@ class RollingScalerProcessor(
                 delta = mean_old - self._state.mean
                 self._state.N = N_new
                 self._state.mean = (N_T * self._state.mean - n_old * mean_old) / N_new
-                self._state.M2 = (
-                    self._state.M2 - M2_old - (delta * delta) * (N_T * n_old / N_new)
-                )
+                self._state.M2 = self._state.M2 - M2_old - (delta * delta) * (N_T * n_old / N_new)
 
         N_A = self._state.N
         N = N_A + n_b

ezmsg/sigproc/sampler.py

@@ -1,28 +1,28 @@
 import asyncio
-from collections import deque
 import copy
 import traceback
 import typing
+from collections import deque
 
-import numpy as np
 import ezmsg.core as ez
+import numpy as np
+from ezmsg.baseproc import (
+    BaseConsumerUnit,
+    BaseProducerUnit,
+    BaseStatefulProducer,
+    BaseStatefulTransformer,
+    BaseTransformerUnit,
+    processor_state,
+)
 from ezmsg.util.messages.axisarray import (
     AxisArray,
 )
 from ezmsg.util.messages.util import replace
 
-from .util.profile import profile_subpub
 from .util.axisarray_buffer import HybridAxisArrayBuffer
 from .util.buffer import UpdateStrategy
 from .util.message import SampleMessage, SampleTriggerMessage
-from .base import (
-    BaseStatefulTransformer,
-    BaseConsumerUnit,
-    BaseTransformerUnit,
-    BaseStatefulProducer,
-    BaseProducerUnit,
-    processor_state,
-)
+from .util.profile import profile_subpub
 
 
 class SamplerSettings(ez.Settings):
@@ -74,12 +74,8 @@ class SamplerState:
     triggers: deque[SampleTriggerMessage] | None = None
 
 
-class SamplerTransformer(
-    BaseStatefulTransformer[SamplerSettings, AxisArray, AxisArray, SamplerState]
-):
-    def __call__(
-        self, message: AxisArray | SampleTriggerMessage
-    ) -> list[SampleMessage]:
+class SamplerTransformer(BaseStatefulTransformer[SamplerSettings, AxisArray, AxisArray, SamplerState]):
+    def __call__(self, message: AxisArray | SampleTriggerMessage) -> list[SampleMessage]:
         # TODO: Currently we have a single entry point that accepts both
         #  data and trigger messages and we choose a code path based on
         #  the message type. However, in the future we will likely replace
@@ -99,9 +95,7 @@ class SamplerTransformer(
         # Compute hash based on message properties that require state reset
         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.key))
 
     def _reset_state(self, message: AxisArray) -> None:
@@ -193,20 +187,14 @@ class SamplerTransformer(
         trigger_ts: float = message.timestamp
         if not self.settings.estimate_alignment:
             # Override the trigger timestamp with the next sample's likely timestamp.
-            trigger_ts = (
-                self._state.buffer.axis_final_value + self._state.buffer.axis_gain
-            )
+            trigger_ts = self._state.buffer.axis_final_value + self._state.buffer.axis_gain
 
-        new_trig_msg = replace(
-            message, timestamp=trigger_ts, period=_period, value=_value
-        )
+        new_trig_msg = replace(message, timestamp=trigger_ts, period=_period, value=_value)
         self._state.triggers.append(new_trig_msg)
         return []
 
 
-class Sampler(
-    BaseTransformerUnit[SamplerSettings, AxisArray, AxisArray, SamplerTransformer]
-):
+class Sampler(BaseTransformerUnit[SamplerSettings, AxisArray, AxisArray, SamplerTransformer]):
     SETTINGS = SamplerSettings
 
     INPUT_TRIGGER = ez.InputStream(SampleTriggerMessage)
@@ -269,19 +257,13 @@ class TriggerGeneratorState:
     output: int = 0
 
 
-class TriggerProducer(
-    BaseStatefulProducer[
-        TriggerGeneratorSettings, SampleTriggerMessage, TriggerGeneratorState
-    ]
-):
+class TriggerProducer(BaseStatefulProducer[TriggerGeneratorSettings, SampleTriggerMessage, TriggerGeneratorState]):
     def _reset_state(self) -> None:
         self._state.output = 0
 
     async def _produce(self) -> SampleTriggerMessage:
         await asyncio.sleep(self.settings.publish_period)
-        out_msg = SampleTriggerMessage(
-            period=self.settings.period, value=self._state.output
-        )
+        out_msg = SampleTriggerMessage(period=self.settings.period, value=self._state.output)
         self._state.output += 1
         return out_msg
 

ezmsg/sigproc/scaler.py

@@ -1,27 +1,24 @@
 import typing
 
 import numpy as np
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-from ezmsg.util.generator import consumer
-
-from .base import (
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
 )
-from .ewma import EWMATransformer, EWMASettings, _alpha_from_tau
+from ezmsg.util.generator import consumer
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 # Imports for backwards compatibility with previous module location
 from .ewma import EWMA_Deprecated as EWMA_Deprecated
-from .ewma import ewma_step as ewma_step
+from .ewma import EWMASettings, EWMATransformer, _alpha_from_tau
 from .ewma import _tau_from_alpha as _tau_from_alpha
+from .ewma import ewma_step as ewma_step
 
 
 @consumer
-def scaler(
-    time_constant: float = 1.0, axis: str | None = None
-) -> typing.Generator[AxisArray, AxisArray, None]:
+def scaler(time_constant: float = 1.0, axis: str | None = None) -> typing.Generator[AxisArray, AxisArray, None]:
     """
     Apply the adaptive standard scaler from https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/
     This is faster than :obj:`scaler_np` for single-channel data.
@@ -85,19 +82,13 @@ 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)
+        self._state.vars_sq_ewma = EWMATransformer(time_constant=self.settings.time_constant, axis=self.settings.axis)
 
     def _process(self, message: AxisArray) -> AxisArray:
         # Update step
         mean_message = self._state.samps_ewma(message)
-        var_sq_message = self._state.vars_sq_ewma(
-            replace(message, data=message.data**2)
-        )
+        var_sq_message = self._state.vars_sq_ewma(replace(message, data=message.data**2))
 
         # Get step
         varis = var_sq_message.data - mean_message.data**2
@@ -119,9 +110,7 @@ class AdaptiveStandardScaler(
 
 
 # Backwards compatibility...
-def scaler_np(
-    time_constant: float = 1.0, axis: str | None = None
-) -> AdaptiveStandardScalerTransformer:
+def scaler_np(time_constant: float = 1.0, axis: str | None = None) -> AdaptiveStandardScalerTransformer:
     return AdaptiveStandardScalerTransformer(
         settings=AdaptiveStandardScalerSettings(time_constant=time_constant, axis=axis)
     )

ezmsg/sigproc/signalinjector.py

@@ -1,14 +1,13 @@
 import ezmsg.core as ez
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
 import numpy as np
 import numpy.typing as npt
-
-from .base import (
+from ezmsg.baseproc import (
     BaseAsyncTransformer,
     BaseTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 
 class SignalInjectorSettings(ez.Settings):
@@ -27,15 +26,11 @@ class SignalInjectorState:
 
 
 class SignalInjectorTransformer(
-    BaseAsyncTransformer[
-        SignalInjectorSettings, AxisArray, AxisArray, SignalInjectorState
-    ]
+    BaseAsyncTransformer[SignalInjectorSettings, AxisArray, AxisArray, SignalInjectorState]
 ):
     def _hash_message(self, message: AxisArray) -> int:
         time_ax_idx = message.get_axis_idx(self.settings.time_dim)
-        sample_shape = (
-            message.data.shape[:time_ax_idx] + message.data.shape[time_ax_idx + 1 :]
-        )
+        sample_shape = message.data.shape[:time_ax_idx] + message.data.shape[time_ax_idx + 1 :]
         return hash((message.key,) + sample_shape)
 
     def _reset_state(self, message: AxisArray) -> None:
@@ -44,9 +39,7 @@ class SignalInjectorTransformer(
         if self._state.cur_amplitude is None:
             self._state.cur_amplitude = self.settings.amplitude
         time_ax_idx = message.get_axis_idx(self.settings.time_dim)
-        self._state.cur_shape = (
-            message.data.shape[:time_ax_idx] + message.data.shape[time_ax_idx + 1 :]
-        )
+        self._state.cur_shape = message.data.shape[:time_ax_idx] + message.data.shape[time_ax_idx + 1 :]
         rng = np.random.default_rng(self.settings.mixing_seed)
         self._state.mixing = rng.random((1, message.shape2d(self.settings.time_dim)[1]))
         self._state.mixing = (self._state.mixing * 2.0) - 1.0
@@ -63,11 +56,7 @@ class SignalInjectorTransformer(
         return out_msg
 
 
-class SignalInjector(
-    BaseTransformerUnit[
-        SignalInjectorSettings, AxisArray, AxisArray, SignalInjectorTransformer
-    ]
-):
+class SignalInjector(BaseTransformerUnit[SignalInjectorSettings, AxisArray, AxisArray, SignalInjectorTransformer]):
     SETTINGS = SignalInjectorSettings
     INPUT_FREQUENCY = ez.InputStream(float | None)
     INPUT_AMPLITUDE = ez.InputStream(float)

ezmsg/sigproc/slicer.py

@@ -1,17 +1,16 @@
+import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-import ezmsg.core as ez
+from ezmsg.baseproc import (
+    BaseStatefulTransformer,
+    BaseTransformerUnit,
+    processor_state,
+)
 from ezmsg.util.messages.axisarray import (
     AxisArray,
-    slice_along_axis,
     AxisBase,
     replace,
-)
-
-from .base import (
-    BaseStatefulTransformer,
-    BaseTransformerUnit,
-    processor_state,
+    slice_along_axis,
 )
 
 """
@@ -49,11 +48,7 @@ def parse_slice(
     if "," not in s:
         parts = [part.strip() for part in s.split(":")]
         if len(parts) == 1:
-            if (
-                axinfo is not None
-                and hasattr(axinfo, "data")
-                and parts[0] in axinfo.data
-            ):
+            if axinfo is not None and hasattr(axinfo, "data") and parts[0] in axinfo.data:
                 return tuple(np.where(axinfo.data == parts[0])[0])
             return (int(parts[0]),)
         return (slice(*(int(part.strip()) if part else None for part in parts)),)
@@ -76,9 +71,7 @@ class SlicerState:
     b_change_dims: bool = False
 
 
-class SlicerTransformer(
-    BaseStatefulTransformer[SlicerSettings, AxisArray, AxisArray, SlicerState]
-):
+class SlicerTransformer(BaseStatefulTransformer[SlicerSettings, AxisArray, AxisArray, SlicerState]):
     def _hash_message(self, message: AxisArray) -> int:
         axis = self.settings.axis or message.dims[-1]
         axis_idx = message.get_axis_idx(axis)
@@ -101,11 +94,7 @@ class SlicerTransformer(
             self._state.slice_ = np.s_[indices]
 
         # Create the output axis
-        if (
-            axis in message.axes
-            and hasattr(message.axes[axis], "data")
-            and len(message.axes[axis].data) > 0
-        ):
+        if axis in message.axes and hasattr(message.axes[axis], "data") and len(message.axes[axis].data) > 0:
             in_data = np.array(message.axes[axis].data)
             if self._state.b_change_dims:
                 out_data = in_data[self._state.slice_ : self._state.slice_ + 1]
@@ -119,17 +108,10 @@ class SlicerTransformer(
 
         replace_kwargs = {}
         if self._state.b_change_dims:
-            replace_kwargs["dims"] = [
-                _ for dim_ix, _ in enumerate(message.dims) if dim_ix != axis_idx
-            ]
-            replace_kwargs["axes"] = {
-                k: v for k, v in message.axes.items() if k != axis
-            }
+            replace_kwargs["dims"] = [_ for dim_ix, _ in enumerate(message.dims) if dim_ix != axis_idx]
+            replace_kwargs["axes"] = {k: v for k, v in message.axes.items() if k != axis}
         elif self._state.new_axis is not None:
-            replace_kwargs["axes"] = {
-                k: (v if k != axis else self._state.new_axis)
-                for k, v in message.axes.items()
-            }
+            replace_kwargs["axes"] = {k: (v if k != axis else self._state.new_axis) for k, v in message.axes.items()}
 
         return replace(
             message,
@@ -138,9 +120,7 @@ class SlicerTransformer(
         )
 
 
-class Slicer(
-    BaseTransformerUnit[SlicerSettings, AxisArray, AxisArray, SlicerTransformer]
-):
+class Slicer(BaseTransformerUnit[SlicerSettings, AxisArray, AxisArray, SlicerTransformer]):
     SETTINGS = SlicerSettings
 
 

ezmsg/sigproc/spectral.py

@@ -1,6 +1,6 @@
 from .spectrum import OptionsEnum as OptionsEnum
-from .spectrum import WindowFunction as WindowFunction
-from .spectrum import SpectralTransform as SpectralTransform
 from .spectrum import SpectralOutput as SpectralOutput
-from .spectrum import SpectrumSettings as SpectrumSettings
+from .spectrum import SpectralTransform as SpectralTransform
 from .spectrum import Spectrum as Spectrum
+from .spectrum import SpectrumSettings as SpectrumSettings
+from .spectrum import WindowFunction as WindowFunction