ezmsg-sigproc 2.5.0__tar.gz → 2.6.0__tar.gz

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/.github/workflows/docs.yml

@@ -4,11 +4,12 @@ on:
   push:
     branches:
       - main
-    tags:
-      - 'v*'
   pull_request:
     branches:
+      - main
       - dev
+  release:
+    types: [published]
   workflow_dispatch:
 
 permissions:
@@ -52,8 +53,8 @@ jobs:
           path: 'docs/build/html'
 
   deploy:
-    # Only deploy on push to main or release tags
-    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v'))
+    # Only deploy when a release is published
+    if: github.event_name == 'release'
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

ezmsg_sigproc-2.6.0/.github/workflows/python-publish.yml

@@ -0,0 +1,29 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: build and upload release to PyPI
+    runs-on: ubuntu-latest
+    environment: "release"
+    permissions:
+      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Build Package
+        run: uv build
+
+      - name: Publish package distributions to PyPI
+        run: uv publish

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/.pre-commit-config.yaml

@@ -1,7 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    # Ruff version.
-    rev: v0.6.7
+    rev: v0.8.3
     hooks:
       # Run the linter.
       - id: ruff

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 2.5.0
+Version: 2.6.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
-License-File: LICENSE.txt
+License-File: LICENSE
 Requires-Python: >=3.10.15
 Requires-Dist: array-api-compat>=1.11.1
+Requires-Dist: ezmsg-baseproc>=1.0.3
 Requires-Dist: ezmsg>=3.6.0
 Requires-Dist: numba>=0.61.0
 Requires-Dist: numpy>=1.26.0

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/docs/source/conf.py

