ezmsg-sigproc 2.10.0__tar.gz → 2.11.0__tar.gz

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 2.10.0
+Version: 2.11.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

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.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.10.0'
-__version_tuple__ = version_tuple = (2, 10, 0)
+__version__ = version = '2.11.0'
+__version_tuple__ = version_tuple = (2, 11, 0)
 
 __commit_id__ = commit_id = None

ezmsg_sigproc-2.11.0/src/ezmsg/sigproc/math/pow.py

@@ -0,0 +1,43 @@
+"""
+Element-wise power of the data.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
+
+import ezmsg.core as ez
+from array_api_compat import get_namespace
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
+
+class PowSettings(ez.Settings):
+    exponent: float = 2.0
+    """The exponent to raise the data to. Default is 2.0 (squaring)."""
+
+
+class PowTransformer(BaseTransformer[PowSettings, AxisArray, AxisArray]):
+    def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
+        return replace(message, data=xp.pow(message.data, self.settings.exponent))
+
+
+class Pow(BaseTransformerUnit[PowSettings, AxisArray, AxisArray, PowTransformer]):
+    SETTINGS = PowSettings
+
+
+def pow(
+    exponent: float = 2.0,
+) -> PowTransformer:
+    """
+    Raise the data to an element-wise power. See :obj:`xp.pow` for more details.
+
+    Args:
+        exponent: The exponent to raise the data to. Default is 2.0.
+
+    Returns: :obj:`PowTransformer`.
+
+    """
+    return PowTransformer(PowSettings(exponent=exponent))

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.0}/src/ezmsg/sigproc/scaler.py

@@ -7,7 +7,6 @@ from ezmsg.baseproc import (
     BaseTransformerUnit,
     processor_state,
 )
-from ezmsg.util.generator import consumer
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -18,50 +17,69 @@ from .ewma import _tau_from_alpha as _tau_from_alpha
 from .ewma import ewma_step as ewma_step
 
 
-@consumer
-def scaler(time_constant: float = 1.0, axis: str | None = None) -> typing.Generator[AxisArray, AxisArray, None]:
-    """
-    Apply the adaptive standard scaler from https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/
-    This is faster than :obj:`scaler_np` for single-channel data.
+class RiverAdaptiveStandardScalerSettings(ez.Settings):
+    time_constant: float = 1.0
+    """Decay constant ``tau`` in seconds."""
+
+    axis: str | None = None
+    """The name of the axis to accumulate statistics over."""
+
+
+@processor_state
+class RiverAdaptiveStandardScalerState:
+    scaler: typing.Any = None
+    axis: str | None = None
+    axis_idx: int = 0
 
-    Args:
-        time_constant: Decay constant `tau` in seconds.
-        axis: The name of the axis to accumulate statistics over.
 
-    Returns:
-        A primed generator object that expects to be sent a :obj:`AxisArray` via `.send(axis_array)`
-         and yields an :obj:`AxisArray` with its data being a standardized, or "Z-scored" version of the input data.
+class RiverAdaptiveStandardScalerTransformer(
+    BaseStatefulTransformer[
+        RiverAdaptiveStandardScalerSettings,
+        AxisArray,
+        AxisArray,
+        RiverAdaptiveStandardScalerState,
+    ]
+):
+    """
+    Apply the adaptive standard scaler from
+    `river <https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/>`_.
+
+    This processes data sample-by-sample using River's online learning
+    implementation. For a vectorized EWMA-based alternative, see
+    :class:`AdaptiveStandardScalerTransformer`.
     """
-    from river import preprocessing
 
-    msg_out = AxisArray(np.array([]), dims=[""])
-    _scaler = None
-    while True:
-        msg_in: AxisArray = yield msg_out
-        data = msg_in.data
+    def _reset_state(self, message: AxisArray) -> None:
+        from river import preprocessing
+
+        axis = self.settings.axis
         if axis is None:
-            axis = msg_in.dims[0]
-            axis_idx = 0
+            axis = message.dims[0]
+            self._state.axis_idx = 0
         else:
-            axis_idx = msg_in.get_axis_idx(axis)
-            if axis_idx != 0:
-                data = np.moveaxis(data, axis_idx, 0)
+            self._state.axis_idx = message.get_axis_idx(axis)
+        self._state.axis = axis
+
+        alpha = _alpha_from_tau(self.settings.time_constant, message.axes[axis].gain)
+        self._state.scaler = preprocessing.AdaptiveStandardScaler(fading_factor=alpha)
 
