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

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.7.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.7.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.7.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.7.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ezmsg-sigproc
+Version: 2.7.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
+Requires-Python: >=3.10.15
+Requires-Dist: array-api-compat>=1.11.1
+Requires-Dist: ezmsg-baseproc>=1.1.0
+Requires-Dist: ezmsg>=3.6.0
+Requires-Dist: numba>=0.61.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pywavelets>=1.6.0
+Requires-Dist: scipy>=1.13.1
+Requires-Dist: sparse>=0.15.4
+Description-Content-Type: text/markdown
+
+# ezmsg-sigproc
+
+Signal processing primitives for the [ezmsg](https://www.ezmsg.org) message-passing framework.
+
+## Features
+
+* **Filtering** - Chebyshev, comb filters, and more
+* **Spectral analysis** - Spectrogram, spectrum, and wavelet transforms
+* **Resampling** - Downsample, decimate, and resample operations
+* **Windowing** - Sliding windows and buffering utilities
+* **Math operations** - Arithmetic, log, abs, difference, and more
+* **Signal generation** - Synthetic signal generators
+
+All modules use `AxisArray` as the primary data structure for passing signals between components.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install ezmsg-sigproc
+```
+
+Or install from GitHub for the latest development version:
+
+```bash
+pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev
+```
+
+## Documentation
+
+Full documentation is available at [ezmsg.org](https://www.ezmsg.org).
+
+## Development
+
+We use [`uv`](https://docs.astral.sh/uv/) for development.
+
+1. Fork and clone the repository
+2. `uv sync` to create a virtual environment and install dependencies
+3. `uv run pre-commit install` to set up linting and formatting hooks
+4. `uv run pytest tests` to run the test suite
+5. Submit a PR against the `dev` branch

ezmsg_sigproc-2.7.0/README.md

@@ -0,0 +1,42 @@
+# ezmsg-sigproc
+
+Signal processing primitives for the [ezmsg](https://www.ezmsg.org) message-passing framework.
+
+## Features
+
+* **Filtering** - Chebyshev, comb filters, and more
+* **Spectral analysis** - Spectrogram, spectrum, and wavelet transforms
+* **Resampling** - Downsample, decimate, and resample operations
+* **Windowing** - Sliding windows and buffering utilities
+* **Math operations** - Arithmetic, log, abs, difference, and more
+* **Signal generation** - Synthetic signal generators
+
+All modules use `AxisArray` as the primary data structure for passing signals between components.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install ezmsg-sigproc
+```
+
+Or install from GitHub for the latest development version:
+
+```bash
+pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev
+```
+
+## Documentation
+
+Full documentation is available at [ezmsg.org](https://www.ezmsg.org).
+
+## Development
+
+We use [`uv`](https://docs.astral.sh/uv/) for development.
+
+1. Fork and clone the repository
+2. `uv sync` to create a virtual environment and install dependencies
+3. `uv run pre-commit install` to set up linting and formatting hooks
+4. `uv run pytest tests` to run the test suite
+5. Submit a PR against the `dev` branch

ezmsg_sigproc-2.7.0/docs/source/api/index.rst

@@ -0,0 +1,11 @@
+API Reference
+=============
+
+This page contains auto-generated API reference documentation.
+
+.. autosummary::
+   :toctree: generated
+   :recursive:
+   :template: autosummary/module.rst
+
+   ezmsg.sigproc

{ezmsg_sigproc-2.5.0 → ezmsg_sigproc-2.7.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.7.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.7.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.7.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.7.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.7.0/docs/source/guides/sigproc/architecture.rst

@@ -0,0 +1,41 @@
+Architecture & Usage Patterns
+=============================
+
+This page describes the architecture of ezmsg-sigproc and different ways to use its components.
+
+Operating Styles: Standalone vs. Pipelines
+------------------------------------------
+
+While each processor is designed to be assembled into an ezmsg pipeline, the components are also well-suited for offline, ad-hoc analysis. You can instantiate processors directly in scripts or notebooks for quick prototyping or to validate results from other code. The companion Unit wrappers, however, are meant for assembling processors into a full ezmsg pipeline.
+
+A fully defined ezmsg pipeline shines in online streaming scenarios where message routing, scheduling, and latency handling are crucial. Nevertheless, you can run the same pipeline offline—say, within a Jupyter notebook—if your analysis benefits from ezmsg's structured execution model.
+
+Deciding between a standalone processor and a full pipeline comes down to the trade-off between simplicity and the operational overhead of the pipeline:
+
+* **Standalone processors**: Low overhead, ideal for one-off or exploratory offline tasks.
+* **Pipeline + Unit wrappers**: Additional setup cost but bring concurrency, standardized interfaces, and automatic message flow—useful when your offline experiment mirrors a live system or when you require fine-grained pipeline behavior.
+
+Source Layout
+-------------
+
+All source resides under ``src/ezmsg/sigproc``, which contains:
+
+* A suite of processors (for example, ``filter.py``, ``spectrogram.py``, ``spectrum.py``, ``sampler.py``)
+* ``math/`` and ``util/`` subpackages for mathematical operations and utilities
+
+Key Modules
+^^^^^^^^^^^
+
+* **base.py** (via ``ezmsg.baseproc``): Defines standard protocols—Processor, Producer, Consumer, and Transformer—that enable both stateless and stateful processing chains.
+* **filter.py**: Provides settings dataclasses and a stateful transformer that applies supplied coefficients to incoming data.
+* **spectrogram.py**: Implements spectral analysis using a composite transformer chaining windowing, spectrum computation, and axis adjustments.
+
+Where to Learn Next
+-------------------
+
+* Study the :doc:`base` page to master the processor architecture.
+* Explore unit tests in the repository for hands-on examples of composing processors and Units.
+* Review the `ezmsg framework <https://www.ezmsg.org>`_ to understand the surrounding ecosystem.
+* Experiment with the code—try running processors standalone and then integrate them into a small pipeline to observe the trade-offs firsthand.
+
+This approach equips newcomers to choose the right level of abstraction—raw processor, Unit wrapper, or full pipeline—based on the demands of their analysis or streaming application.

ezmsg_sigproc-2.7.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.7.0}/docs/source/guides/sigproc/content-sigproc.rst

@@ -17,6 +17,7 @@ This may occur when the generator receives inadequate data to produce a valid ou
 .. toctree::
     :maxdepth: 1
 
+    architecture
     base
     units
     processors

ezmsg_sigproc-2.7.0/docs/source/index.md

@@ -0,0 +1,20 @@
+```{include} ../../README.md
+```
+
+## Documentation
+
+```{toctree}
+:maxdepth: 2
+:caption: Contents:
+
+guides/sigproc/content-sigproc
+guides/HybridBuffer
+guides/how-tos/signalprocessing/content-signalprocessing
+guides/tutorials/signalprocessing
+api/index
+```
+
+## Indices and tables
+
+- {ref}`genindex`
+- {ref}`modindex`

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

@@ -13,6 +13,7 @@ requires-python = ">=3.10.15"
 dynamic = ["version"]
 dependencies = [
   "array-api-compat>=1.11.1",
+  "ezmsg-baseproc>=1.1.0",
   "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.7.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.7.0'
+__version_tuple__ = version_tuple = (2, 7, 0)
 
 __commit_id__ = commit_id = None

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

@@ -1,10 +1,10 @@
-import scipy.special
 import ezmsg.core as ez
+import scipy.special
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
 from .spectral import OptionsEnum
-from .base import BaseTransformer, BaseTransformerUnit
 
 
 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.7.0}/src/ezmsg/sigproc/adaptive_lattice_notch.py

@@ -1,12 +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.baseproc import BaseStatefulTransformer, processor_state
 from ezmsg.util.messages.axisarray import AxisArray, CoordinateAxis
 from ezmsg.util.messages.util import replace
 
-from .base import processor_state, BaseStatefulTransformer
-
 
 class AdaptiveLatticeNotchFilterSettings(ez.Settings):
     """Settings for the Adaptive Lattice Notch Filter."""
@@ -76,9 +75,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 +88,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 +142,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 +152,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 +186,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.7.0}/src/ezmsg/sigproc/affinetransform.py

@@ -1,18 +1,17 @@
 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 (
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
-    BaseTransformerUnit,
     BaseTransformer,
+    BaseTransformerUnit,
     processor_state,
 )
+from ezmsg.util.messages.axisarray import AxisArray, AxisBase
+from ezmsg.util.messages.util import replace
 
 
 class AffineTransformSettings(ez.Settings):
@@ -38,15 +37,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 +64,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 +87,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 +98,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 +114,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 +135,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 +158,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 +166,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 +189,7 @@ class CommonRereferenceTransformer(
 
 
 class CommonRereference(
-    BaseTransformerUnit[
-        CommonRereferenceSettings, AxisArray, AxisArray, CommonRereferenceTransformer
-    ]
+    BaseTransformerUnit[CommonRereferenceSettings, AxisArray, AxisArray, CommonRereferenceTransformer]
 ):
     SETTINGS = CommonRereferenceSettings