ezmsg-sigproc 2.1.0__tar.gz → 2.2.0__tar.gz

{ezmsg_sigproc-2.1.0 → ezmsg_sigproc-2.2.0}/.github/workflows/python-publish-ezmsg-sigproc.yml

@@ -17,8 +17,8 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install uv
-        uses: astral-sh/setup-uv@v2
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6
 
       - name: Build Package
         run: uv build

{ezmsg_sigproc-2.1.0 → ezmsg_sigproc-2.2.0}/.github/workflows/python-tests.yml

@@ -13,7 +13,7 @@ jobs:
   build:
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.10.15", "3.11", "3.12", "3.13"]
         os:
           - "ubuntu-latest"
           - "windows-latest"
@@ -23,17 +23,11 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install uv
-        uses: astral-sh/setup-uv@v2
-        with:
-          enable-cache: true
-          cache-dependency-glob: "uv.lock"
-
-      - name: Set up Python ${{ matrix.python-version }}
-        run: uv python install ${{ matrix.python-version }}
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6
 
       - name: Install the project
-        run: uv sync --all-extras --dev
+        run: uv sync --python ${{ matrix.python-version }}
 
       - name: Lint
         run:

{ezmsg_sigproc-2.1.0 → ezmsg_sigproc-2.2.0}/.gitignore

@@ -142,4 +142,5 @@ cython_debug/
 # JetBrains
 .idea/
 
-src/ezmsg/sigproc/__version__.py
+src/ezmsg/sigproc/__version__.py
+uv.lock