-        if _scaler is None:
-            alpha = _alpha_from_tau(time_constant, msg_in.axes[axis].gain)
-            _scaler = preprocessing.AdaptiveStandardScaler(fading_factor=alpha)
+    def _process(self, message: AxisArray) -> AxisArray:
+        data = message.data
+        axis_idx = self._state.axis_idx
+        if axis_idx != 0:
+            data = np.moveaxis(data, axis_idx, 0)
 
         result = []
         for sample in data:
             x = {k: v for k, v in enumerate(sample.flatten().tolist())}
-            _scaler.learn_one(x)
-            y = _scaler.transform_one(x)
+            self._state.scaler.learn_one(x)
+            y = self._state.scaler.transform_one(x)
             k = sorted(y.keys())
             result.append(np.array([y[_] for _ in k]).reshape(sample.shape))
 
         result = np.stack(result)
         result = np.moveaxis(result, 0, axis_idx)
-        msg_out = replace(msg_in, data=result)
+        return replace(message, data=result)
 
 
 class AdaptiveStandardScalerSettings(EWMASettings): ...
@@ -158,7 +176,14 @@ class AdaptiveStandardScaler(
             self.processor.settings = msg
 
 
-# Backwards compatibility...
+# Convenience functions to support deprecated generator API
+def scaler(time_constant: float = 1.0, axis: str | None = None) -> RiverAdaptiveStandardScalerTransformer:
+    """Create a :class:`RiverAdaptiveStandardScalerTransformer` with the given parameters."""
+    return RiverAdaptiveStandardScalerTransformer(
+        settings=RiverAdaptiveStandardScalerSettings(time_constant=time_constant, axis=axis)
+    )
+
+
 def scaler_np(time_constant: float = 1.0, axis: str | None = None) -> AdaptiveStandardScalerTransformer:
     return AdaptiveStandardScalerTransformer(
         settings=AdaptiveStandardScalerSettings(time_constant=time_constant, axis=axis)

ezmsg_sigproc-2.11.0/src/ezmsg/sigproc/singlebandpow.py

@@ -0,0 +1,116 @@
+"""
+Time-domain single-band power estimation.
+
+Two methods are provided:
+
+1. **RMS Band Power** — Bandpass filter, square, window into bins, take the mean, optionally take the square root.
+2. **Square-Law + LPF Band Power** — Bandpass filter, square, lowpass filter (smoothing), downsample.
+"""
+
+from dataclasses import field
+
+import ezmsg.core as ez
+from ezmsg.baseproc import (
+    BaseProcessor,
+    BaseStatefulProcessor,
+    BaseTransformerUnit,
+    CompositeProcessor,
+)
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.modify import modify_axis
+
+from .aggregate import AggregateSettings, AggregateTransformer, AggregationFunction
+from .butterworthfilter import ButterworthFilterSettings, ButterworthFilterTransformer
+from .downsample import DownsampleSettings, DownsampleTransformer
+from .math.pow import PowSettings, PowTransformer
+from .window import WindowTransformer
+
+
+class RMSBandPowerSettings(ez.Settings):
+    """Settings for :obj:`RMSBandPowerTransformer`."""
+
+    bandpass: ButterworthFilterSettings = field(
+        default_factory=lambda: ButterworthFilterSettings(order=4, coef_type="sos")
+    )
+    """Butterworth bandpass filter settings. Set ``cuton`` and ``cutoff`` to define the band."""
+
+    bin_duration: float = 0.05
+    """Duration of each non-overlapping bin in seconds."""
+
+    apply_sqrt: bool = True
+    """If True, output is RMS (root-mean-square). If False, output is mean-square power."""
+
+
+class RMSBandPowerTransformer(CompositeProcessor[RMSBandPowerSettings, AxisArray, AxisArray]):
+    """
+    RMS band power estimation.
+
+    Pipeline: bandpass -> square -> window(bins) -> mean(time) -> rename bin->time -> [sqrt]
+    """
+
+    @staticmethod
+    def _initialize_processors(
+        settings: RMSBandPowerSettings,
+    ) -> dict[str, BaseProcessor | BaseStatefulProcessor]:
+        procs: dict[str, BaseProcessor | BaseStatefulProcessor] = {
+            "bandpass": ButterworthFilterTransformer(settings.bandpass),
+            "square": PowTransformer(PowSettings(exponent=2.0)),
+            "window": WindowTransformer(
+                axis="time",
+                newaxis="bin",
+                window_dur=settings.bin_duration,
+                window_shift=settings.bin_duration,
+                zero_pad_until="none",
+            ),
+            "aggregate": AggregateTransformer(AggregateSettings(axis="time", operation=AggregationFunction.MEAN)),
+            "rename": modify_axis(name_map={"bin": "time"}),
+        }
+        if settings.apply_sqrt:
+            procs["sqrt"] = PowTransformer(PowSettings(exponent=0.5))
+        return procs
+
+
+class RMSBandPower(BaseTransformerUnit[RMSBandPowerSettings, AxisArray, AxisArray, RMSBandPowerTransformer]):
+    SETTINGS = RMSBandPowerSettings
+
+
+class SquareLawBandPowerSettings(ez.Settings):
+    """Settings for :obj:`SquareLawBandPowerTransformer`."""
+
+    bandpass: ButterworthFilterSettings = field(
+        default_factory=lambda: ButterworthFilterSettings(order=4, coef_type="sos")
+    )
+    """Butterworth bandpass filter settings. Set ``cuton`` and ``cutoff`` to define the band."""
+
+    lowpass: ButterworthFilterSettings = field(
+        default_factory=lambda: ButterworthFilterSettings(order=4, coef_type="sos")
+    )
+    """Butterworth lowpass filter settings for smoothing the squared signal."""
+
+    downsample: DownsampleSettings = field(default_factory=DownsampleSettings)
+    """Downsample settings for rate reduction after lowpass smoothing."""
+
+
+class SquareLawBandPowerTransformer(CompositeProcessor[SquareLawBandPowerSettings, AxisArray, AxisArray]):
+    """
+    Square-law + LPF band power estimation.
+
+    Pipeline: bandpass -> square -> lowpass -> downsample
+    """
+
+    @staticmethod
+    def _initialize_processors(
+        settings: SquareLawBandPowerSettings,
+    ) -> dict[str, BaseProcessor | BaseStatefulProcessor]:
+        return {
+            "bandpass": ButterworthFilterTransformer(settings.bandpass),
+            "square": PowTransformer(PowSettings(exponent=2.0)),
+            "lowpass": ButterworthFilterTransformer(settings.lowpass),
+            "downsample": DownsampleTransformer(settings.downsample),
+        }
+
+
+class SquareLawBandPower(
+    BaseTransformerUnit[SquareLawBandPowerSettings, AxisArray, AxisArray, SquareLawBandPowerTransformer]
+):
+    SETTINGS = SquareLawBandPowerSettings

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.0}/tests/integration/ezmsg/test_scaler_system.py

@@ -8,7 +8,11 @@ from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.terminate import TerminateOnTotal, TerminateOnTotalSettings
 from frozendict import frozendict
 
-from ezmsg.sigproc.scaler import AdaptiveStandardScaler, AdaptiveStandardScalerSettings, scaler_np
+from ezmsg.sigproc.scaler import (
+    AdaptiveStandardScaler,
+    AdaptiveStandardScalerSettings,
+    AdaptiveStandardScalerTransformer,
+)
 from tests.helpers.synth import Counter, CounterSettings
 from tests.helpers.util import get_test_fn
 
@@ -20,10 +24,10 @@ def test_scaler_system(
     test_name: str | None = None,
 ):
     """
-    For this test, we assume that Counter and scaler_np are functioning properly.
-    The purpose of this test is exclusively to test that the AdaptiveStandardScaler and AdaptiveStandardScalerSettings
-    generated classes are wrapping scaler_np and exposing its parameters.
-    This test passing should only be considered a success if test_scaler_np also passed.
+    For this test, we assume that Counter and AdaptiveStandardScalerTransformer are functioning properly.
+    The purpose of this test is exclusively to test that the AdaptiveStandardScaler Unit
+    correctly wraps AdaptiveStandardScalerTransformer and exposes its parameters.
+    This test passing should only be considered a success if test_scaler also passed.
     """
     block_size: int = 4
     test_filename = get_test_fn(test_name)
@@ -68,6 +72,6 @@ def test_scaler_system(
         dims=["ch", "time"],
         axes=frozendict({"time": AxisArray.TimeAxis(fs=fs)}),
     )
-    _scaler = scaler_np(time_constant=tau, axis="time")
+    _scaler = AdaptiveStandardScalerTransformer(settings=AdaptiveStandardScalerSettings(time_constant=tau, axis="time"))
     expected_output = _scaler.send(expected_input)
     assert np.allclose(expected_output.data.squeeze(), data)

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.0}/tests/unit/test_base.py

