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

ezmsg/sigproc/fbcca.py

@@ -1,29 +1,26 @@
-import typing
 import math
+import typing
 from dataclasses import field
 
-import numpy as np
-
 import ezmsg.core as ez
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-
-from .sampler import SampleTriggerMessage
-from .window import WindowTransformer, WindowSettings
-
-from .base import (
+import numpy as np
+from ezmsg.baseproc import (
+    BaseProcessor,
+    BaseStatefulProcessor,
     BaseTransformer,
     BaseTransformerUnit,
     CompositeProcessor,
-    BaseProcessor,
-    BaseStatefulProcessor,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
-from .kaiser import KaiserFilterSettings
 from .filterbankdesign import (
     FilterbankDesignSettings,
     FilterbankDesignTransformer,
 )
+from .kaiser import KaiserFilterSettings
+from .sampler import SampleTriggerMessage
+from .window import WindowSettings, WindowTransformer
 
 
 class FBCCASettings(ez.Settings):
@@ -33,7 +30,7 @@ class FBCCASettings(ez.Settings):
 
     time_dim: str
     """
-    The time dim in the data array.  
+    The time dim in the data array.
     """
 
     ch_dim: str
@@ -49,40 +46,41 @@ class FBCCASettings(ez.Settings):
 
     harmonics: int = 5
     """
-    The number of additional harmonics beyond the fundamental to use for the 'design' matrix.  
-    5 (default): Evaluate 5 harmonics of the base frequency.  
-    Many periodic signals are not pure sinusoids, and inclusion of higher harmonics can help evaluate the 
+    The number of additional harmonics beyond the fundamental to use for the 'design' matrix.
+    5 (default): Evaluate 5 harmonics of the base frequency.
+    Many periodic signals are not pure sinusoids, and inclusion of higher harmonics can help evaluate the
     presence of signals with higher frequency harmonic content
     """
 
     freqs: typing.List[float] = field(default_factory=list)
     """
-    Frequencies (in hz) to evaluate the presence of within the input signal.  
-    [] (default): an empty list; frequencies will be found within the input SampleMessages.  
+    Frequencies (in hz) to evaluate the presence of within the input signal.
+    [] (default): an empty list; frequencies will be found within the input SampleMessages.
     AxisArrays have no good place to put this metadata, so specify frequencies here if only AxisArrays
     will be passed as input to the generator.  If the input has a `trigger` attr of type :obj:`SampleTriggerMessage`,
-    the processor looks for the `freqs` attribute within that trigger for a list of frequencies to evaluate.  
-    This field is present in the :obj:`SSVEPSampleTriggerMessage` defined in ezmsg.tasks.ssvep from the ezmsg-tasks package.
+    the processor looks for the `freqs` attribute within that trigger for a list of frequencies to evaluate.
+    This field is present in the :obj:`SSVEPSampleTriggerMessage` defined in ezmsg.tasks.ssvep from
+    the ezmsg-tasks package.
     NOTE: Avoid frequencies that have line-noise (60 Hz/50 Hz) as a harmonic.
     """
 
     softmax_beta: float = 1.0
     """
-    Beta parameter for softmax on output --> "probabilities".  
-    1.0 (default): Use the shifted softmax transformation to output 0-1 probabilities.  
+    Beta parameter for softmax on output --> "probabilities".
+    1.0 (default): Use the shifted softmax transformation to output 0-1 probabilities.
     If 0.0, the maximum singular value of the SVD for each design matrix is output
     """
 
     target_freq_dim: str = "target_freq"
     """
-    Name for dim to put target frequency outputs on.  
+    Name for dim to put target frequency outputs on.
     'target_freq' (default)
     """
 
     max_int_time: float = 0.0
     """
-    Maximum integration time (in seconds) to use for calculation.  
-    0 (default): Use all time provided for the calculation.  
+    Maximum integration time (in seconds) to use for calculation.
+    0 (default): Use all time provided for the calculation.
     Useful for artificially limiting the amount of data used for the CCA method to evaluate
     the necessary integration time for good decoding performance
     """
@@ -136,9 +134,7 @@ class FBCCATransformer(BaseTransformer[FBCCASettings, AxisArray, AxisArray]):
         if filterbank_dim_idx is not None:
             new_order.append(filterbank_dim_idx)
         new_order.extend([time_dim_idx, ch_dim_idx])
-        out_dims = [
-            message.dims[i] for i in new_order if message.dims[i] not in rm_dims
-        ]
+        out_dims = [message.dims[i] for i in new_order if message.dims[i] not in rm_dims]
         data_arr = message.data.transpose(new_order)
 
         # Add a singleton dim for filterbank dim if we don't have one
@@ -158,10 +154,7 @@ class FBCCATransformer(BaseTransformer[FBCCASettings, AxisArray, AxisArray]):
             axis_name: axis
             for axis_name, axis in message.axes.items()
             if axis_name not in rm_dims
-            and not (
-                isinstance(axis, AxisArray.CoordinateAxis)
-                and any(d in rm_dims for d in axis.dims)
-            )
+            and not (isinstance(axis, AxisArray.CoordinateAxis) and any(d in rm_dims for d in axis.dims))
         }
         out_axes[self.settings.target_freq_dim] = AxisArray.CoordinateAxis(
             np.array(test_freqs), [self.settings.target_freq_dim]
@@ -193,15 +186,9 @@ class FBCCATransformer(BaseTransformer[FBCCASettings, AxisArray, AxisArray]):
                 ]
             )
 