ezmsg_sigproc-2.2.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: ezmsg-sigproc
+Version: 2.2.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>
+License-Expression: MIT
+License-File: LICENSE.txt
+Requires-Python: >=3.10.15
+Requires-Dist: array-api-compat>=1.11.1
+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
+
+## Overview
+
+ezmsg-sigproc offers timeseries signal‑processing primitives built atop the ezmsg message‑passing framework. Core dependencies include ezmsg, numpy, scipy, pywavelets, and sparse; the project itself is managed through hatchling and uses VCS hooks to populate __version__.py.
+
+## Installation
+
+Install the latest release from pypi with: `pip install ezmsg-sigproc` (or `uv add ...` or `poetry add ...`).
+
+You can install pre-release versions directly from GitHub:
+
+* Using `pip`: `pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev`
+* Using `uv`: `uv add git+https://github.com/ezmsg-org/ezmsg-sigproc --branch dev`
+* Using `poetry`: `poetry add "git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev"`
+
+> See the [Development](#development) section below for installing with the intention of developing.
+
+## Source layout & key modules
+* All source resides under src/ezmsg/sigproc, which contains a suite of processors (for example, filter.py, spectrogram.py, spectrum.py, sampler.py) and math and util subpackages.
+* The framework’s backbone is base.py, defining standard protocols—Processor, Producer, Consumer, and Transformer—that enable both stateless and stateful processing chains.
+* Filtering is implemented in filter.py, providing settings dataclasses and a stateful transformer that applies supplied coefficients to incoming data.
+* Spectral analysis uses a composite spectrogram transformer chaining windowing, spectrum computation, and axis adjustments.
+
+## Operating styles: Standalone processors vs. ezmsg 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.
+
+## Documentation & tests
+* `docs/ProcessorsBase.md` details the processor hierarchy and generic type patterns, providing a solid foundation for custom components.
+* Unit tests (e.g., `tests/unit/test_sampler.py`) offer concrete examples of usage, showcasing sampler generation, windowing, and message handling.
+
+## Where to learn next
+* Study docs/ProcessorsBase.md to master the processor architecture.
+* Explore unit tests for hands‑on examples of composing processors and Units.
+* Review the ezmsg framework in pyproject.toml 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.
+
+## Development
+
+We use [`uv`](https://docs.astral.sh/uv/getting-started/installation/) for development. It is not strictly required, but if you intend to contribute to ezmsg-sigproc then using `uv` will lead to the smoothest collaboration.
+
+1. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if not already installed.
+2. Fork ezmsg-sigproc and clone your fork to your local computer.
+3. Open a terminal and `cd` to the cloned folder.
+4. `uv sync` to create a .venv and install dependencies.
+5. `uv run pre-commit install` to install pre-commit hooks to do linting and formatting.
+6. Run the test suite before finalizing your edits: `uv run pytest tests`
+7. Make a PR against the `dev` branch of the main repo.

ezmsg_sigproc-2.2.0/README.md

@@ -0,0 +1,55 @@
+# ezmsg.sigproc
+
+## Overview
+
+ezmsg-sigproc offers timeseries signal‑processing primitives built atop the ezmsg message‑passing framework. Core dependencies include ezmsg, numpy, scipy, pywavelets, and sparse; the project itself is managed through hatchling and uses VCS hooks to populate __version__.py.
+
+## Installation
+
+Install the latest release from pypi with: `pip install ezmsg-sigproc` (or `uv add ...` or `poetry add ...`).
+
+You can install pre-release versions directly from GitHub:
+
+* Using `pip`: `pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev`
+* Using `uv`: `uv add git+https://github.com/ezmsg-org/ezmsg-sigproc --branch dev`
+* Using `poetry`: `poetry add "git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev"`
+
+> See the [Development](#development) section below for installing with the intention of developing.
+
+## Source layout & key modules
+* All source resides under src/ezmsg/sigproc, which contains a suite of processors (for example, filter.py, spectrogram.py, spectrum.py, sampler.py) and math and util subpackages.
+* The framework’s backbone is base.py, defining standard protocols—Processor, Producer, Consumer, and Transformer—that enable both stateless and stateful processing chains.
+* Filtering is implemented in filter.py, providing settings dataclasses and a stateful transformer that applies supplied coefficients to incoming data.
+* Spectral analysis uses a composite spectrogram transformer chaining windowing, spectrum computation, and axis adjustments.
+
+## Operating styles: Standalone processors vs. ezmsg 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.
+
+## Documentation & tests
+* `docs/ProcessorsBase.md` details the processor hierarchy and generic type patterns, providing a solid foundation for custom components.
+* Unit tests (e.g., `tests/unit/test_sampler.py`) offer concrete examples of usage, showcasing sampler generation, windowing, and message handling.
+
+## Where to learn next
+* Study docs/ProcessorsBase.md to master the processor architecture.
+* Explore unit tests for hands‑on examples of composing processors and Units.
+* Review the ezmsg framework in pyproject.toml 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.
+
+## Development
+
+We use [`uv`](https://docs.astral.sh/uv/getting-started/installation/) for development. It is not strictly required, but if you intend to contribute to ezmsg-sigproc then using `uv` will lead to the smoothest collaboration.
+
+1. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if not already installed.
+2. Fork ezmsg-sigproc and clone your fork to your local computer.
+3. Open a terminal and `cd` to the cloned folder.
+4. `uv sync` to create a .venv and install dependencies.
+5. `uv run pre-commit install` to install pre-commit hooks to do linting and formatting.
+6. Run the test suite before finalizing your edits: `uv run pytest tests`
+7. Make a PR against the `dev` branch of the main repo.

{ezmsg_sigproc-2.1.0 → ezmsg_sigproc-2.2.0}/pyproject.toml

@@ -20,9 +20,18 @@ dependencies = [
   "sparse>=0.15.4",
 ]
 
-[project.optional-dependencies]
+[dependency-groups]
+dev = [
+  "typer>=0.12.5",
+  "pre-commit>=4.2.0",
+  "jupyter>=1.1.1",
+  {include-group = "lint"},
+  {include-group = "test"},
+]
+lint = [
+  "ruff"
+]
 test = [
-  "flake8>=7.1.1",
   "frozendict>=2.4.4",
   "pytest-asyncio>=0.24.0",
   "pytest-cov>=5.0.0",
@@ -42,9 +51,6 @@ version-file = "src/ezmsg/sigproc/__version__.py"
 [tool.hatch.build.targets.wheel]
 packages = ["src/ezmsg"]
 
-[tool.uv]
-dev-dependencies = ["pre-commit>=3.8.0", "ruff>=0.6.7"]
-
 [tool.pytest.ini_options]
 norecursedirs = "tests/helpers"
 addopts = "-p no:warnings"

{ezmsg_sigproc-2.1.0 → ezmsg_sigproc-2.2.0}/src/ezmsg/sigproc/__version__.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.2.0'
+__version_tuple__ = version_tuple = (2, 2, 0)

{ezmsg_sigproc-2.1.0 → ezmsg_sigproc-2.2.0}/src/ezmsg/sigproc/filter.py

@@ -32,17 +32,19 @@ FilterCoefsType = typing.TypeVar("FilterCoefsType", BACoeffs, SOSCoeffs)
 
 
 def _normalize_coefs(
-    coefs: FilterCoefficients | tuple[npt.NDArray, npt.NDArray] | npt.NDArray,
-) -> tuple[str, tuple[npt.NDArray, ...]]:
+    coefs: FilterCoefficients | tuple[npt.NDArray, npt.NDArray] | npt.NDArray | None,
+) -> tuple[str, tuple[npt.NDArray, ...] | None]:
     coef_type = "ba"
     if coefs is not None:
         # scipy.signal functions called with first arg `*coefs`.
         # Make sure we have a tuple of coefficients.
-        if isinstance(coefs, npt.NDArray):
+        if isinstance(coefs, np.ndarray):
             coef_type = "sos"
             coefs = (coefs,)  # sos funcs just want a single ndarray.
         elif isinstance(coefs, FilterCoefficients):
-            coefs = (FilterCoefficients.b, FilterCoefficients.a)
+            coefs = (coefs.b, coefs.a)
+        elif not isinstance(coefs, tuple):
+            coefs = (coefs,)
     return coef_type, coefs
 
 
@@ -91,16 +93,20 @@ class FilterTransformer(
         axis = message.dims[0] if self.settings.axis is None else self.settings.axis
         axis_idx = message.get_axis_idx(axis)
         n_tail = message.data.ndim - axis_idx - 1
-        coefs = (
-            (self.settings.coefs,)
-            if self.settings.coefs is not None
-            and not isinstance(self.settings.coefs, tuple)
-            else self.settings.coefs
-        )
-        zi_func = {"ba": scipy.signal.lfilter_zi, "sos": scipy.signal.sosfilt_zi}[
-            self.settings.coef_type
-        ]
-        zi = zi_func(*coefs)
+        _, coefs = _normalize_coefs(self.settings.coefs)
+
+        if self.settings.coef_type == "ba":
+            b, a = coefs
+            if len(a) == 1 or np.allclose(a[1:], 0):
+                # For FIR filters, use lfiltic with zero initial conditions
+                zi = scipy.signal.lfiltic(b, a, [])
+            else:
+                # For IIR filters...
+                zi = scipy.signal.lfilter_zi(b, a)
+        else:
+            # For second-order sections (SOS) filters, use sosfilt_zi
+            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 :]
@@ -166,12 +172,7 @@ class FilterTransformer(
         if message.data.size > 0:
             axis = message.dims[0] if self.settings.axis is None else self.settings.axis
             axis_idx = message.get_axis_idx(axis)
-            coefs = (
-                (self.settings.coefs,)
-                if self.settings.coefs is not None
-                and not isinstance(self.settings.coefs, tuple)
-                else self.settings.coefs
-            )
+            _, coefs = _normalize_coefs(self.settings.coefs)
             filt_func = {"ba": scipy.signal.lfilter, "sos": scipy.signal.sosfilt}[
                 self.settings.coef_type
             ]

ezmsg_sigproc-2.2.0/src/ezmsg/sigproc/gaussiansmoothing.py

@@ -0,0 +1,93 @@
+from typing import Callable
+import warnings
+
+import numpy as np
+
+from .filter import (
+    FilterBaseSettings,
+    BACoeffs,
+    FilterByDesignTransformer,
+    BaseFilterByDesignTransformerUnit,
+)
+
+
+class GaussianSmoothingSettings(FilterBaseSettings):
+    sigma: float | None = 1.0
+    """
+    sigma : float
+        Standard deviation of the Gaussian kernel.
+    """
+
+    width: int | None = 4
+    """
+    width : int
+        Number of standard deviations covered by the kernel window if kernel_size is not provided.
+    """
+
+    kernel_size: int | None = None
+    """
+    kernel_size : int | None
+        Length of the kernel in samples. If provided, overrides automatic calculation.
+    """
+
+
+def gaussian_smoothing_filter_design(
+    sigma: float = 1.0,
+    width: int = 4,
+    kernel_size: int | None = None,
+) -> BACoeffs | None:
+    # Parameter checks
+    if sigma <= 0:
+        raise ValueError(f"sigma must be positive. Received: {sigma}")
+
+    if width <= 0:
+        raise ValueError(f"width must be positive. Received: {width}")
+
+    if kernel_size is not None:
+        if kernel_size < 1:
+            raise ValueError(f"kernel_size must be >= 1. Received: {kernel_size}")
+    else:
+        kernel_size = int(2 * width * sigma + 1)
+
+    # Warn if kernel_size is smaller than recommended but don't fail
+    expected_kernel_size = int(2 * width * sigma + 1)
+    if kernel_size < expected_kernel_size:
+        ## TODO: Either add a warning or determine appropriate kernel size and raise an error
+        warnings.warn(
+            f"Provided kernel_size {kernel_size} is smaller than recommended "
+            f"size {expected_kernel_size} for sigma={sigma} and width={width}. "
+            "The kernel may be truncated."
+        )
+
+    from scipy.signal.windows import gaussian
+
+    b = gaussian(kernel_size, std=sigma)
+    b /= np.sum(b)  # Ensure normalization
+    a = np.array([1.0])
+
+    return b, a
+
+
+class GaussianSmoothingFilterTransformer(
+    FilterByDesignTransformer[GaussianSmoothingSettings, BACoeffs]
+):
+    def get_design_function(
+        self,
+    ) -> Callable[[float], BACoeffs]:
+        # Create a wrapper function that ignores fs parameter since gaussian smoothing doesn't need it
+        def design_wrapper(fs: float) -> BACoeffs:
+            return gaussian_smoothing_filter_design(
+                sigma=self.settings.sigma,
+                width=self.settings.width,
+                kernel_size=self.settings.kernel_size,
+            )
+
+        return design_wrapper
+
+
+class GaussianSmoothingFilter(
+    BaseFilterByDesignTransformerUnit[
+        GaussianSmoothingSettings, GaussianSmoothingFilterTransformer
+    ]
+):
+    SETTINGS = GaussianSmoothingSettings

ezmsg_sigproc-2.2.0/src/ezmsg/sigproc/util/sparse.py

@@ -0,0 +1,123 @@
+import numpy as np
+import sparse
+
+
+def sliding_win_oneaxis_old(
+    s: sparse.SparseArray, nwin: int, axis: int, step: int = 1
+) -> sparse.SparseArray:
+    """
+    Like `ezmsg.util.messages.axisarray.sliding_win_oneaxis` but for sparse arrays.
+    This approach is about 4x slower than the version that uses coordinate arithmetic below.
+
+    Args:
+        s: The input sparse array.
+        nwin: The size of the sliding window.
+        axis: The axis along which the sliding window will be applied.
+        step: The size of the step between windows. If > 1, the strided window will be sliced with `slice_along_axis`.
+
+    Returns:
+
+    """
+    if -s.ndim <= axis < 0:
+        axis = s.ndim + axis
+    targ_slices = [slice(_, _ + nwin) for _ in range(0, s.shape[axis] - nwin + 1, step)]
+    s = s.reshape(s.shape[:axis] + (1,) + s.shape[axis:])
+    full_slices = (slice(None),) * s.ndim
+    full_slices = [
+        full_slices[: axis + 1] + (sl,) + full_slices[axis + 2 :] for sl in targ_slices
+    ]
+    result = sparse.concatenate([s[_] for _ in full_slices], axis=axis)
+    return result
+
+
+def sliding_win_oneaxis(
+    s: sparse.SparseArray, nwin: int, axis: int, step: int = 1
+) -> sparse.SparseArray:
+    """
+    Generates a view-like sparse array using a sliding window of specified length along a specified axis.
+    Sparse analog of an optimized dense as_strided-based implementation with these properties:
+
+    - Accepts a single `nwin` and a single `axis`.
+    - Inserts a new 'win' axis immediately BEFORE the original target axis.
+      Output shape:
+        s.shape[:axis] + (W,) + (nwin,) + s.shape[axis+1:]
+      where W = s.shape[axis] - (nwin - 1).
+    - If `step > 1`, stepping is applied by slicing along the new windows axis (same observable behavior
+      as doing `slice_along_axis(result, slice(None, None, step), axis)` in the dense version).
+
+    Args:
+        s: Input sparse array (pydata/sparse COO-compatible).
+        nwin: Sliding window size (must be > 0).
+        axis: Axis of `s` along which the window slides (supports negative indexing).
+        step: Stride between windows. If > 1, applied by slicing the windows axis after construction.
+
+    Returns:
+        A sparse array with a new windows axis inserted before the original axis.
+
+    Notes:
+        - Mirrors the dense function’s known edge case: when nwin == shape[axis] + 1, W becomes 0 and
+          an empty windows axis is returned.
+        - Built by coordinate arithmetic; no per-window indexing or concatenation.
+    """
+    if -s.ndim <= axis < 0:
+        axis = s.ndim + axis
+    if not (0 <= axis < s.ndim):
+        raise ValueError(f"Invalid axis {axis} for array with {s.ndim} dimensions")
+    if nwin <= 0:
+        raise ValueError("nwin must be > 0")
+    dim = s.shape[axis]
+
+    last_win_start = dim - nwin
+    win_starts = list(range(0, last_win_start + 1, step))
+    n_win_out = len(win_starts)
+    if n_win_out <= 0:
+        # Return array with proper shape except empty along windows axis
+        return sparse.zeros(
+            s.shape[:axis] + (0,) + (nwin,) + s.shape[axis + 1 :], dtype=s.dtype
+        )
+
+    coo = s.asformat("coo")
+    coords = coo.coords  # shape: (ndim, nnz)
+    data = coo.data  # shape: (nnz,)
+    ia = coords[axis]  # indices along sliding axis, shape: (nnz,)
+
+    # We emit contributions for each offset o in [0, nwin-1].
+    # For a nonzero at index i, it contributes to window start w = i - o when 0 <= w < W.
+    out_coords_blocks = []
+    out_data_blocks = []
+
+    # Small speed/memory tweak: reuse dtypes and pre-allocate o-array once per loop.
+    idx_dtype = coords.dtype
+
+    for win_ix, win_start in enumerate(win_starts):
+        w = ia - win_start
+        # Valid window starts are those within [0, nwin]
+        mask = (w >= 0) & (w < nwin)
+        if not mask.any():
+            continue
+
+        sel = np.nonzero(mask)[0]
+        w_sel = w[sel]
+
+        # Build new coords with windows axis inserted at `axis` and the original axis
+        # becoming the next axis with fixed offset value `o`.
+        # Output ndim = s.ndim + 1
+        before = coords[:axis, sel]  # unchanged
+        after_other = coords[axis + 1 :, sel]  # dims after original axis
+        win_idx_row = np.full((1, sel.size), win_ix, dtype=idx_dtype)
+
+        new_coords = np.vstack([before, win_idx_row, w_sel[None, :], after_other])
+
+        out_coords_blocks.append(new_coords)
+        out_data_blocks.append(data[sel])
+
+    if not out_coords_blocks:
+        return sparse.zeros(
+            s.shape[:axis] + (n_win_out,) + (nwin,) + s.shape[axis + 1 :], dtype=s.dtype
+        )
+
+    out_coords = np.hstack(out_coords_blocks)
+    out_data = np.hstack(out_data_blocks)
+    out_shape = s.shape[:axis] + (n_win_out,) + (nwin,) + s.shape[axis + 1 :]
+
+    return sparse.COO(out_coords, out_data, shape=out_shape)

ezmsg_sigproc-2.2.0/tests/unit/test_filter.py

@@ -0,0 +1,17 @@
+import numpy as np
+from ezmsg.sigproc.filter import FilterTransformer, FilterSettings, FilterCoefficients
+from ezmsg.util.messages.axisarray import AxisArray
+
+
+def test_filter_transformer_accepts_dataclass_coefficients():
+    data = np.arange(10.0)
+    msg = AxisArray(
+        data=data,
+        dims=["time"],
+        axes={"time": AxisArray.TimeAxis(fs=1.0, offset=0.0)},
+        key="test",
+    )
+    coefs = FilterCoefficients(b=np.array([1.0]), a=np.array([1.0, 0.0]))
+    transformer = FilterTransformer(settings=FilterSettings(axis="time", coefs=coefs))
+    out = transformer(msg)
+    assert np.allclose(out.data, data)