@@ -1,7 +1,7 @@
 import dataclasses
 import pickle
 from types import NoneType
-from typing import Any, Generator
+from typing import Any
 from unittest.mock import MagicMock
 
 import pytest
@@ -26,7 +26,6 @@ from ezmsg.baseproc import (
     _get_processor_message_type,
     processor_state,
 )
-from ezmsg.util.generator import consumer
 
 from ezmsg.sigproc.cheby import ChebyshevFilterTransformer
 from ezmsg.sigproc.filter import FilterByDesignState
@@ -251,18 +250,18 @@ class ChainedCompositeProcessorWithDeepProcessors(CompositeProcessor[MockSetting
         }
 
 
-@consumer
-def mock_generator() -> Generator[MockMessageA, MockMessageA, None]:
-    """A mock generator function for testing purposes."""
-    while True:
-        yield MockMessageA()
+class MockGeneratorTransformer(BaseTransformer[MockSettings, MockMessageA, MockMessageA]):
+    """A mock transformer replacing the legacy @consumer generator."""
+
+    def _process(self, message: MockMessageA) -> MockMessageA:
+        return MockMessageA()
 
 
 class MockGeneratorCompositeProcessor(CompositeProcessor[MockSettings, MockMessageA, MockMessageB]):
     @staticmethod
     def _initialize_processors(settings):
         return {
-            "generator": mock_generator(),
+            "generator": MockGeneratorTransformer(settings=settings),
             "stateful_processor": MockStatefulProcessor(settings=settings),
         }
 
@@ -333,27 +332,26 @@ class ChainedCompositeProducerWithDeepProcessors(CompositeProducer[MockSettings,
         }
 
 
-@consumer
-def mock_producer_generator() -> Generator[MockMessageA, None, None]:
-    """A mock generator function for testing purposes."""
-    while True:
-        yield MockMessageA()
+class MockGeneratorProducer(BaseProducer[MockSettings, MockMessageA]):
+    """A mock producer replacing the legacy @consumer producer generator."""
+
+    async def _produce(self) -> MockMessageA:
+        return MockMessageA()
+
 
+class MockGeneratorPassthroughTransformer(BaseTransformer[MockSettings, MockMessageA, MockMessageA]):
+    """A mock transformer replacing the legacy unprimed generator."""
 
-def mock_generator_unprimed() -> Generator[MockMessageA, MockMessageA, None]:
-    """A mock generator function for testing purposes."""
-    output = MockMessageA()
-    while True:
-        input = yield output
-        output = input or output
+    def _process(self, message: MockMessageA) -> MockMessageA:
+        return message or MockMessageA()
 
 
 class MockGeneratorCompositeProducer(CompositeProducer[MockSettings, MockMessageB]):
     @staticmethod
     def _initialize_processors(settings):
         return {
-            "generator": mock_producer_generator(),
-            "mock_generator_unprimed": mock_generator_unprimed(),
+            "generator": MockGeneratorProducer(settings=settings),
+            "mock_generator_passthrough": MockGeneratorPassthroughTransformer(settings=settings),
             "stateful_processor": MockStatefulProcessor(settings=settings),
         }
 

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.0}/tests/unit/test_math.py

@@ -7,6 +7,7 @@ from ezmsg.sigproc.math.clip import ClipSettings, ClipTransformer
 from ezmsg.sigproc.math.difference import ConstDifferenceSettings, ConstDifferenceTransformer
 from ezmsg.sigproc.math.invert import InvertTransformer
 from ezmsg.sigproc.math.log import LogSettings, LogTransformer
+from ezmsg.sigproc.math.pow import PowSettings, PowTransformer
 from ezmsg.sigproc.math.scale import ScaleSettings, ScaleTransformer
 
 
@@ -85,3 +86,17 @@ def test_scale(scale_factor: float):
 
     assert msg_out.data.shape == (n_times, n_chans)
     assert np.array_equal(msg_out.data, in_dat * scale_factor)
+
+
+@pytest.mark.parametrize("exponent", [0.5, 2.0, 3.0])
+def test_pow(exponent: float):
+    n_times = 130
+    n_chans = 255
+    in_dat = np.abs(np.arange(n_times * n_chans).reshape(n_times, n_chans)).astype(float) + 1.0
+    msg_in = AxisArray(in_dat, dims=["time", "ch"])
+
+    xformer = PowTransformer(PowSettings(exponent=exponent))
+    msg_out = xformer(msg_in)
+
+    assert msg_out.data.shape == (n_times, n_chans)
+    assert np.allclose(msg_out.data, in_dat**exponent)

{ezmsg_sigproc-2.10.0 → ezmsg_sigproc-2.11.0}/tests/unit/test_scaler.py

@@ -10,7 +10,8 @@ from frozendict import frozendict
 from ezmsg.sigproc.scaler import (
     AdaptiveStandardScalerSettings,
     AdaptiveStandardScalerTransformer,
-    scaler,
+    RiverAdaptiveStandardScalerSettings,
+    RiverAdaptiveStandardScalerTransformer,
 )
 from tests.helpers.util import assert_messages_equal
 
@@ -39,8 +40,10 @@ def test_adaptive_standard_scaler_river(fixture_arrays):
     # The River example used alpha = 0.6
     # tau = -gain / np.log(1 - alpha) and here we're using gain = 0.01
     tau = 0.010913566679372915
-    _scaler = scaler(time_constant=tau, axis="time")
-    output = _scaler.send(test_input)
+    _scaler = RiverAdaptiveStandardScalerTransformer(
+        settings=RiverAdaptiveStandardScalerSettings(time_constant=tau, axis="time")
+    )
+    output = _scaler(test_input)
     assert np.allclose(output.data[0], expected_result, atol=1e-3)
     assert_messages_equal([test_input], backup)
 

ezmsg_sigproc-2.11.0/tests/unit/test_singlebandpow.py

@@ -0,0 +1,180 @@
+import numpy as np
+from ezmsg.util.messages.axisarray import AxisArray
+
+from ezmsg.sigproc.butterworthfilter import ButterworthFilterSettings
+from ezmsg.sigproc.downsample import DownsampleSettings
+from ezmsg.sigproc.singlebandpow import (
+    RMSBandPowerSettings,
+    RMSBandPowerTransformer,
+    SquareLawBandPowerSettings,
+    SquareLawBandPowerTransformer,
+)
+
+
+def _make_sinusoid(
+    freq: float = 50.0,
+    amplitude: float = 1.0,
+    fs: float = 1000.0,
+    duration: float = 2.0,
+    n_channels: int = 2,
+) -> AxisArray:
+    """Generate a multi-channel sinusoid as an AxisArray."""
+    n_samples = int(fs * duration)
+    t = np.arange(n_samples) / fs
+    signal = amplitude * np.sin(2 * np.pi * freq * t)
+    data = np.column_stack([signal] * n_channels)
+    return AxisArray(
+        data,
+        dims=["time", "ch"],
+        axes={"time": AxisArray.LinearAxis(gain=1.0 / fs, offset=0.0)},
+    )
+
+
+def test_rms_bandpower():
+    """RMS band power of a sinusoid should approximate A / sqrt(2)."""
+    freq = 50.0
+    amplitude = 2.0
+    fs = 1000.0
+    duration = 2.0
+    bin_duration = 0.1
+    n_channels = 2
+
+    msg_in = _make_sinusoid(freq=freq, amplitude=amplitude, fs=fs, duration=duration, n_channels=n_channels)
+
+    xformer = RMSBandPowerTransformer(
+        RMSBandPowerSettings(
+            bandpass=ButterworthFilterSettings(order=4, coef_type="sos", cuton=30.0, cutoff=70.0),
+            bin_duration=bin_duration,
+            apply_sqrt=True,
+        )
+    )
+
+    # Process in chunks to exercise stateful behavior
+    chunk_size = 100
+    outputs = []
+    for i in range(0, msg_in.data.shape[0], chunk_size):
+        chunk_data = msg_in.data[i : i + chunk_size]
+        chunk = AxisArray(
+            chunk_data,
+            dims=["time", "ch"],
+            axes={"time": AxisArray.LinearAxis(gain=1.0 / fs, offset=i / fs)},
+        )
+        result = xformer(chunk)
+        if result.data.size > 0:
+            outputs.append(result)
+
+    assert len(outputs) > 0
+
+    all_data = np.concatenate([o.data for o in outputs], axis=0)
+
+    # Output should have dims (time, ch)
+    assert all_data.ndim == 2
+    assert all_data.shape[1] == n_channels
+
+    # Check the output axis is "time" (renamed from "bin")
+    assert "time" in outputs[-1].dims
+
+    # After the filter settles, RMS of sinusoid should be ~ A / sqrt(2)
+    expected_rms = amplitude / np.sqrt(2)
+    # Use the second half of the output to let the filter settle
+    settled = all_data[all_data.shape[0] // 2 :]
+    mean_rms = np.mean(settled)
+    assert abs(mean_rms - expected_rms) < 0.15 * expected_rms, f"Expected RMS ~{expected_rms:.3f}, got {mean_rms:.3f}"
+
+
+def test_rms_bandpower_no_sqrt():
+    """With apply_sqrt=False, output should be mean-square power ~ A^2 / 2."""
+    freq = 50.0
+    amplitude = 2.0
+    fs = 1000.0
+    duration = 2.0
+    bin_duration = 0.1
+
+    msg_in = _make_sinusoid(freq=freq, amplitude=amplitude, fs=fs, duration=duration, n_channels=1)
+
+    xformer = RMSBandPowerTransformer(
+        RMSBandPowerSettings(
+            bandpass=ButterworthFilterSettings(order=4, coef_type="sos", cuton=30.0, cutoff=70.0),
+            bin_duration=bin_duration,
+            apply_sqrt=False,
+        )
+    )
+
+    chunk_size = 100
+    outputs = []
+    for i in range(0, msg_in.data.shape[0], chunk_size):
+        chunk_data = msg_in.data[i : i + chunk_size]
+        chunk = AxisArray(
+            chunk_data,
+            dims=["time", "ch"],
+            axes={"time": AxisArray.LinearAxis(gain=1.0 / fs, offset=i / fs)},
+        )
+        result = xformer(chunk)
+        if result.data.size > 0:
+            outputs.append(result)
+
+    assert len(outputs) > 0
+
+    all_data = np.concatenate([o.data for o in outputs], axis=0)
+
+    # Mean-square power of sinusoid: A^2 / 2
+    expected_ms = amplitude**2 / 2
+    settled = all_data[all_data.shape[0] // 2 :]
+    mean_ms = np.mean(settled)
+    assert (
+        abs(mean_ms - expected_ms) < 0.15 * expected_ms
+    ), f"Expected mean-square ~{expected_ms:.3f}, got {mean_ms:.3f}"
+
+
+def test_squarelaw_bandpower():
+    """Square-law band power should track signal power and downsample correctly."""
+    freq = 50.0
+    amplitude = 3.0
+    fs = 1000.0
+    duration = 2.0
+    target_rate = 100.0
+    n_channels = 2
+
+    msg_in = _make_sinusoid(freq=freq, amplitude=amplitude, fs=fs, duration=duration, n_channels=n_channels)
+
+    xformer = SquareLawBandPowerTransformer(
+        SquareLawBandPowerSettings(
+            bandpass=ButterworthFilterSettings(order=4, coef_type="sos", cuton=30.0, cutoff=70.0),
+            lowpass=ButterworthFilterSettings(order=4, coef_type="sos", cutoff=10.0),
+            downsample=DownsampleSettings(target_rate=target_rate),
+        )
+    )
+
+    chunk_size = 100
+    outputs = []
+    for i in range(0, msg_in.data.shape[0], chunk_size):
+        chunk_data = msg_in.data[i : i + chunk_size]
+        chunk = AxisArray(
+            chunk_data,
+            dims=["time", "ch"],
+            axes={"time": AxisArray.LinearAxis(gain=1.0 / fs, offset=i / fs)},
+        )
+        result = xformer(chunk)
+        if result.data.size > 0:
+            outputs.append(result)
+
+    assert len(outputs) > 0
+
+    all_data = np.concatenate([o.data for o in outputs], axis=0)
+
+    # Output should have dims (time, ch) and be downsampled
+    assert all_data.ndim == 2
+    assert all_data.shape[1] == n_channels
+
+    # Check output rate: should be approximately target_rate
+    out_axis = outputs[-1].get_axis("time")
+    out_rate = 1.0 / out_axis.gain
+    assert abs(out_rate - target_rate) < 1.0, f"Expected rate ~{target_rate}, got {out_rate}"
+
+    # After settling, the mean power should track A^2/2
+    expected_ms = amplitude**2 / 2
+    settled = all_data[all_data.shape[0] // 2 :]
+    mean_power = np.mean(settled)
+    assert (
+        abs(mean_power - expected_ms) < 0.25 * expected_ms
+    ), f"Expected power ~{expected_ms:.3f}, got {mean_power:.3f}"