-            for test_idx, arr in enumerate(
-                data_arr
-            ):  # iterate over first dim; arr is (filterbank x time x ch)
-                for band_idx, band in enumerate(
-                    arr
-                ):  # iterate over second dim: arr is (time x ch)
-                    calc_output[test_idx, band_idx, test_freq_idx] = cca_rho_max(
-                        band[:max_samp, ...], Y
-                    )
+            for test_idx, arr in enumerate(data_arr):  # iterate over first dim; arr is (filterbank x time x ch)
+                for band_idx, band in enumerate(arr):  # iterate over second dim: arr is (time x ch)
+                    calc_output[test_idx, band_idx, test_freq_idx] = cca_rho_max(band[:max_samp, ...], Y)
 
         # Combine per-subband canonical correlations using a weighted sum
         # https://iopscience.iop.org/article/10.1088/1741-2560/12/4/046008
@@ -209,9 +196,7 @@ class FBCCATransformer(BaseTransformer[FBCCASettings, AxisArray, AxisArray]):
         calc_output = ((calc_output**2) * freq_weights[None, :, None]).sum(axis=1)
 
         if self.settings.softmax_beta != 0:
-            calc_output = calc_softmax(
-                calc_output, axis=-1, beta=self.settings.softmax_beta
-            )
+            calc_output = calc_softmax(calc_output, axis=-1, beta=self.settings.softmax_beta)
 
         output = replace(
             message,
@@ -244,9 +229,7 @@ class StreamingFBCCASettings(FBCCASettings):
     subbands: int = 12
 
 
-class StreamingFBCCATransformer(
-    CompositeProcessor[StreamingFBCCASettings, AxisArray, AxisArray]
-):
+class StreamingFBCCATransformer(CompositeProcessor[StreamingFBCCASettings, AxisArray, AxisArray]):
     @staticmethod
     def _initialize_processors(
         settings: StreamingFBCCASettings,
@@ -254,9 +237,7 @@ class StreamingFBCCATransformer(
         pipeline = {}
 
         if settings.filterbank_dim is not None:
-            cut_freqs = (
-                np.arange(settings.subbands + 1) * settings.filter_bw
-            ) + settings.filter_low
+            cut_freqs = (np.arange(settings.subbands + 1) * settings.filter_bw) + settings.filter_low
             filters = [
                 KaiserFilterSettings(
                     axis=settings.time_dim,
@@ -269,9 +250,7 @@ class StreamingFBCCATransformer(
             ]
 
             pipeline["filterbank"] = FilterbankDesignTransformer(
-                FilterbankDesignSettings(
-                    filters=filters, new_axis=settings.filterbank_dim
-                )
+                FilterbankDesignSettings(filters=filters, new_axis=settings.filterbank_dim)
             )
 
         pipeline["window"] = WindowTransformer(
@@ -289,11 +268,7 @@ class StreamingFBCCATransformer(
         return pipeline
 
 
-class StreamingFBCCA(
-    BaseTransformerUnit[
-        StreamingFBCCASettings, AxisArray, AxisArray, StreamingFBCCATransformer
-    ]
-):
+class StreamingFBCCA(BaseTransformerUnit[StreamingFBCCASettings, AxisArray, AxisArray, StreamingFBCCATransformer]):
     SETTINGS = StreamingFBCCASettings
 
 

ezmsg/sigproc/filter.py

@@ -1,21 +1,21 @@
-from abc import abstractmethod, ABC
-from dataclasses import dataclass, field
 import typing
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
 
 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
 import scipy.signal
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 from ezmsg.sigproc.base import (
-    processor_state,
+    BaseConsumerUnit,
     BaseStatefulTransformer,
     BaseTransformerUnit,
     SettingsType,
-    BaseConsumerUnit,
     TransformerType,
+    processor_state,
 )
 
 
@@ -68,9 +68,7 @@ class FilterState:
     zi: npt.NDArray | None = None
 
 
-class FilterTransformer(
-    BaseStatefulTransformer[FilterSettings, AxisArray, AxisArray, FilterState]
-):
+class FilterTransformer(BaseStatefulTransformer[FilterSettings, AxisArray, AxisArray, FilterState]):
     """
     Filter data using the provided coefficients.
     """
@@ -108,9 +106,7 @@ class FilterTransformer(
             zi = scipy.signal.sosfilt_zi(*coefs)
 
         zi_expand = (None,) * axis_idx + (slice(None),) + (None,) * n_tail
-        n_tile = (
-            message.data.shape[:axis_idx] + (1,) + message.data.shape[axis_idx + 1 :]
-        )
+        n_tile = message.data.shape[:axis_idx] + (1,) + message.data.shape[axis_idx + 1 :]
 
         if self.settings.coef_type == "sos":
             zi_expand = (slice(None),) + zi_expand
@@ -144,17 +140,11 @@ class FilterTransformer(
             reset_needed = False
 
             if self.settings.coef_type == "ba":
-                if isinstance(old_coefs, FilterCoefficients) and isinstance(
-                    coefs, FilterCoefficients
-                ):
-                    if len(old_coefs.b) != len(coefs.b) or len(old_coefs.a) != len(
-                        coefs.a
-                    ):
+                if isinstance(old_coefs, FilterCoefficients) and isinstance(coefs, FilterCoefficients):
+                    if len(old_coefs.b) != len(coefs.b) or len(old_coefs.a) != len(coefs.a):
                         reset_needed = True
                 elif isinstance(old_coefs, tuple) and isinstance(coefs, tuple):
-                    if len(old_coefs[0]) != len(coefs[0]) or len(old_coefs[1]) != len(
-                        coefs[1]
-                    ):
+                    if len(old_coefs[0]) != len(coefs[0]) or len(old_coefs[1]) != len(coefs[1]):
                         reset_needed = True
                 else:
                     reset_needed = True
@@ -173,36 +163,26 @@ class FilterTransformer(
             axis = message.dims[0] if self.settings.axis is None else self.settings.axis
             axis_idx = message.get_axis_idx(axis)
             _, coefs = _normalize_coefs(self.settings.coefs)
-            filt_func = {"ba": scipy.signal.lfilter, "sos": scipy.signal.sosfilt}[
-                self.settings.coef_type
-            ]
-            dat_out, self.state.zi = filt_func(
-                *coefs, message.data, axis=axis_idx, zi=self.state.zi
-            )
+            filt_func = {"ba": scipy.signal.lfilter, "sos": scipy.signal.sosfilt}[self.settings.coef_type]
+            dat_out, self.state.zi = filt_func(*coefs, message.data, axis=axis_idx, zi=self.state.zi)
         else:
             dat_out = message.data
 
         return replace(message, data=dat_out)
 
 
-class Filter(
-    BaseTransformerUnit[FilterSettings, AxisArray, AxisArray, FilterTransformer]
-):
+class Filter(BaseTransformerUnit[FilterSettings, AxisArray, AxisArray, FilterTransformer]):
     SETTINGS = FilterSettings
 
 
-def filtergen(
-    axis: str, coefs: npt.NDArray | tuple[npt.NDArray] | None, coef_type: str
-) -> FilterTransformer:
+def filtergen(axis: str, coefs: npt.NDArray | tuple[npt.NDArray] | None, coef_type: str) -> FilterTransformer:
     """
     Filter data using the provided coefficients.
 
     Returns:
         :obj:`FilterTransformer`.
     """
-    return FilterTransformer(
-        FilterSettings(axis=axis, coefs=coefs, coef_type=coef_type)
-    )
+    return FilterTransformer(FilterSettings(axis=axis, coefs=coefs, coef_type=coef_type))
 
 
 @processor_state
@@ -230,9 +210,7 @@ class FilterByDesignTransformer(
         """Return a function that takes sampling frequency and returns filter coefficients."""
         ...
 
-    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.
 
@@ -271,9 +249,7 @@ class FilterByDesignTransformer(
                     b, a = coefs
                     coefs = scipy.signal.tf2sos(b, a)
 
-            self.state.filter.update_coefficients(
-                coefs, coef_type=self.settings.coef_type
-            )
+            self.state.filter.update_coefficients(coefs, coef_type=self.settings.coef_type)
             self.state.needs_redesign = False
 
         return super().__call__(message)
@@ -298,9 +274,7 @@ class FilterByDesignTransformer(
                 b, a = coefs
                 coefs = scipy.signal.tf2sos(b, a)
 
-        new_settings = FilterSettings(
-            axis=axis, coef_type=self.settings.coef_type, coefs=coefs
-        )
+        new_settings = FilterSettings(axis=axis, coef_type=self.settings.coef_type, coefs=coefs)
         self.state.filter = FilterTransformer(settings=new_settings)
 
     def _process(self, message: AxisArray) -> AxisArray:

ezmsg/sigproc/filterbank.py

@@ -2,20 +2,20 @@ import functools
 import math
 import typing
 
+import ezmsg.core as ez
 import numpy as np
-import scipy.signal as sps
-import scipy.fft as sp_fft
-from scipy.special import lambertw
 import numpy.typing as npt
-import ezmsg.core as ez
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-
-from .base import (
+import scipy.fft as sp_fft
+import scipy.signal as sps
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+from scipy.special import lambertw
+
 from .spectrum import OptionsEnum
 from .window import WindowTransformer
 
@@ -32,8 +32,14 @@ class MinPhaseMode(OptionsEnum):
     """The mode of operation for the filterbank."""
 
     NONE = "No kernel modification"
-    HILBERT = "Hilbert Method; designed to be used with equiripple filters (e.g., from remez) with unity or zero gain regions"
-    HOMOMORPHIC = "Works best with filters with an odd number of taps, and the resulting minimum phase filter will have a magnitude response that approximates the square root of the original filter’s magnitude response using half the number of taps"
+    HILBERT = (
+        "Hilbert Method; designed to be used with equiripple filters (e.g., from remez) with unity or zero gain regions"
+    )
+    HOMOMORPHIC = (
+        "Works best with filters with an odd number of taps, and the resulting minimum phase filter "
+        "will have a magnitude response that approximates the square root of the original filter’s "
+        "magnitude response using half the number of taps"
+    )
     # HOMOMORPHICFULL = "Like HOMOMORPHIC, but uses the full number of taps and same magnitude"
 
 
@@ -78,23 +84,17 @@ class FilterbankState:
     mode: FilterbankMode | None = None
 
 
-class FilterbankTransformer(
-    BaseStatefulTransformer[FilterbankSettings, AxisArray, AxisArray, FilterbankState]
-):
+class FilterbankTransformer(BaseStatefulTransformer[FilterbankSettings, AxisArray, AxisArray, FilterbankState]):
     def _hash_message(self, message: AxisArray) -> int:
         axis = self.settings.axis or message.dims[0]
         gain = message.axes[axis].gain if axis in message.axes else 1.0
         targ_ax_ix = message.get_axis_idx(axis)
-        in_shape = (
-            message.data.shape[:targ_ax_ix] + message.data.shape[targ_ax_ix + 1 :]
-        )
+        in_shape = message.data.shape[:targ_ax_ix] + message.data.shape[targ_ax_ix + 1 :]
 
         return hash(
             (
                 message.key,
-                gain
-                if self.settings.mode in [FilterbankMode.FFT, FilterbankMode.AUTO]
-                else None,
+                gain if self.settings.mode in [FilterbankMode.FFT, FilterbankMode.AUTO] else None,
                 message.data.dtype.kind,
                 in_shape,
             )
@@ -104,9 +104,7 @@ class FilterbankTransformer(
         axis = self.settings.axis or message.dims[0]
         gain = message.axes[axis].gain if axis in message.axes else 1.0
         targ_ax_ix = message.get_axis_idx(axis)
-        in_shape = (
-            message.data.shape[:targ_ax_ix] + message.data.shape[targ_ax_ix + 1 :]
-        )
+        in_shape = message.data.shape[:targ_ax_ix] + message.data.shape[targ_ax_ix + 1 :]
 
         kernels = self.settings.kernels
         if self.settings.min_phase != MinPhaseMode.NONE:
@@ -118,9 +116,7 @@ class FilterbankTransformer(
             kernels = [sps.minimum_phase(k, method=method) for k in kernels]
 
         # Determine if this will be operating with complex data.
-        b_complex = message.data.dtype.kind == "c" or any(
-            [_.dtype.kind == "c" for _ in kernels]
-        )
+        b_complex = message.data.dtype.kind == "c" or any([_.dtype.kind == "c" for _ in kernels])
 
         # Calculate window_dur, window_shift, nfft
         max_kernel_len = max([_.size for _ in kernels])
@@ -130,17 +126,13 @@ class FilterbankTransformer(
 
         # Prepare previous iteration's overlap tail to add to input -- all zeros.
         tail_shape = in_shape + (len(kernels), self._state.overlap)
-        self._state.tail = np.zeros(
-            tail_shape, dtype="complex" if b_complex else "float"
-        )
+        self._state.tail = np.zeros(tail_shape, dtype="complex" if b_complex else "float")
 
         # Prepare output template -- kernels axis immediately before the target axis
         dummy_shape = in_shape + (len(kernels), 0)
         self._state.template = AxisArray(
             data=np.zeros(dummy_shape, dtype="complex" if b_complex else "float"),
-            dims=message.dims[:targ_ax_ix]
-            + message.dims[targ_ax_ix + 1 :]
-            + [self.settings.new_axis, axis],
+            dims=message.dims[:targ_ax_ix] + message.dims[targ_ax_ix + 1 :] + [self.settings.new_axis, axis],
             axes=message.axes.copy(),
             key=message.key,
         )
@@ -155,8 +147,7 @@ class FilterbankTransformer(
             dummy_arr = np.zeros(n_dummy)
             self._state.mode = (
                 FilterbankMode.CONV
-                if sps.choose_conv_method(dummy_arr, concat_kernel, mode="full")
-                == "direct"
+                if sps.choose_conv_method(dummy_arr, concat_kernel, mode="full") == "direct"
                 else FilterbankMode.FFT
             )
 
@@ -166,16 +157,11 @@ class FilterbankTransformer(
                 len(kernels),
                 self._state.overlap + message.data.shape[targ_ax_ix],
             )
-            self._state.dest_arr = np.zeros(
-                dest_shape, dtype="complex" if b_complex else "float"
-            )
+            self._state.dest_arr = np.zeros(dest_shape, dtype="complex" if b_complex else "float")
             self._state.prep_kerns = kernels
         else:  # FFT mode
             # Calculate optimal nfft and windowing size.
-            opt_size = (
-                -self._state.overlap
-                * lambertw(-1 / (2 * math.e * self._state.overlap), k=-1).real
-            )
+            opt_size = -self._state.overlap * lambertw(-1 / (2 * math.e * self._state.overlap), k=-1).real
             self._state.nfft = sp_fft.next_fast_len(math.ceil(opt_size))
             win_len = self._state.nfft - self._state.overlap
             # infft same as nfft. Keeping as separate variable because I might need it again.
@@ -201,19 +187,11 @@ class FilterbankTransformer(
             #  for a rather simple calculation. We may revisit if `spectrum` gets additional features, such as
             #  more fft backends.
             if b_complex:
-                self._state.fft = functools.partial(
-                    sp_fft.fft, n=self._state.nfft, norm="backward"
-                )
-                self._state.ifft = functools.partial(
-                    sp_fft.ifft, n=self._state.infft, norm="backward"
-                )
+                self._state.fft = functools.partial(sp_fft.fft, n=self._state.nfft, norm="backward")
+                self._state.ifft = functools.partial(sp_fft.ifft, n=self._state.infft, norm="backward")
             else:
-                self._state.fft = functools.partial(
-                    sp_fft.rfft, n=self._state.nfft, norm="backward"
-                )
-                self._state.ifft = functools.partial(
-                    sp_fft.irfft, n=self._state.infft, norm="backward"
-                )
+                self._state.fft = functools.partial(sp_fft.rfft, n=self._state.nfft, norm="backward")
+                self._state.ifft = functools.partial(sp_fft.irfft, n=self._state.infft, norm="backward")
 
             # Calculate fft of kernels
             self._state.prep_kerns = np.array([self._state.fft(_) for _ in kernels])
@@ -229,9 +207,7 @@ class FilterbankTransformer(
             in_dat = np.moveaxis(message.data, targ_ax_ix, -1)
             if self._state.mode == FilterbankMode.FFT:
                 # Fix message.dims because we will pass it to windower
-                move_dims = (
-                    message.dims[:targ_ax_ix] + message.dims[targ_ax_ix + 1 :] + [axis]
-                )
+                move_dims = message.dims[:targ_ax_ix] + message.dims[targ_ax_ix + 1 :] + [axis]
                 message = replace(message, data=in_dat, dims=move_dims)
         else:
             in_dat = message.data
@@ -239,22 +215,15 @@ class FilterbankTransformer(
         if self._state.mode == FilterbankMode.CONV:
             n_dest = in_dat.shape[-1] + self._state.overlap
             if self._state.dest_arr.shape[-1] < n_dest:
-                pad = np.zeros(
-                    self._state.dest_arr.shape[:-1]
-                    + (n_dest - self._state.dest_arr.shape[-1],)
-                )
-                self._state.dest_arr = np.concatenate(
-                    [self._state.dest_arr, pad], axis=-1
-                )
+                pad = np.zeros(self._state.dest_arr.shape[:-1] + (n_dest - self._state.dest_arr.shape[-1],))
+                self._state.dest_arr = np.concatenate([self._state.dest_arr, pad], axis=-1)
             self._state.dest_arr.fill(0)
 
             # Note: I tried several alternatives to this loop; all were slower than this.
             #  numba.jit; stride_tricks + np.einsum; threading. Latter might be better with Python 3.13.
             for k_ix, k in enumerate(self._state.prep_kerns):
                 n_out = in_dat.shape[-1] + k.shape[-1] - 1
-                self._state.dest_arr[..., k_ix, :n_out] = np.apply_along_axis(
-                    np.convolve, -1, in_dat, k, mode="full"
-                )
+                self._state.dest_arr[..., k_ix, :n_out] = np.apply_along_axis(np.convolve, -1, in_dat, k, mode="full")
             self._state.dest_arr[..., : self._state.overlap] += self._state.tail
             new_tail = self._state.dest_arr[..., in_dat.shape[-1] : n_dest]
             if new_tail.size > 0:
@@ -278,18 +247,14 @@ class FilterbankTransformer(
             # Previous iteration's tail:
             overlapped[..., :1, : self._state.overlap] += self._state.tail
             # window-to-window:
-            overlapped[..., 1:, : self._state.overlap] += overlapped[
-                ..., :-1, -self._state.overlap :
-            ]
+            overlapped[..., 1:, : self._state.overlap] += overlapped[..., :-1, -self._state.overlap :]
             # Save tail:
             new_tail = overlapped[..., -1:, -self._state.overlap :]
             if new_tail.size > 0:
                 # All of the above code works if input is size-zero, but we don't want to save a zero-size tail.
                 self._state.tail = new_tail
             # Concat over win axis, without overlap.
-            res = overlapped[..., : -self._state.overlap].reshape(
-                overlapped.shape[:-2] + (-1,)
-            )
+            res = overlapped[..., : -self._state.overlap].reshape(overlapped.shape[:-2] + (-1,))
 
         return replace(
             self._state.template,
@@ -298,9 +263,7 @@ class FilterbankTransformer(
         )
 
 
-class Filterbank(
-    BaseTransformerUnit[FilterbankSettings, AxisArray, AxisArray, FilterbankTransformer]
-):
+class Filterbank(BaseTransformerUnit[FilterbankSettings, AxisArray, AxisArray, FilterbankTransformer]):
     SETTINGS = FilterbankSettings
 
 

ezmsg/sigproc/filterbankdesign.py

@@ -3,22 +3,19 @@ import typing
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-
-from ezmsg.util.messages.util import replace
-from ezmsg.util.messages.axisarray import AxisArray
-
-from .base import (
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 from .filterbank import (
-    FilterbankTransformer,
-    FilterbankSettings,
     FilterbankMode,
+    FilterbankSettings,
+    FilterbankTransformer,
     MinPhaseMode,
 )
-
 from .kaiser import KaiserFilterSettings, kaiser_design_fun
 
 
@@ -55,9 +52,7 @@ class FilterbankDesignState:
 
 
 class FilterbankDesignTransformer(
-    BaseStatefulTransformer[
-        FilterbankDesignSettings, AxisArray, AxisArray, FilterbankDesignState
-    ],
+    BaseStatefulTransformer[FilterbankDesignSettings, AxisArray, AxisArray, FilterbankDesignState],
 ):
     """
     Transformer that designs and applies a filterbank based on Kaiser windowed FIR filters.
@@ -70,9 +65,7 @@ class FilterbankDesignTransformer(
         else:
             raise ValueError(f"Invalid direction: {dir}. Must be 'in' or 'out'.")
 
-    def update_settings(
-        self, new_settings: typing.Optional[FilterbankDesignSettings] = None, **kwargs
-    ) -> None:
+    def update_settings(self, new_settings: typing.Optional[FilterbankDesignSettings] = None, **kwargs) -> None:
         """
         Update settings and mark that filter coefficients need to be recalculated.