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

ezmsg/sigproc/fir_hilbert.py

@@ -4,6 +4,9 @@ import typing
 import ezmsg.core as ez
 import numpy as np
 import scipy.signal as sps
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
 from ezmsg.sigproc.base import BaseStatefulTransformer, processor_state
 from ezmsg.sigproc.filter import (
     BACoeffs,
@@ -12,8 +15,6 @@ from ezmsg.sigproc.filter import (
     FilterBaseSettings,
     FilterByDesignTransformer,
 )
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
 
 
 class FIRHilbertFilterSettings(FilterBaseSettings):
@@ -60,7 +61,7 @@ class FIRHilbertFilterSettings(FilterBaseSettings):
 
     weight_pass: float = 1.0
     """
-    Weight for Hilbert pass region. 
+    Weight for Hilbert pass region.
     """
 
     weight_stop_lo: float = 1.0
@@ -74,7 +75,7 @@ class FIRHilbertFilterSettings(FilterBaseSettings):
     """
 
     norm_band: tuple[float, float] | None = None
-    """ 
+    """
     Optional normalization band (f_lo, f_hi) in Hz for gain normalization.
     If None, no normalization is applied.
     """
@@ -128,9 +129,7 @@ def fir_hilbert_design_fun(
         if bands[i] <= bands[i - 1]:
             bands[i] = np.nextafter(bands[i - 1], np.inf)
     if bands[-2] >= nyq:
-        ez.logger.warning(
-            "Hilbert upper stopband collapsed; using 2-band (stop/pass) design."
-        )
+        ez.logger.warning("Hilbert upper stopband collapsed; using 2-band (stop/pass) design.")
         bands = bands[:-3] + [nyq]
         desired = desired[:-1]
         weight = weight[:-1]
@@ -139,9 +138,7 @@ def fir_hilbert_design_fun(
     g = None
     if norm_freq is not None:
         if norm_freq < f1 or norm_freq > f2:
-            ez.logger.warning(
-                "Invalid normalization frequency specifications. Skipping normalization."
-            )
+            ez.logger.warning("Invalid normalization frequency specifications. Skipping normalization.")
         else:
             f0 = float(norm_freq)
             w = 2.0 * np.pi * (np.asarray([f0], dtype=np.float64) / fs)
@@ -152,13 +149,9 @@ def fir_hilbert_design_fun(
         if lo < f1 or hi > f2:
             lo = max(lo, f1)
             hi = min(hi, f2)
-            ez.logger.warning(
-                "Normalization band outside passband. Clipping to passband for normalization."
-            )
+            ez.logger.warning("Normalization band outside passband. Clipping to passband for normalization.")
         if lo >= hi:
-            ez.logger.warning(
-                "Invalid normalization band specifications. Skipping normalization."
-            )
+            ez.logger.warning("Invalid normalization band specifications. Skipping normalization.")
         else:
             freqs = np.linspace(lo, hi, 2048, dtype=np.float64)
             w = 2.0 * np.pi * (np.asarray(freqs, dtype=np.float64) / fs)
@@ -169,9 +162,7 @@ def fir_hilbert_design_fun(
     return (b, a)
 
 
-class FIRHilbertFilterTransformer(
-    FilterByDesignTransformer[FIRHilbertFilterSettings, BACoeffs]
-):
+class FIRHilbertFilterTransformer(FilterByDesignTransformer[FIRHilbertFilterSettings, BACoeffs]):
     def get_design_function(self) -> typing.Callable[[float], BACoeffs | None]:
         if self.settings.coef_type != "ba":
             ez.logger.error("FIRHilbert only supports coef_type='ba'.")
@@ -198,11 +189,7 @@ class FIRHilbertFilterTransformer(
         return b.size if b is not None else None
 
 
-class FIRHilbertFilterUnit(
-    BaseFilterByDesignTransformerUnit[
-        FIRHilbertFilterSettings, FIRHilbertFilterTransformer
-    ]
-):
+class FIRHilbertFilterUnit(BaseFilterByDesignTransformerUnit[FIRHilbertFilterSettings, FIRHilbertFilterTransformer]):
     SETTINGS = FIRHilbertFilterSettings
 
 
@@ -214,9 +201,7 @@ class FIRHilbertEnvelopeState:
 
 
 class FIRHilbertEnvelopeTransformer(
-    BaseStatefulTransformer[
-        FIRHilbertFilterSettings, AxisArray, AxisArray, FIRHilbertEnvelopeState
-    ]
+    BaseStatefulTransformer[FIRHilbertFilterSettings, AxisArray, AxisArray, FIRHilbertEnvelopeState]
 ):
     """
     Processor for computing the envelope of a signal using the Hilbert transform.
@@ -304,9 +289,7 @@ class FIRHilbertEnvelopeTransformer(
 
         if self._state.delay_buf is None:
             lead_shape = x.shape[:-1]
-            self._state.delay_buf = np.zeros(
-                lead_shape + (self._state.dly,), dtype=x.dtype
-            )
+            self._state.delay_buf = np.zeros(lead_shape + (self._state.dly,), dtype=x.dtype)
 
         x_cat = np.concatenate([self._state.delay_buf, x], axis=-1)
         x_delayed_full = x_cat[..., : -self._state.dly]

ezmsg/sigproc/fir_pmc.py

@@ -4,6 +4,7 @@ import typing
 import ezmsg.core as ez
 import numpy as np
 import scipy.signal
+
 from ezmsg.sigproc.filter import (
     BACoeffs,
     BaseFilterByDesignTransformerUnit,
@@ -33,14 +34,14 @@ class ParksMcClellanFIRSettings(FilterBaseSettings):
     """
     Cuton frequency (Hz). If `cutoff` is not specified then this is the highpass corner. Otherwise,
     if this is lower than `cutoff` then this is the beginning of the bandpass
-    or if this is greater than `cutoff` then this is the end of the bandstop. 
+    or if this is greater than `cutoff` then this is the end of the bandstop.
     """
 
     cutoff: float | None = None
     """
     Cutoff frequency (Hz). If `cuton` is not specified then this is the lowpass corner. Otherwise,
     if this is greater than `cuton` then this is the end of the bandpass,
-    or if this is less than `cuton` then this is the beginning of the bandstop. 
+    or if this is less than `cuton` then this is the beginning of the bandstop.
     """
 
     transition: float = 10.0
@@ -187,9 +188,7 @@ def parks_mcclellan_design_fun(
     return (b, np.array([1.0]))
 
 
-class ParksMcClellanFIRTransformer(
-    FilterByDesignTransformer[ParksMcClellanFIRSettings, BACoeffs]
-):
+class ParksMcClellanFIRTransformer(FilterByDesignTransformer[ParksMcClellanFIRSettings, BACoeffs]):
     def get_design_function(self) -> typing.Callable[[float], BACoeffs | None]:
         if self.settings.coef_type != "ba":
             ez.logger.error("ParksMcClellanFIR only supports coef_type='ba'.")
@@ -206,9 +205,5 @@ class ParksMcClellanFIRTransformer(
         )
 
 
-class ParksMcClellanFIR(
-    BaseFilterByDesignTransformerUnit[
-        ParksMcClellanFIRSettings, ParksMcClellanFIRTransformer
-    ]
-):
+class ParksMcClellanFIR(BaseFilterByDesignTransformerUnit[ParksMcClellanFIRSettings, ParksMcClellanFIRTransformer]):
     SETTINGS = ParksMcClellanFIRSettings

ezmsg/sigproc/firfilter.py

@@ -6,10 +6,10 @@ import numpy.typing as npt
 import scipy.signal
 
 from .filter import (
-    FilterBaseSettings,
-    FilterByDesignTransformer,
     BACoeffs,
     BaseFilterByDesignTransformerUnit,
+    FilterBaseSettings,
+    FilterByDesignTransformer,
 )
 
 
@@ -25,16 +25,16 @@ class FIRFilterSettings(FilterBaseSettings):
 
     cutoff: float | npt.ArrayLike | None = None
     """
-    Cutoff frequency of filter (expressed in the same units as fs) OR an array of cutoff frequencies 
-    (that is, band edges). In the former case, as a float, the cutoff frequency should correspond with 
-    the half-amplitude point, where the attenuation will be -6dB. In the latter case, the frequencies in 
-    cutoff should be positive and monotonically increasing between 0 and fs/2. The values 0 and fs/2 must 
+    Cutoff frequency of filter (expressed in the same units as fs) OR an array of cutoff frequencies
+    (that is, band edges). In the former case, as a float, the cutoff frequency should correspond with
+    the half-amplitude point, where the attenuation will be -6dB. In the latter case, the frequencies in
+    cutoff should be positive and monotonically increasing between 0 and fs/2. The values 0 and fs/2 must
     not be included in cutoff.
     """
 
     width: float | None = None
     """
-    If width is not None, then assume it is the approximate width of the transition region (expressed in 
+    If width is not None, then assume it is the approximate width of the transition region (expressed in
     the same units as fs) for use in Kaiser FIR filter design. In this case, the window argument is ignored.
     """
 
@@ -45,18 +45,18 @@ class FIRFilterSettings(FilterBaseSettings):
 
     pass_zero: bool | str = True
     """
-    If True, the gain at the frequency 0 (i.e., the “DC gain”) is 1. If False, the DC gain is 0. Can also 
+    If True, the gain at the frequency 0 (i.e., the “DC gain”) is 1. If False, the DC gain is 0. Can also
     be a string argument for the desired filter type (equivalent to btype in IIR design functions).
     {‘lowpass’, ‘highpass’, ‘bandpass’, ‘bandstop’}
     """
 
     scale: bool = True
     """
-    Set to True to scale the coefficients so that the frequency response is exactly unity at a certain 
+    Set to True to scale the coefficients so that the frequency response is exactly unity at a certain
     frequency. That frequency is either:
     * 0 (DC) if the first passband starts at 0 (i.e. pass_zero is True)
-    * fs/2 (the Nyquist frequency) if the first passband ends at fs/2 
-        (i.e the filter is a single band highpass filter); 
+    * fs/2 (the Nyquist frequency) if the first passband ends at fs/2
+        (i.e the filter is a single band highpass filter);
         center of first passband otherwise
     """
 
@@ -113,7 +113,5 @@ class FIRFilterTransformer(FilterByDesignTransformer[FIRFilterSettings, BACoeffs
         )
 
 
-class FIRFilter(
-    BaseFilterByDesignTransformerUnit[FIRFilterSettings, FIRFilterTransformer]
-):
+class FIRFilter(BaseFilterByDesignTransformerUnit[FIRFilterSettings, FIRFilterTransformer]):
     SETTINGS = FIRFilterSettings

ezmsg/sigproc/gaussiansmoothing.py

@@ -1,13 +1,13 @@
-from typing import Callable
 import warnings
+from typing import Callable
 
 import numpy as np
 
 from .filter import (
-    FilterBaseSettings,
     BACoeffs,
-    FilterByDesignTransformer,
     BaseFilterByDesignTransformerUnit,
+    FilterBaseSettings,
+    FilterByDesignTransformer,
 )
 
 
@@ -68,9 +68,7 @@ def gaussian_smoothing_filter_design(
     return b, a
 
 
-class GaussianSmoothingFilterTransformer(
-    FilterByDesignTransformer[GaussianSmoothingSettings, BACoeffs]
-):
+class GaussianSmoothingFilterTransformer(FilterByDesignTransformer[GaussianSmoothingSettings, BACoeffs]):
     def get_design_function(
         self,
     ) -> Callable[[float], BACoeffs]:
@@ -86,8 +84,6 @@ class GaussianSmoothingFilterTransformer(
 
 
 class GaussianSmoothingFilter(
-    BaseFilterByDesignTransformerUnit[
-        GaussianSmoothingSettings, GaussianSmoothingFilterTransformer
-    ]
+    BaseFilterByDesignTransformerUnit[GaussianSmoothingSettings, GaussianSmoothingFilterTransformer]
 ):
     SETTINGS = GaussianSmoothingSettings

ezmsg/sigproc/kaiser.py

@@ -6,10 +6,10 @@ import numpy.typing as npt
 import scipy.signal
 
 from .filter import (
-    FilterBaseSettings,
-    FilterByDesignTransformer,
     BACoeffs,
     BaseFilterByDesignTransformerUnit,
+    FilterBaseSettings,
+    FilterByDesignTransformer,
 )
 
 
@@ -20,30 +20,30 @@ class KaiserFilterSettings(FilterBaseSettings):
 
     cutoff: float | npt.ArrayLike | None = None
     """
-    Cutoff frequency of filter (expressed in the same units as fs) OR an array of cutoff frequencies 
-    (that is, band edges). In the former case, as a float, the cutoff frequency should correspond with 
-    the half-amplitude point, where the attenuation will be -6dB. In the latter case, the frequencies in 
-    cutoff should be positive and monotonically increasing between 0 and fs/2. The values 0 and fs/2 must 
+    Cutoff frequency of filter (expressed in the same units as fs) OR an array of cutoff frequencies
+    (that is, band edges). In the former case, as a float, the cutoff frequency should correspond with
+    the half-amplitude point, where the attenuation will be -6dB. In the latter case, the frequencies in
+    cutoff should be positive and monotonically increasing between 0 and fs/2. The values 0 and fs/2 must
     not be included in cutoff.
     """
 
     ripple: float | None = None
     """
-    Upper bound for the deviation (in dB) of the magnitude of the filter's frequency response from that of 
+    Upper bound for the deviation (in dB) of the magnitude of the filter's frequency response from that of
     the desired filter (not including frequencies in any transition intervals).
     See scipy.signal.kaiserord for more information.
     """
 
     width: float | None = None
     """
-    If width is not None, then assume it is the approximate width of the transition region (expressed in 
+    If width is not None, then assume it is the approximate width of the transition region (expressed in
     the same units as fs) for use in Kaiser FIR filter design.
     See scipy.signal.kaiserord for more information.
     """
 
     pass_zero: bool | str = True
     """
-    If True, the gain at the frequency 0 (i.e., the “DC gain”) is 1. If False, the DC gain is 0. Can also 
+    If True, the gain at the frequency 0 (i.e., the “DC gain”) is 1. If False, the DC gain is 0. Can also
     be a string argument for the desired filter type (equivalent to btype in IIR design functions).
     {‘lowpass’, ‘highpass’, ‘bandpass’, ‘bandstop’}
     """
@@ -88,9 +88,7 @@ def kaiser_design_fun(
     return (taps, np.array([1.0]))
 
 
-class KaiserFilterTransformer(
-    FilterByDesignTransformer[KaiserFilterSettings, BACoeffs]
-):
+class KaiserFilterTransformer(FilterByDesignTransformer[KaiserFilterSettings, BACoeffs]):
     def get_design_function(
         self,
     ) -> typing.Callable[[float], BACoeffs | None]:
@@ -104,7 +102,5 @@ class KaiserFilterTransformer(
         )
 
 
-class KaiserFilter(
-    BaseFilterByDesignTransformerUnit[KaiserFilterSettings, KaiserFilterTransformer]
-):
+class KaiserFilter(BaseFilterByDesignTransformerUnit[KaiserFilterSettings, KaiserFilterTransformer]):
     SETTINGS = KaiserFilterSettings

ezmsg/sigproc/math/abs.py

@@ -14,9 +14,7 @@ class AbsTransformer(BaseTransformer[None, AxisArray, AxisArray]):
         return replace(message, data=np.abs(message.data))
 
 
-class Abs(
-    BaseTransformerUnit[None, AxisArray, AxisArray, AbsTransformer]
-): ...  # SETTINGS = None
+class Abs(BaseTransformerUnit[None, AxisArray, AxisArray, AbsTransformer]): ...  # SETTINGS = None
 
 
 def abs() -> AbsTransformer:

ezmsg/sigproc/math/add.py

@@ -0,0 +1,121 @@
+"""Signal addition utilities."""
+
+import asyncio
+import typing
+from dataclasses import dataclass, field
+
+import ezmsg.core as ez
+from ezmsg.baseproc.util.asio import run_coroutine_sync
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
+from ..base import BaseTransformer, BaseTransformerUnit
+
+# --- Constant Addition (single input) ---
+
+
+class ConstAddSettings(ez.Settings):
+    value: float = 0.0
+    """Number to add to the input data."""
+
+
+class ConstAddTransformer(BaseTransformer[ConstAddSettings, AxisArray, AxisArray]):
+    """Add a constant value to input data."""
+
+    def _process(self, message: AxisArray) -> AxisArray:
+        return replace(message, data=message.data + self.settings.value)
+
+
+class ConstAdd(BaseTransformerUnit[ConstAddSettings, AxisArray, AxisArray, ConstAddTransformer]):
+    """Unit wrapper for ConstAddTransformer."""
+
+    SETTINGS = ConstAddSettings
+
+
+# --- Two-input Addition ---
+
+
+@dataclass
+class AddState:
+    """State for Add processor with two input queues."""
+
+    queue_a: "asyncio.Queue[AxisArray]" = field(default_factory=asyncio.Queue)
+    queue_b: "asyncio.Queue[AxisArray]" = field(default_factory=asyncio.Queue)
+
+
+class AddProcessor:
+    """Processor that adds two AxisArray signals together.
+
+    This processor maintains separate queues for two input streams and
+    adds corresponding messages element-wise. It assumes both inputs
+    have compatible shapes and aligned time spans.
+    """
+
+    def __init__(self):
+        self._state = AddState()
+
+    @property
+    def state(self) -> AddState:
+        return self._state
+
+    @state.setter
+    def state(self, state: AddState | bytes | None) -> None:
+        if state is not None:
+            # TODO: Support hydrating state from bytes
+            # if isinstance(state, bytes):
+            #     self._state = pickle.loads(state)
+            # else:
+            self._state = state
+
+    def push_a(self, msg: AxisArray) -> None:
+        """Push a message to queue A."""
+        self._state.queue_a.put_nowait(msg)
+
+    def push_b(self, msg: AxisArray) -> None:
+        """Push a message to queue B."""
+        self._state.queue_b.put_nowait(msg)
+
+    async def __acall__(self) -> AxisArray:
+        """Await and add the next messages from both queues."""
+        a = await self._state.queue_a.get()
+        b = await self._state.queue_b.get()
+        return replace(a, data=a.data + b.data)
+
+    def __call__(self) -> AxisArray:
+        """Synchronously get and add the next messages from both queues."""
+        return run_coroutine_sync(self.__acall__())
+
+    # Aliases for legacy interface
+    async def __anext__(self) -> AxisArray:
+        return await self.__acall__()
+
+    def __next__(self) -> AxisArray:
+        return self.__call__()
+
+
+class Add(ez.Unit):
+    """Add two signals together.
+
+    Assumes compatible/similar axes/dimensions and aligned time spans.
+    Messages are paired by arrival order (oldest from each queue).
+    """
+
+    INPUT_SIGNAL_A = ez.InputStream(AxisArray)
+    INPUT_SIGNAL_B = ez.InputStream(AxisArray)
+    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
+
+    async def initialize(self) -> None:
+        self.processor = AddProcessor()
+
+    @ez.subscriber(INPUT_SIGNAL_A)
+    async def on_a(self, msg: AxisArray) -> None:
+        self.processor.push_a(msg)
+
+    @ez.subscriber(INPUT_SIGNAL_B)
+    async def on_b(self, msg: AxisArray) -> None:
+        self.processor.push_b(msg)
+
+    @ez.publisher(OUTPUT_SIGNAL)
+    async def output(self) -> typing.AsyncGenerator:
+        while True:
+            yield self.OUTPUT_SIGNAL, await self.processor.__acall__()

ezmsg/sigproc/math/clip.py

@@ -1,5 +1,5 @@
-import numpy as np
 import ezmsg.core as ez
+import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 

ezmsg/sigproc/math/difference.py

@@ -1,4 +1,9 @@
+import asyncio
+import typing
+from dataclasses import dataclass, field
+
 import ezmsg.core as ez
+from ezmsg.baseproc.util.asio import run_coroutine_sync
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -10,12 +15,11 @@ class ConstDifferenceSettings(ez.Settings):
     """number to subtract or be subtracted from the input data"""
 
     subtrahend: bool = True
-    """If True (default) then value is subtracted from the input data. If False, the input data is subtracted from value."""
+    """If True (default) then value is subtracted from the input data. If False, the input data
+    is subtracted from value."""
 
 
-class ConstDifferenceTransformer(
-    BaseTransformer[ConstDifferenceSettings, AxisArray, AxisArray]
-):
+class ConstDifferenceTransformer(BaseTransformer[ConstDifferenceSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
         return replace(
             message,
@@ -25,17 +29,11 @@ class ConstDifferenceTransformer(
         )
 
 
-class ConstDifference(
-    BaseTransformerUnit[
-        ConstDifferenceSettings, AxisArray, AxisArray, ConstDifferenceTransformer
-    ]
-):
+class ConstDifference(BaseTransformerUnit[ConstDifferenceSettings, AxisArray, AxisArray, ConstDifferenceTransformer]):
     SETTINGS = ConstDifferenceSettings
 
 
-def const_difference(
-    value: float = 0.0, subtrahend: bool = True
-) -> ConstDifferenceTransformer:
+def const_difference(value: float = 0.0, subtrahend: bool = True) -> ConstDifferenceTransformer:
     """
     result = (in_data - value) if subtrahend else (value - in_data)
     https://en.wikipedia.org/wiki/Template:Arithmetic_operations
@@ -47,27 +45,91 @@ def const_difference(
 
     Returns: :obj:`ConstDifferenceTransformer`.
     """
-    return ConstDifferenceTransformer(
-        ConstDifferenceSettings(value=value, subtrahend=subtrahend)
-    )
-
-
-# class DifferenceSettings(ez.Settings):
-#     pass
-#
-#
-# class Difference(ez.Unit):
-#     SETTINGS = DifferenceSettings
-#
-#     INPUT_SIGNAL_1 = ez.InputStream(AxisArray)
-#     INPUT_SIGNAL_2 = ez.InputStream(AxisArray)
-#     OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-#
-#     @ez.subscriber(INPUT_SIGNAL_2, zero_copy=True)
-#     @ez.publisher(OUTPUT_SIGNAL)
-#     async def on_input_2(self, message: AxisArray) -> typing.AsyncGenerator:
-#         # TODO: buffer_2
-#         # TODO: take buffer_1 - buffer_2 for ranges that align
-#         # TODO: Drop samples from buffer_1 and buffer_2
-#         if ret is not None:
-#             yield self.OUTPUT_SIGNAL, ret
+    return ConstDifferenceTransformer(ConstDifferenceSettings(value=value, subtrahend=subtrahend))
+
+
+# --- Two-input Difference ---
+
+
+@dataclass
+class DifferenceState:
+    """State for Difference processor with two input queues."""
+
+    queue_a: "asyncio.Queue[AxisArray]" = field(default_factory=asyncio.Queue)
+    queue_b: "asyncio.Queue[AxisArray]" = field(default_factory=asyncio.Queue)
+
+
+class DifferenceProcessor:
+    """Processor that subtracts two AxisArray signals (A - B).
+
+    This processor maintains separate queues for two input streams and
+    subtracts corresponding messages element-wise. It assumes both inputs
+    have compatible shapes and aligned time spans.
+    """
+
+    def __init__(self):
+        self._state = DifferenceState()
+
+    @property
+    def state(self) -> DifferenceState:
+        return self._state
+
+    @state.setter
+    def state(self, state: DifferenceState | bytes | None) -> None:
+        if state is not None:
+            self._state = state
+
+    def push_a(self, msg: AxisArray) -> None:
+        """Push a message to queue A (minuend)."""
+        self._state.queue_a.put_nowait(msg)
+
+    def push_b(self, msg: AxisArray) -> None:
+        """Push a message to queue B (subtrahend)."""
+        self._state.queue_b.put_nowait(msg)
+
+    async def __acall__(self) -> AxisArray:
+        """Await and subtract the next messages (A - B)."""
+        a = await self._state.queue_a.get()
+        b = await self._state.queue_b.get()
+        return replace(a, data=a.data - b.data)
+
+    def __call__(self) -> AxisArray:
+        """Synchronously get and subtract the next messages."""
+        return run_coroutine_sync(self.__acall__())
+
+    # Aliases for legacy interface
+    async def __anext__(self) -> AxisArray:
+        return await self.__acall__()
+
+    def __next__(self) -> AxisArray:
+        return self.__call__()
+
+
+class Difference(ez.Unit):
+    """Subtract two signals (A - B).
+
+    Assumes compatible/similar axes/dimensions and aligned time spans.
+    Messages are paired by arrival order (oldest from each queue).
+
+    OUTPUT = INPUT_SIGNAL_A - INPUT_SIGNAL_B
+    """
+
+    INPUT_SIGNAL_A = ez.InputStream(AxisArray)
+    INPUT_SIGNAL_B = ez.InputStream(AxisArray)
+    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
+
+    async def initialize(self) -> None:
+        self.processor = DifferenceProcessor()
+
+    @ez.subscriber(INPUT_SIGNAL_A)
+    async def on_a(self, msg: AxisArray) -> None:
+        self.processor.push_a(msg)
+
+    @ez.subscriber(INPUT_SIGNAL_B)
+    async def on_b(self, msg: AxisArray) -> None:
+        self.processor.push_b(msg)
+
+    @ez.publisher(OUTPUT_SIGNAL)
+    async def output(self) -> typing.AsyncGenerator:
+        while True:
+            yield self.OUTPUT_SIGNAL, await self.processor.__acall__()

ezmsg/sigproc/math/invert.py

@@ -9,9 +9,7 @@ class InvertTransformer(BaseTransformer[None, AxisArray, AxisArray]):
         return replace(message, data=1 / message.data)
 
 
-class Invert(
-    BaseTransformerUnit[None, AxisArray, AxisArray, InvertTransformer]
-): ...  # SETTINGS = None
+class Invert(BaseTransformerUnit[None, AxisArray, AxisArray, InvertTransformer]): ...  # SETTINGS = None
 
 
 def invert() -> InvertTransformer:

ezmsg/sigproc/math/log.py

@@ -1,5 +1,5 @@
-import numpy as np
 import ezmsg.core as ez
+import numpy as np
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -17,11 +17,7 @@ class LogSettings(ez.Settings):
 class LogTransformer(BaseTransformer[LogSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
         data = message.data
-        if (
-            self.settings.clip_zero
-            and np.any(data <= 0)
-            and np.issubdtype(data.dtype, np.floating)
-        ):
+        if self.settings.clip_zero and np.any(data <= 0) and np.issubdtype(data.dtype, np.floating):
             data = np.clip(data, a_min=np.finfo(data.dtype).tiny, a_max=None)
         return replace(message, data=np.log(data) / np.log(self.settings.base))