@@ -72,6 +72,7 @@ intersphinx_mapping = {
     "numpy": ("https://numpy.org/doc/stable/", None),
     "scipy": ("https://scipy.org/doc/scipy/", None),
     "ezmsg": ("https://www.ezmsg.org/ezmsg/", None),
+    "ezmsg.baseproc": ("https://www.ezmsg.org/ezmsg-baseproc/", None),
     "ezmsg.learn": ("https://www.ezmsg.org/ezmsg-learn/", None),
     "ezmsg.event": ("https://www.ezmsg.org/ezmsg-event/", None),
     "ezmsg.lsl": ("https://www.ezmsg.org/ezmsg-lsl/", None),

ezmsg_sigproc-2.6.0/docs/source/guides/ProcessorsBase.md

@@ -0,0 +1,58 @@
+## Signal Processor Base Classes
+
+The signal processors in `ezmsg-sigproc` are built on top of the base processor classes from `ezmsg-baseproc`. For comprehensive documentation on the processor architecture, including protocols, base classes, and implementation patterns, see the [ezmsg-baseproc documentation](https://www.ezmsg.org/ezmsg-baseproc/guides/ProcessorsBase.html).
+
+### Quick Reference
+
+The base classes provide a consistent pattern for building message processors:
+
+* **Processors** - Transform input messages to output messages
+* **Producers** - Generate output messages without requiring input
+* **Consumers** - Accept input messages without producing output
+* **Transformers** - A specific type of processor with typed input/output
+* **Stateful variants** - Processors that maintain state across invocations
+* **Adaptive transformers** - Transformers that can be trained via `partial_fit`
+* **Composite processors** - Chain multiple processors together efficiently
+
+### Signal Processing Example
+
+Here's an example of a signal processing transformer using `AxisArray`:
+
+```Python
+import ezmsg.core as ez
+from ezmsg.util.messages.axisarray import AxisArray, replace
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
+
+
+class ScaleTransformerSettings(ez.Settings):
+    scale: float = 1.0
+
+
+class ScaleTransformer(BaseTransformer[ScaleTransformerSettings, AxisArray, AxisArray]):
+    def _process(self, message: AxisArray) -> AxisArray:
+        return replace(message, data=message.data * self.settings.scale)
+
+
+class ScaleUnit(BaseTransformerUnit[
+        ScaleTransformerSettings,
+        AxisArray,
+        AxisArray,
+        ScaleTransformer,
+    ]):
+        SETTINGS = ScaleTransformerSettings
+```
+
+### Existing Signal Processors
+
+For examples of signal processing implementations, see the processors in `ezmsg.sigproc`:
+
+* **Filtering** - `ChebyshevFilterTransformer`, `CombFilterTransformer`, etc.
+* **Spectral** - `SpectrogramTransformer`, `SpectrumTransformer`, `WaveletTransformer`
+* **Resampling** - `DownsampleTransformer`, `DecimateTransformer`, `ResampleTransformer`
+* **Windowing** - `WindowTransformer`, `AggregateTransformer`
+* **Math** - `ScalerTransformer`, `LogTransformer`, `AbsTransformer`, `DifferenceTransformer`
+
+### Learn More
+
+* [Processor Base Classes (ezmsg-baseproc)](https://www.ezmsg.org/ezmsg-baseproc/guides/ProcessorsBase.html) - Full documentation on the processor architecture
+* [API Reference](../api/index) - Complete API documentation for ezmsg-sigproc

ezmsg_sigproc-2.6.0/docs/source/guides/how-tos/signalprocessing/composite.rst

@@ -0,0 +1,6 @@
+How to efficiently chain multiple signal processors in ezmsg?
+#############################################################
+
+For general composite processor implementation guidance, see the `ezmsg-baseproc documentation <https://www.ezmsg.org/ezmsg-baseproc/guides/ProcessorsBase.html>`_.
+
+(under construction)

ezmsg_sigproc-2.6.0/docs/source/guides/how-tos/signalprocessing/processor.rst

@@ -0,0 +1,8 @@
+How to write a signal processor in ezmsg?
+#########################################
+
+For general processor implementation guidance, see the `ezmsg-baseproc documentation <https://www.ezmsg.org/ezmsg-baseproc/guides/ProcessorsBase.html>`_.
+
+For signal processing specific patterns, see the existing processors in ``ezmsg.sigproc`` as examples.
+
+(under construction)

ezmsg_sigproc-2.6.0/docs/source/guides/how-tos/signalprocessing/stateful.rst

@@ -0,0 +1,8 @@
+How to implement a stateful signal processor in ezmsg?
+######################################################
+
+For general stateful processor implementation guidance, see the `ezmsg-baseproc documentation <https://www.ezmsg.org/ezmsg-baseproc/guides/ProcessorsBase.html>`_.
+
+For signal processing specific patterns using stateful processors, see implementations like ``ChebyshevFilterTransformer`` and ``WindowTransformer`` as examples.
+
+(under construction)

ezmsg_sigproc-2.6.0/docs/source/guides/how-tos/signalprocessing/unit.rst

@@ -0,0 +1,41 @@
+How to turn a signal processor into an ``ezmsg`` Unit?
+######################################################
+
+For general guidance on converting processors to ezmsg Units, see the `ezmsg-baseproc documentation <https://www.ezmsg.org/ezmsg-baseproc/guides/ProcessorsBase.html#implementing-a-custom-ezmsg-unit>`_.
+
+Example with Signal Processing
+------------------------------
+
+To convert a signal processor to an ``ezmsg`` Unit:
+
+1. **Define the Processor**: Create a class that inherits from the appropriate base class (e.g., ``BaseTransformer``, ``BaseStatefulTransformer``).
+2. **Implement the Processing Logic**: Override the ``_process`` method to implement the signal processing logic.
+3. **Create the Unit**: Inherit from the appropriate Unit base class (e.g., ``BaseTransformerUnit``).
+
+.. code-block:: python
+
+   import ezmsg.core as ez
+   from ezmsg.util.messages.axisarray import AxisArray
+   from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
+
+
+   class MyProcessorSettings(ez.Settings):
+       # Your settings here
+       pass
+
+
+   class MyProcessor(BaseTransformer[MyProcessorSettings, AxisArray, AxisArray]):
+       def _process(self, message: AxisArray) -> AxisArray:
+           # Your signal processing logic here
+           return message
+
+
+   class MyUnit(BaseTransformerUnit[
+           MyProcessorSettings,
+           AxisArray,
+           AxisArray,
+           MyProcessor,
+       ]):
+       SETTINGS = MyProcessorSettings
+
+(under construction)

ezmsg_sigproc-2.6.0/docs/source/guides/sigproc/base.rst

@@ -0,0 +1,19 @@
+Base Processors
+===============
+
+The base processor classes are provided by the ``ezmsg-baseproc`` package and re-exported from ``ezmsg.sigproc.base`` for backwards compatibility.
+
+For detailed documentation on the base processor architecture, see the `ezmsg-baseproc documentation <https://www.ezmsg.org/ezmsg-baseproc/>`_.
+
+.. note::
+   New code should import directly from ``ezmsg.baseproc`` instead of ``ezmsg.sigproc.base``.
+
+API Reference
+-------------
+
+The following classes are re-exported from ``ezmsg.baseproc``:
+
+.. automodule:: ezmsg.sigproc.base
+   :members:
+   :show-inheritance:
+   :imported-members:

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/pyproject.toml

@@ -13,6 +13,7 @@ requires-python = ">=3.10.15"
 dynamic = ["version"]
 dependencies = [
   "array-api-compat>=1.11.1",
+  "ezmsg-baseproc>=1.0.3",
   "ezmsg>=3.6.0",
   "numba>=0.61.0",
   "numpy>=1.26.0",
@@ -64,5 +65,24 @@ version-file = "src/ezmsg/sigproc/__version__.py"
 packages = ["src/ezmsg"]
 
 [tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 norecursedirs = "tests/helpers"
 addopts = "-p no:warnings"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+# Exclude auto-generated files
+exclude = ["*/__version__.py"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["ezmsg.sigproc"]
+known-third-party = ["ezmsg", "ezmsg.baseproc"]
+
+[tool.uv.sources]
+# Uncomment to use development version of ezmsg from git
+#ezmsg = { git = "https://github.com/ezmsg-org/ezmsg.git", branch = "dev" }

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/src/ezmsg/sigproc/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.5.0'
-__version_tuple__ = version_tuple = (2, 5, 0)
+__version__ = version = '2.6.0'
+__version_tuple__ = version_tuple = (2, 6, 0)
 
 __commit_id__ = commit_id = None

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/src/ezmsg/sigproc/activation.py

@@ -1,10 +1,10 @@
-import scipy.special
 import ezmsg.core as ez
+import scipy.special
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from .spectral import OptionsEnum
 from .base import BaseTransformer, BaseTransformerUnit
+from .spectral import OptionsEnum
 
 
 class ActivationFunction(OptionsEnum):
@@ -50,20 +50,14 @@ class ActivationTransformer(BaseTransformer[ActivationSettings, AxisArray, AxisA
             # str type handling
             function = self.settings.function.lower()
             if function not in ActivationFunction.options():
-                raise ValueError(
-                    f"Unrecognized activation function {function}. Must be one of {ACTIVATIONS.keys()}"
-                )
-            function = list(ACTIVATIONS.keys())[
-                ActivationFunction.options().index(function)
-            ]
+                raise ValueError(f"Unrecognized activation function {function}. Must be one of {ACTIVATIONS.keys()}")
+            function = list(ACTIVATIONS.keys())[ActivationFunction.options().index(function)]
             func = ACTIVATIONS[function]
 
         return replace(message, data=func(message.data))
 
 
-class Activation(
-    BaseTransformerUnit[ActivationSettings, AxisArray, AxisArray, ActivationTransformer]
-):
+class Activation(BaseTransformerUnit[ActivationSettings, AxisArray, AxisArray, ActivationTransformer]):
     SETTINGS = ActivationSettings
 
 

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/src/ezmsg/sigproc/adaptive_lattice_notch.py

@@ -1,11 +1,11 @@
+import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
 import scipy.signal
-import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray, CoordinateAxis
 from ezmsg.util.messages.util import replace
 
-from .base import processor_state, BaseStatefulTransformer
+from .base import BaseStatefulTransformer, processor_state
 
 
 class AdaptiveLatticeNotchFilterSettings(ez.Settings):
@@ -76,9 +76,7 @@ class AdaptiveLatticeNotchFilterTransformer(
 
         fs = 1 / message.axes[self.settings.axis].gain
         init_f = (
-            self.settings.init_notch_freq
-            if self.settings.init_notch_freq is not None
-            else 0.07178314656435313 * fs
+            self.settings.init_notch_freq if self.settings.init_notch_freq is not None else 0.07178314656435313 * fs
         )
         init_omega = init_f * (2 * np.pi) / fs
         init_k1 = -np.cos(init_omega)
@@ -91,9 +89,7 @@ class AdaptiveLatticeNotchFilterTransformer(
         self._state.k1 = init_k1 + np.zeros(sample_shape, dtype=float)
         self._state.freq_template = CoordinateAxis(
             data=np.zeros((0,) + sample_shape, dtype=float),
-            dims=[self.settings.axis]
-            + message.dims[:ax_idx]
-            + message.dims[ax_idx + 1 :],
+            dims=[self.settings.axis] + message.dims[:ax_idx] + message.dims[ax_idx + 1 :],
             unit="Hz",
         )
 
@@ -147,9 +143,7 @@ class AdaptiveLatticeNotchFilterTransformer(
             for ix, k in enumerate(self._state.k1.flatten()):
                 # Filter to get s_n (notch filter state)
                 a_s = [1, k * gamma_plus_1, gamma]
-                s_n[:, ix], self._state.zi[:, ix] = scipy.signal.lfilter(
-                    [1], a_s, _x[:, ix], zi=self._state.zi[:, ix]
-                )
+                s_n[:, ix], self._state.zi[:, ix] = scipy.signal.lfilter([1], a_s, _x[:, ix], zi=self._state.zi[:, ix])
 
                 # Apply output filter to get y_out
                 b_y = [1, 2 * k, 1]
@@ -159,17 +153,11 @@ class AdaptiveLatticeNotchFilterTransformer(
             s_n_reshaped = s_n.reshape((s_n.shape[0],) + x_data.shape[1:])
             s_final = s_n_reshaped[-1]  # Current s_n
             s_final_1 = s_n_reshaped[-2]  # s_n_1
-            s_final_2 = (
-                s_n_reshaped[-3] if len(s_n_reshaped) > 2 else self._state.s_history[0]
-            )  # s_n_2
+            s_final_2 = s_n_reshaped[-3] if len(s_n_reshaped) > 2 else self._state.s_history[0]  # s_n_2
 
             # Update p and q using final values
-            self._state.p = eta * self._state.p + one_minus_eta * (
-                s_final_1 * (s_final + s_final_2)
-            )
-            self._state.q = eta * self._state.q + one_minus_eta * (
-                2 * (s_final_1 * s_final_1)
-            )
+            self._state.p = eta * self._state.p + one_minus_eta * (s_final_1 * (s_final + s_final_2))
+            self._state.q = eta * self._state.q + one_minus_eta * (2 * (s_final_1 * s_final_1))
 
             # Update reflection coefficient
             new_k1 = -self._state.p / (self._state.q + 1e-8)  # Avoid division by zero
@@ -199,17 +187,11 @@ class AdaptiveLatticeNotchFilterTransformer(
                 y_out[sample_ix] = s_n + 2 * self._state.k1 * s_n_1 + s_n_2
 
                 # Update filter parameters
-                self._state.p = eta * self._state.p + one_minus_eta * (
-                    s_n_1 * (s_n + s_n_2)
-                )
-                self._state.q = eta * self._state.q + one_minus_eta * (
-                    2 * (s_n_1 * s_n_1)
-                )
+                self._state.p = eta * self._state.p + one_minus_eta * (s_n_1 * (s_n + s_n_2))
+                self._state.q = eta * self._state.q + one_minus_eta * (2 * (s_n_1 * s_n_1))
 
                 # Update reflection coefficient
-                new_k1 = -self._state.p / (
-                    self._state.q + 1e-8
-                )  # Avoid division by zero
+                new_k1 = -self._state.p / (self._state.q + 1e-8)  # Avoid division by zero
                 new_k1 = np.clip(new_k1, -1, 1)  # Clip to prevent instability
                 self._state.k1 = mu * self._state.k1 + one_minus_mu * new_k1  # Smoothed
 

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/src/ezmsg/sigproc/affinetransform.py

@@ -1,16 +1,16 @@
 import os
 from pathlib import Path
 
+import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray, AxisBase
 from ezmsg.util.messages.util import replace
 
 from .base import (
     BaseStatefulTransformer,
-    BaseTransformerUnit,
     BaseTransformer,
+    BaseTransformerUnit,
     processor_state,
 )
 
@@ -38,15 +38,12 @@ class AffineTransformState:
 
 
 class AffineTransformTransformer(
-    BaseStatefulTransformer[
-        AffineTransformSettings, AxisArray, AxisArray, AffineTransformState
-    ]
+    BaseStatefulTransformer[AffineTransformSettings, AxisArray, AxisArray, AffineTransformState]
 ):
     def __call__(self, message: AxisArray) -> AxisArray:
         # Override __call__ so we can shortcut if weights are None.
         if self.settings.weights is None or (
-            isinstance(self.settings.weights, str)
-            and self.settings.weights == "passthrough"
+            isinstance(self.settings.weights, str) and self.settings.weights == "passthrough"
         ):
             return message
         return super().__call__(message)
@@ -68,18 +65,12 @@ class AffineTransformTransformer(
         self._state.weights = weights
 
         axis = self.settings.axis or message.dims[-1]
-        if (
-            axis in message.axes
-            and hasattr(message.axes[axis], "data")
-            and weights.shape[0] != weights.shape[1]
-        ):
+        if axis in message.axes and hasattr(message.axes[axis], "data") and weights.shape[0] != weights.shape[1]:
             in_labels = message.axes[axis].data
             new_labels = []
             n_in, n_out = weights.shape
             if len(in_labels) != n_in:
-                ez.logger.warning(
-                    f"Received {len(in_labels)} for {n_in} inputs. Check upstream labels."
-                )
+                ez.logger.warning(f"Received {len(in_labels)} for {n_in} inputs. Check upstream labels.")
             else:
                 b_filled_outputs = np.any(weights, axis=0)
                 b_used_inputs = np.any(weights, axis=1)
@@ -97,9 +88,7 @@ class AffineTransformTransformer(
                 elif np.all(b_filled_outputs):
                     new_labels = np.array(in_labels)[b_used_inputs]
 
-            self._state.new_axis = replace(
-                message.axes[axis], data=np.array(new_labels)
-            )
+            self._state.new_axis = replace(message.axes[axis], data=np.array(new_labels))
 
     def _process(self, message: AxisArray) -> AxisArray:
         axis = self.settings.axis or message.dims[-1]
@@ -110,9 +99,7 @@ class AffineTransformTransformer(
             # The weights are stacked A|B where A is the transform and B is a single row
             #  in the equation y = Ax + B. This supports NeuroKey's weights matrices.
             sample_shape = data.shape[:axis_idx] + (1,) + data.shape[axis_idx + 1 :]
-            data = np.concatenate(
-                (data, np.ones(sample_shape).astype(data.dtype)), axis=axis_idx
-            )
+            data = np.concatenate((data, np.ones(sample_shape).astype(data.dtype)), axis=axis_idx)
 
         if axis_idx in [-1, len(message.dims) - 1]:
             data = np.matmul(data, self._state.weights)
@@ -128,11 +115,7 @@ class AffineTransformTransformer(
         return replace(message, **replace_kwargs)
 
 
-class AffineTransform(
-    BaseTransformerUnit[
-        AffineTransformSettings, AxisArray, AxisArray, AffineTransformTransformer
-    ]
-):
+class AffineTransform(BaseTransformerUnit[AffineTransformSettings, AxisArray, AxisArray, AffineTransformTransformer]):
     SETTINGS = AffineTransformSettings
 
 
@@ -153,9 +136,7 @@ def affine_transform(
         :obj:`AffineTransformTransformer`.
     """
     return AffineTransformTransformer(
-        AffineTransformSettings(
-            weights=weights, axis=axis, right_multiply=right_multiply
-        )
+        AffineTransformSettings(weights=weights, axis=axis, right_multiply=right_multiply)
     )
 
 
@@ -178,9 +159,7 @@ class CommonRereferenceSettings(ez.Settings):
     """Set False to exclude each channel from participating in the calculation of its reference."""
 
 
-class CommonRereferenceTransformer(
-    BaseTransformer[CommonRereferenceSettings, AxisArray, AxisArray]
-):
+class CommonRereferenceTransformer(BaseTransformer[CommonRereferenceSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
         if self.settings.mode == "passthrough":
             return message
@@ -188,9 +167,7 @@ class CommonRereferenceTransformer(
         axis = self.settings.axis or message.dims[-1]
         axis_idx = message.get_axis_idx(axis)
 
-        func = {"mean": np.mean, "median": np.median, "passthrough": zeros_for_noop}[
-            self.settings.mode
-        ]
+        func = {"mean": np.mean, "median": np.median, "passthrough": zeros_for_noop}[self.settings.mode]
 
         ref_data = func(message.data, axis=axis_idx, keepdims=True)
 
@@ -213,9 +190,7 @@ class CommonRereferenceTransformer(
 
 
 class CommonRereference(
-    BaseTransformerUnit[
-        CommonRereferenceSettings, AxisArray, AxisArray, CommonRereferenceTransformer
-    ]
+    BaseTransformerUnit[CommonRereferenceSettings, AxisArray, AxisArray, CommonRereferenceTransformer]
 ):
     SETTINGS = CommonRereferenceSettings
 

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.6.0}/src/ezmsg/sigproc/aggregate.py

@@ -1,23 +1,23 @@
-from array_api_compat import get_namespace
 import typing
 
+import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
-import ezmsg.core as ez
+from array_api_compat import get_namespace
 from ezmsg.util.messages.axisarray import (
     AxisArray,
-    slice_along_axis,
     AxisBase,
     replace,
+    slice_along_axis,
 )
 
-from .spectral import OptionsEnum
 from .base import (
-    BaseTransformer,
     BaseStatefulTransformer,
+    BaseTransformer,
     BaseTransformerUnit,
     processor_state,
 )
+from .spectral import OptionsEnum
 
 
 class AggregationFunction(OptionsEnum):
@@ -89,9 +89,7 @@ class RangedAggregateState:
 
 
 class RangedAggregateTransformer(
-    BaseStatefulTransformer[
-        RangedAggregateSettings, AxisArray, AxisArray, RangedAggregateState
-    ]
+    BaseStatefulTransformer[RangedAggregateSettings, AxisArray, AxisArray, RangedAggregateState]
 ):
     def __call__(self, message: AxisArray) -> AxisArray:
         # Override for shortcut passthrough mode.
@@ -118,16 +116,12 @@ class RangedAggregateTransformer(
         if hasattr(target_axis, "data"):
             self._state.ax_vec = target_axis.data
         else:
-            self._state.ax_vec = target_axis.value(
-                np.arange(message.data.shape[ax_idx])
-            )
+            self._state.ax_vec = target_axis.value(np.arange(message.data.shape[ax_idx]))
 
         ax_dat = []
         slices = []
         for start, stop in self.settings.bands:
-            inds = np.where(
-                np.logical_and(self._state.ax_vec >= start, self._state.ax_vec <= stop)
-            )[0]
+            inds = np.where(np.logical_and(self._state.ax_vec >= start, self._state.ax_vec <= stop))[0]
             slices.append(np.s_[inds[0] : inds[-1] + 1])
             if hasattr(target_axis, "data"):
                 if self._state.ax_vec.dtype.type is np.str_:
@@ -164,8 +158,7 @@ class RangedAggregateTransformer(
             ]
         else:
             out_data = [
-                agg_func(slice_along_axis(message.data, sl, axis=ax_idx), axis=ax_idx)
-                for sl in self._state.slices
+                agg_func(slice_along_axis(message.data, sl, axis=ax_idx), axis=ax_idx) for sl in self._state.slices
             ]
 
         msg_out = replace(
@@ -187,11 +180,7 @@ class RangedAggregateTransformer(
         return msg_out
 
 
-class RangedAggregate(
-    BaseTransformerUnit[
-        RangedAggregateSettings, AxisArray, AxisArray, RangedAggregateTransformer
-    ]
-):
+class RangedAggregate(BaseTransformerUnit[RangedAggregateSettings, AxisArray, AxisArray, RangedAggregateTransformer]):
     SETTINGS = RangedAggregateSettings
 
 
@@ -212,9 +201,7 @@ def ranged_aggregate(
     Returns:
         :obj:`RangedAggregateTransformer`
     """
-    return RangedAggregateTransformer(
-        RangedAggregateSettings(axis=axis, bands=bands, operation=operation)
-    )
+    return RangedAggregateTransformer(RangedAggregateSettings(axis=axis, bands=bands, operation=operation))
 
 
 class AggregateSettings(ez.Settings):
@@ -242,9 +229,7 @@ class AggregateTransformer(BaseTransformer[AggregateSettings, AxisArray, AxisArr
         op = self.settings.operation
 
         if op == AggregationFunction.NONE:
-            raise ValueError(
-                "AggregationFunction.NONE is not supported for full-axis aggregation"
-            )
+            raise ValueError("AggregationFunction.NONE is not supported for full-axis aggregation")
 
         if op == AggregationFunction.TRAPEZOID:
             # Trapezoid integration requires x-coordinates
@@ -276,9 +261,7 @@ class AggregateTransformer(BaseTransformer[AggregateSettings, AxisArray, AxisArr
         )
 
 
-class AggregateUnit(
-    BaseTransformerUnit[AggregateSettings, AxisArray, AxisArray, AggregateTransformer]
-):
+class AggregateUnit(BaseTransformerUnit[AggregateSettings, AxisArray, AxisArray, AggregateTransformer]):
     """Unit that aggregates an entire axis using a specified operation."""
 
     SETTINGS = AggregateSettings