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

ezmsg/sigproc/spectrum.py

@@ -1,14 +1,14 @@
 import enum
-from functools import partial
 import typing
+from functools import partial
 
+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,
-    slice_along_axis,
     replace,
+    slice_along_axis,
 )
 
 from .base import (
@@ -127,17 +127,13 @@ class SpectrumState:
     window: npt.NDArray | None = None
 
 
-class SpectrumTransformer(
-    BaseStatefulTransformer[SpectrumSettings, AxisArray, AxisArray, SpectrumState]
-):
+class SpectrumTransformer(BaseStatefulTransformer[SpectrumSettings, AxisArray, AxisArray, SpectrumState]):
     def _hash_message(self, message: AxisArray) -> int:
         axis = self.settings.axis or message.dims[0]
         ax_idx = message.get_axis_idx(axis)
         ax_info = message.axes[axis]
         targ_len = message.data.shape[ax_idx]
-        return hash(
-            (targ_len, message.data.ndim, message.data.dtype.kind, ax_idx, ax_info.gain)
-        )
+        return hash((targ_len, message.data.ndim, message.data.dtype.kind, ax_idx, ax_info.gain))
 
     def _reset_state(self, message: AxisArray) -> None:
         axis = self.settings.axis or message.dims[0]
@@ -156,8 +152,7 @@ class SpectrumTransformer(
             + [1] * (message.data.ndim - 1 - ax_idx)
         )
         if self.settings.transform != SpectralTransform.RAW_COMPLEX and not (
-            self.settings.transform == SpectralTransform.REAL
-            or self.settings.transform == SpectralTransform.IMAG
+            self.settings.transform == SpectralTransform.REAL or self.settings.transform == SpectralTransform.IMAG
         ):
             scale = np.sum(window**2.0) * ax_info.gain
 
@@ -170,30 +165,21 @@ class SpectrumTransformer(
         if (not b_complex) and self.settings.output == SpectralOutput.POSITIVE:
             # If input is not complex and desired output is SpectralOutput.POSITIVE, we can save some computation
             #  by using rfft and rfftfreq.
-            self.state.fftfun = partial(
-                np.fft.rfft, n=nfft, axis=ax_idx, norm=self.settings.norm
-            )
+            self.state.fftfun = partial(np.fft.rfft, n=nfft, axis=ax_idx, norm=self.settings.norm)
             freqs = np.fft.rfftfreq(nfft, d=ax_info.gain * targ_len / nfft)
         else:
-            self.state.fftfun = partial(
-                np.fft.fft, n=nfft, axis=ax_idx, norm=self.settings.norm
-            )
+            self.state.fftfun = partial(np.fft.fft, n=nfft, axis=ax_idx, norm=self.settings.norm)
             freqs = np.fft.fftfreq(nfft, d=ax_info.gain * targ_len / nfft)
             if self.settings.output == SpectralOutput.POSITIVE:
                 self.state.f_sl = slice(None, nfft // 2 + 1 - (nfft % 2))
             elif self.settings.output == SpectralOutput.NEGATIVE:
                 freqs = np.fft.fftshift(freqs, axes=-1)
                 self.state.f_sl = slice(None, nfft // 2 + 1)
-            elif (
-                self.settings.do_fftshift
-                and self.settings.output == SpectralOutput.FULL
-            ):
+            elif self.settings.do_fftshift and self.settings.output == SpectralOutput.FULL:
                 freqs = np.fft.fftshift(freqs, axes=-1)
             freqs = freqs[self.state.f_sl]
         freqs = freqs.tolist()  # To please type checking
-        self.state.freq_axis = AxisArray.LinearAxis(
-            unit="Hz", gain=freqs[1] - freqs[0], offset=freqs[0]
-        )
+        self.state.freq_axis = AxisArray.LinearAxis(unit="Hz", gain=freqs[1] - freqs[0], offset=freqs[0])
         self.state.new_dims = (
             message.dims[:ax_idx]
             + [
@@ -232,11 +218,7 @@ class SpectrumTransformer(
         ax_idx = message.get_axis_idx(axis)
         targ_len = message.data.shape[ax_idx]
 
-        new_axes = {
-            k: v
-            for k, v in message.axes.items()
-            if k not in [self.settings.out_axis, axis]
-        }
+        new_axes = {k: v for k, v in message.axes.items() if k not in [self.settings.out_axis, axis]}
         new_axes[self.settings.out_axis or axis] = self.state.freq_axis
 
         if self.state.window is not None:
@@ -261,9 +243,7 @@ class SpectrumTransformer(
         return msg_out
 
 
-class Spectrum(
-    BaseTransformerUnit[SpectrumSettings, AxisArray, AxisArray, SpectrumTransformer]
-):
+class Spectrum(BaseTransformerUnit[SpectrumSettings, AxisArray, AxisArray, SpectrumTransformer]):
     SETTINGS = SpectrumSettings
 
 

ezmsg/sigproc/transpose.py

@@ -1,6 +1,7 @@
 from types import EllipsisType
-import numpy as np
+
 import ezmsg.core as ez
+import numpy as np
 from ezmsg.util.messages.axisarray import (
     AxisArray,
     replace,
@@ -30,9 +31,7 @@ class TransposeState:
     axes_ints: tuple[int, ...] | None = None
 
 
-class TransposeTransformer(
-    BaseStatefulTransformer[TransposeSettings, AxisArray, AxisArray, TransposeState]
-):
+class TransposeTransformer(BaseStatefulTransformer[TransposeSettings, AxisArray, AxisArray, TransposeState]):
     """
     Downsampled data simply comprise every `factor`th sample.
     This should only be used following appropriate lowpass filtering.
@@ -67,11 +66,7 @@ class TransposeTransformer(
                     if ax not in message.dims:
                         raise ValueError(f"Axis {ax} not found in message dims.")
                     suffix.append(message.dims.index(ax))
-            ells = [
-                _
-                for _ in range(message.data.ndim)
-                if _ not in prefix and _ not in suffix
-            ]
+            ells = [_ for _ in range(message.data.ndim) if _ not in prefix and _ not in suffix]
             re_ix = tuple(prefix + ells + suffix)
             if re_ix == tuple(range(message.data.ndim)):
                 self._state.axes_ints = None
@@ -100,17 +95,13 @@ class TransposeTransformer(
                 # If the memory is already contiguous in the correct order, np.require won't do anything.
                 msg_out = replace(
                     message,
-                    data=np.require(
-                        message.data, requirements=self.settings.order.upper()[0]
-                    ),
+                    data=np.require(message.data, requirements=self.settings.order.upper()[0]),
                 )
         else:
             dims_out = [message.dims[ix] for ix in self.state.axes_ints]
             data_out = np.transpose(message.data, axes=self.state.axes_ints)
             if self.settings.order is not None:
-                data_out = np.require(
-                    data_out, requirements=self.settings.order.upper()[0]
-                )
+                data_out = np.require(data_out, requirements=self.settings.order.upper()[0])
             msg_out = replace(
                 message,
                 data=data_out,
@@ -119,9 +110,7 @@ class TransposeTransformer(
         return msg_out
 
 
-class Transpose(
-    BaseTransformerUnit[TransposeSettings, AxisArray, AxisArray, TransposeTransformer]
-):
+class Transpose(BaseTransformerUnit[TransposeSettings, AxisArray, AxisArray, TransposeTransformer]):
     SETTINGS = TransposeSettings
 
 

ezmsg/sigproc/util/asio.py

@@ -1,156 +1,25 @@
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-import contextlib
-import inspect
-import threading
-from typing import Any, Coroutine, TypeVar
-
-T = TypeVar("T")
-
-
-class CoroutineExecutionError(Exception):
-    """Custom exception for coroutine execution failures"""
-
-    pass
-
-
-def run_coroutine_sync(coroutine: Coroutine[Any, Any, T], timeout: float = 30) -> T:
-    """
-    Executes an asyncio coroutine synchronously, with enhanced error handling.
-
-    Args:
-        coroutine: The asyncio coroutine to execute
-        timeout: Maximum time in seconds to wait for coroutine completion (default: 30)
-
-    Returns:
-        The result of the coroutine execution
-
-    Raises:
-        CoroutineExecutionError: If execution fails due to threading or event loop issues
-        TimeoutError: If execution exceeds the timeout period
-        Exception: Any exception raised by the coroutine
-    """
-
-    def run_in_new_loop() -> T:
-        """
-        Creates and runs a new event loop in the current thread.
-        Ensures proper cleanup of the loop.
-        """
-        new_loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(new_loop)
-        try:
-            return new_loop.run_until_complete(
-                asyncio.wait_for(coroutine, timeout=timeout)
-            )
-        finally:
-            with contextlib.suppress(Exception):
-                # Clean up any pending tasks
-                pending = asyncio.all_tasks(new_loop)
-                for task in pending:
-                    task.cancel()
-                new_loop.run_until_complete(
-                    asyncio.gather(*pending, return_exceptions=True)
-                )
-            new_loop.close()
-
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        try:
-            return asyncio.run(asyncio.wait_for(coroutine, timeout=timeout))
-        except Exception as e:
-            raise CoroutineExecutionError(
-                f"Failed to execute coroutine: {str(e)}"
-            ) from e
-
-    if threading.current_thread() is threading.main_thread():
-        if not loop.is_running():
-            try:
-                return loop.run_until_complete(
-                    asyncio.wait_for(coroutine, timeout=timeout)
-                )
-            except Exception as e:
-                raise CoroutineExecutionError(
-                    f"Failed to execute coroutine in main loop: {str(e)}"
-                ) from e
-        else:
-            with ThreadPoolExecutor() as pool:
-                try:
-                    future = pool.submit(run_in_new_loop)
-                    return future.result(timeout=timeout)
-                except Exception as e:
-                    raise CoroutineExecutionError(
-                        f"Failed to execute coroutine in thread: {str(e)}"
-                    ) from e
-    else:
-        try:
-            future = asyncio.run_coroutine_threadsafe(coroutine, loop)
-            return future.result(timeout=timeout)
-        except Exception as e:
-            raise CoroutineExecutionError(
-                f"Failed to execute coroutine threadsafe: {str(e)}"
-            ) from e
-
-
-class SyncToAsyncGeneratorWrapper:
-    """
-    A wrapper for synchronous generators to be used in an async context.
-    """
-
-    def __init__(self, gen):
-        self._gen = gen
-        self._closed = False
-        # Prime the generator to ready for first send/next call
-        try:
-            is_not_primed = inspect.getgeneratorstate(self._gen) is inspect.GEN_CREATED
-        except AttributeError as e:
-            raise TypeError(
-                "The provided generator is not a valid generator object"
-            ) from e
-        if is_not_primed:
-            try:
-                next(self._gen)
-            except StopIteration:
-                self._closed = True
-            except Exception as e:
-                raise RuntimeError(f"Failed to prime generator: {e}") from e
-
-    async def asend(self, value):
-        if self._closed:
-            raise StopAsyncIteration("Generator is closed")
-        try:
-            return await asyncio.to_thread(self._gen.send, value)
-        except StopIteration as e:
-            self._closed = True
-            raise StopAsyncIteration("Generator is closed") from e
-        except Exception as e:
-            raise RuntimeError(f"Error while sending value to generator: {e}") from e
-
-    async def __anext__(self):
-        if self._closed:
-            raise StopAsyncIteration("Generator is closed")
-        try:
-            return await asyncio.to_thread(self._gen.__next__)
-        except StopIteration as e:
-            self._closed = True
-            raise StopAsyncIteration("Generator is closed") from e
-        except Exception as e:
-            raise RuntimeError(
-                f"Error while getting next value from generator: {e}"
-            ) from e
-
-    async def aclose(self):
-        if self._closed:
-            return
-        try:
-            await asyncio.to_thread(self._gen.close)
-        except Exception as e:
-            raise RuntimeError(f"Error while closing generator: {e}") from e
-        finally:
-            self._closed = True
-
-    def __aiter__(self):
-        return self
-
-    def __getattr__(self, name):
-        return getattr(self._gen, name)
+"""
+Backwards-compatible re-exports from ezmsg.baseproc.util.asio.
+
+New code should import directly from ezmsg.baseproc instead.
+"""
+
+import warnings
+
+warnings.warn(
+    "Importing from 'ezmsg.sigproc.util.asio' is deprecated. Please import from 'ezmsg.baseproc.util.asio' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from ezmsg.baseproc.util.asio import (  # noqa: E402
+    CoroutineExecutionError,
+    SyncToAsyncGeneratorWrapper,
+    run_coroutine_sync,
+)
+
+__all__ = [
+    "CoroutineExecutionError",
+    "SyncToAsyncGeneratorWrapper",
+    "run_coroutine_sync",
+]

ezmsg/sigproc/util/axisarray_buffer.py

@@ -1,14 +1,13 @@
 import math
 import typing
 
-from array_api_compat import get_namespace
 import numpy as np
-from ezmsg.util.messages.axisarray import AxisArray, LinearAxis, CoordinateAxis
+from array_api_compat import get_namespace
+from ezmsg.util.messages.axisarray import AxisArray, CoordinateAxis, LinearAxis
 from ezmsg.util.messages.util import replace
 
 from .buffer import HybridBuffer
 
-
 Array = typing.TypeVar("Array")
 
 
@@ -68,9 +67,7 @@ class HybridAxisBuffer:
         if hasattr(first_axis, "data"):
             # Initialize a CoordinateAxis buffer
             if len(first_axis.data) > 1:
-                _axis_gain = (first_axis.data[-1] - first_axis.data[0]) / (
-                    len(first_axis.data) - 1
-                )
+                _axis_gain = (first_axis.data[-1] - first_axis.data[0]) / (len(first_axis.data) - 1)
             else:
                 _axis_gain = 1.0
             self._coords_gain_estimate = _axis_gain
@@ -107,8 +104,7 @@ class HybridAxisBuffer:
                 )
             if axis.gain != self._linear_axis.gain:
                 raise ValueError(
-                    f"Buffer initialized with gain={self._linear_axis.gain}, "
-                    f"but received gain={axis.gain}."
+                    f"Buffer initialized with gain={self._linear_axis.gain}, but received gain={axis.gain}."
                 )
             if self._linear_n_available + n_samples > self.capacity:
                 # Simulate overflow by advancing the offset and decreasing
@@ -117,16 +113,12 @@ class HybridAxisBuffer:
                 self.seek(n_to_discard)
             # Update the offset corresponding to the oldest sample in the buffer
             #  by anchoring on the new offset and accounting for the samples already available.
-            self._linear_axis.offset = (
-                axis.offset - self._linear_n_available * axis.gain
-            )
+            self._linear_axis.offset = axis.offset - self._linear_n_available * axis.gain
             self._linear_n_available += n_samples
 
     def peek(self, n_samples: int | None = None) -> LinearAxis | CoordinateAxis:
         if self._coords_buffer is not None:
-            return replace(
-                self._coords_template, data=self._coords_buffer.peek(n_samples)
-            )
+            return replace(self._coords_template, data=self._coords_buffer.peek(n_samples))
         else:
             # Return a shallow copy.
             return replace(self._linear_axis, offset=self._linear_axis.offset)
@@ -184,13 +176,9 @@ class HybridAxisBuffer:
         else:
             return None
 
-    def searchsorted(
-        self, values: typing.Union[float, Array], side: str = "left"
-    ) -> typing.Union[int, Array]:
+    def searchsorted(self, values: typing.Union[float, Array], side: str = "left") -> typing.Union[int, Array]:
         if self._coords_buffer is not None:
-            return self._coords_buffer.xp.searchsorted(
-                self._coords_buffer.peek(self.available()), values, side=side
-            )
+            return self._coords_buffer.xp.searchsorted(self._coords_buffer.peek(self.available()), values, side=side)
         else:
             if self.available() == 0:
                 if isinstance(values, float):
@@ -312,9 +300,7 @@ class HybridAxisArrayBuffer:
             axes={**self._template_msg.axes, self._axis: out_axis},
         )
 
-    def peek_axis(
-        self, n_samples: int | None = None
-    ) -> LinearAxis | CoordinateAxis | None:
+    def peek_axis(self, n_samples: int | None = None) -> LinearAxis | CoordinateAxis | None:
         """Retrieves the axis data without advancing the read head."""
         if self._data_buffer is None:
             return None
@@ -369,9 +355,7 @@ class HybridAxisArrayBuffer:
         """
         return self._axis_buffer.gain
 
-    def axis_searchsorted(
-        self, values: typing.Union[float, Array], side: str = "left"
-    ) -> typing.Union[int, Array]:
+    def axis_searchsorted(self, values: typing.Union[float, Array], side: str = "left") -> typing.Union[int, Array]:
         """
         Find the indices into which the given values would be inserted
         into the target axis data to maintain order.

ezmsg/sigproc/util/buffer.py

@@ -63,9 +63,7 @@ class HybridBuffer:
         self._buff_unread = 0  # Number of unread samples in the circular buffer
         self._buff_read = 0  # Tracks samples read and still in buffer
         self._deque_len = 0  # Number of unread samples in the deque
-        self._last_overflow = (
-            0  # Tracks the last overflow count, overwritten or skipped
-        )
+        self._last_overflow = 0  # Tracks the last overflow count, overwritten or skipped
         self._warned = False  # Tracks if we've warned already (for warn_once)
 
     @property
@@ -96,9 +94,7 @@ class HybridBuffer:
             block = block[:, self.xp.newaxis]
 
         if block.shape[1:] != other_shape:
-            raise ValueError(
-                f"Block shape {block.shape[1:]} does not match buffer's other_shape {other_shape}"
-            )
+            raise ValueError(f"Block shape {block.shape[1:]} does not match buffer's other_shape {other_shape}")
 
         # Most overflow strategies are handled during flush, but there are a couple
         # scenarios that can be evaluated on write to give immediate feedback.
@@ -117,8 +113,7 @@ class HybridBuffer:
         self._deque_len += block.shape[0]
 
         if self._update_strategy == "immediate" or (
-            self._update_strategy == "threshold"
-            and (0 < self._threshold <= self._deque_len)
+            self._update_strategy == "threshold" and (0 < self._threshold <= self._deque_len)
         ):
             self.flush()
 
@@ -128,9 +123,7 @@ class HybridBuffer:
         from the buffer.
         """
         if n_samples > self.available():
-            raise ValueError(
-                f"Requested {n_samples} samples, but only {self.available()} are available."
-            )
+            raise ValueError(f"Requested {n_samples} samples, but only {self.available()} are available.")
         n_overflow = 0
         if self._deque and (n_samples > self._buff_unread):
             # We would cause a flush, but would that cause an overflow?
@@ -161,14 +154,10 @@ class HybridBuffer:
         n_overflow = self._estimate_overflow(n_samples)
         if n_overflow > 0:
             first_read = self._buff_unread
-            if (n_overflow - first_read) < self.capacity or (
-                self._overflow_strategy == "drop"
-            ):
+            if (n_overflow - first_read) < self.capacity or (self._overflow_strategy == "drop"):
                 # We can prevent the overflow (or at least *some* if using "drop"
                 # strategy) by reading the samples in the buffer first to make room.
-                data = self.xp.empty(
-                    (n_samples, *self._buffer.shape[1:]), dtype=self._buffer.dtype
-                )
+                data = self.xp.empty((n_samples, *self._buffer.shape[1:]), dtype=self._buffer.dtype)
                 self.peek(first_read, out=data[:first_read])
                 offset += first_read
                 self.seek(first_read)
@@ -204,13 +193,9 @@ class HybridBuffer:
         if n_samples is None:
             n_samples = self.available()
         elif n_samples > self.available():
-            raise ValueError(
-                f"Requested to peek {n_samples} samples, but only {self.available()} are available."
-            )
+            raise ValueError(f"Requested to peek {n_samples} samples, but only {self.available()} are available.")
         if out is not None and out.shape[0] < n_samples:
-            raise ValueError(
-                f"Output array shape {out.shape} is smaller than requested {n_samples} samples."
-            )
+            raise ValueError(f"Output array shape {out.shape} is smaller than requested {n_samples} samples.")
 
         if n_samples == 0:
             return self._buffer[:0]
@@ -224,9 +209,7 @@ class HybridBuffer:
             out = (
                 out
                 if out is not None
-                else self.xp.empty(
-                    (n_samples, *self._buffer.shape[1:]), dtype=self._buffer.dtype
-                )
+                else self.xp.empty((n_samples, *self._buffer.shape[1:]), dtype=self._buffer.dtype)
             )
             out[:part1_len] = self._buffer[self._tail :]
             out[part1_len:] = self._buffer[:part2_len]
@@ -258,9 +241,7 @@ class HybridBuffer:
         if not allow_flush and idx >= self._buff_unread:
             # The requested sample is in the deque.
             idx -= self._buff_unread
-            deq_splits = self.xp.cumsum(
-                [0] + [_.shape[0] for _ in self._deque], dtype=int
-            )
+            deq_splits = self.xp.cumsum([0] + [_.shape[0] for _ in self._deque], dtype=int)
             arr_idx = self.xp.searchsorted(deq_splits, idx, side="right") - 1
             idx -= deq_splits[arr_idx]
             return self._deque[arr_idx][idx : idx + 1]
@@ -334,7 +315,8 @@ class HybridBuffer:
             if n_overflow > 0 and (not self._warn_once or not self._warned):
                 self._warned = True
                 warnings.warn(
-                    f"Buffer overflow: {n_new} samples received, but only {self._capacity - self._buff_unread} available. "
+                    f"Buffer overflow: {n_new} samples received, "
+                    f"but only {self._capacity - self._buff_unread} available. "
                     f"Overwriting {n_overflow} previous samples.",
                     RuntimeWarning,
                 )
@@ -347,10 +329,9 @@ class HybridBuffer:
                     break
                 n_to_copy = min(block.shape[0], samples_to_copy - copied_samples)
                 start_idx = block.shape[0] - n_to_copy
-                self._buffer[
-                    samples_to_copy - copied_samples - n_to_copy : samples_to_copy
-                    - copied_samples
-                ] = block[start_idx:]
+                self._buffer[samples_to_copy - copied_samples - n_to_copy : samples_to_copy - copied_samples] = block[
+                    start_idx:
+                ]
                 copied_samples += n_to_copy
 
             self._head = 0
@@ -362,9 +343,7 @@ class HybridBuffer:
         else:
             if n_overflow > 0:
                 if self._overflow_strategy == "raise":
-                    raise OverflowError(
-                        f"Buffer overflow: {n_new} samples received, but only {n_free} available."
-                    )
+                    raise OverflowError(f"Buffer overflow: {n_new} samples received, but only {n_free} available.")
                 elif self._overflow_strategy == "warn-overwrite":
                     if not self._warn_once or not self._warned:
                         self._warned = True
@@ -430,9 +409,7 @@ class HybridBuffer:
             return
 
         other_shape = self._buffer.shape[1:]
-        max_capacity = self._max_size / (
-            self._buffer.dtype.itemsize * math.prod(other_shape)
-        )
+        max_capacity = self._max_size / (self._buffer.dtype.itemsize * math.prod(other_shape))
         if min_capacity > max_capacity:
             raise OverflowError(
                 f"Cannot grow buffer to {min_capacity} samples, "
@@ -440,9 +417,7 @@ class HybridBuffer:
             )
 
         new_capacity = min(max_capacity, max(self._capacity * 2, min_capacity))
-        new_buffer = self.xp.empty(
-            (new_capacity, *other_shape), dtype=self._buffer.dtype
-        )
+        new_buffer = self.xp.empty((new_capacity, *other_shape), dtype=self._buffer.dtype)
 
         # Copy existing data to new buffer
         total_samples = self._buff_read + self._buff_unread

ezmsg/sigproc/util/message.py

@@ -1,31 +1,17 @@
-import time
-import typing
-from dataclasses import dataclass, field
-
-from ezmsg.util.messages.axisarray import AxisArray
-
-
-@dataclass(unsafe_hash=True)
-class SampleTriggerMessage:
-    timestamp: float = field(default_factory=time.time)
-    """Time of the trigger, in seconds. The Clock depends on the input but defaults to time.time"""
-
-    period: tuple[float, float] | None = None
-    """The period around the timestamp, in seconds"""
-
-    value: typing.Any = None
-    """A value or 'label' associated with the trigger."""
-
-
-@dataclass
-class SampleMessage:
-    trigger: SampleTriggerMessage
-    """The time, window, and value (if any) associated with the trigger."""
-
-    sample: AxisArray
-    """The data sampled around the trigger."""
-
-
-def is_sample_message(message: typing.Any) -> typing.TypeGuard[SampleMessage]:
-    """Check if the message is a SampleMessage."""
-    return hasattr(message, "trigger")
+"""
+Backwards-compatible re-exports from ezmsg.baseproc.util.message.
+
+New code should import directly from ezmsg.baseproc instead.
+"""
+
+from ezmsg.baseproc.util.message import (
+    SampleMessage,
+    SampleTriggerMessage,
+    is_sample_message,
+)
+
+__all__ = [
+    "SampleMessage",
+    "SampleTriggerMessage",
+    "is_sample_message",
+]