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

ezmsg/sigproc/util/buffer.py

@@ -1,3 +1,7 @@
+"""A stateful, FIFO buffer that combines a deque for fast appends with a
+contiguous circular buffer for efficient, advancing reads.
+"""
+
 import collections
 import math
 import typing
@@ -63,9 +67,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 +98,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 +117,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 +127,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 +158,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 +197,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 +213,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 +245,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 +319,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 +333,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 +347,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 +413,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 +421,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",
+]

ezmsg/sigproc/util/profile.py

@@ -1,174 +1,23 @@
-import functools
-import logging
-import os
-from pathlib import Path
-import time
-import typing
-
-import ezmsg.core as ez
-
-
-HEADER = "Time,Source,Topic,SampleTime,PerfCounter,Elapsed"
-
-
-def get_logger_path() -> Path:
-    # Retrieve the logfile name from the environment variable
-    logfile = os.environ.get("EZMSG_PROFILE", None)
-
-    # Determine the log file path, defaulting to "ezprofiler.log" if not set
-    logpath = Path(logfile or "ezprofiler.log")
-
-    # If the log path is not absolute, prepend it with the user's home directory and ".ezmsg/profile"
-    if not logpath.is_absolute():
-        logpath = Path.home() / ".ezmsg" / "profile" / logpath
-
-    return logpath
-
-
-def _setup_logger(append: bool = False) -> logging.Logger:
-    logpath = get_logger_path()
-    logpath.parent.mkdir(parents=True, exist_ok=True)
-
-    write_header = True
-    if logpath.exists() and logpath.is_file():
-        if append:
-            with open(logpath) as f:
-                first_line = f.readline().rstrip()
-            if first_line == HEADER:
-                write_header = False
-            else:
-                # Remove the file if appending, but headers do not match
-                ezmsg_logger = logging.getLogger("ezmsg")
-                ezmsg_logger.warning(
-                    "Profiling header mismatch: please make sure to use the same version of ezmsg for all processes."
-                )
-                logpath.unlink()
-        else:
-            # Remove the file if not appending
-            logpath.unlink()
-
-    # Create a logger with the name "ezprofile"
-    _logger = logging.getLogger("ezprofile")
-
-    # Set the logger's level to EZMSG_LOGLEVEL env var value if it exists, otherwise INFO
-    _logger.setLevel(os.environ.get("EZMSG_LOGLEVEL", "INFO").upper())
-
-    # Create a file handler to write log messages to the log file
-    fh = logging.FileHandler(logpath)
-    fh.setLevel(logging.DEBUG)  # Set the file handler log level to DEBUG
-
-    # Add the file handler to the logger
-    _logger.addHandler(fh)
-
-    # Add the header if writing to new file or if header matched header in file.
-    if write_header:
-        _logger.debug(HEADER)
-
-    # Set the log message format
-    formatter = logging.Formatter(
-        "%(asctime)s,%(message)s", datefmt="%Y-%m-%dT%H:%M:%S%z"
-    )
-    fh.setFormatter(formatter)
-
-    return _logger
-
-
-logger = _setup_logger(append=True)
-
-
-def _process_obj(obj, trace_oldest: bool = True):
-    samp_time = None
-    if hasattr(obj, "axes") and ("time" in obj.axes or "win" in obj.axes):
-        axis = "win" if "win" in obj.axes else "time"
-        ax = obj.get_axis(axis)
-        len = obj.data.shape[obj.get_axis_idx(axis)]
-        if len > 0:
-            idx = 0 if trace_oldest else (len - 1)
-            if hasattr(ax, "data"):
-                samp_time = ax.data[idx]
-            else:
-                samp_time = ax.value(idx)
-            if ax == "win" and "time" in obj.axes:
-                if hasattr(obj.axes["time"], "data"):
-                    samp_time += obj.axes["time"].data[idx]
-                else:
-                    samp_time += obj.axes["time"].value(idx)
-    return samp_time
-
-
-def profile_method(trace_oldest: bool = True):
-    """
-    Decorator to profile a method by logging its execution time and other details.
-
-    Args:
-        trace_oldest (bool): If True, trace the oldest sample time; otherwise, trace the newest.
-
-    Returns:
-        Callable: The decorated function with profiling.
-    """
-
-    def profiling_decorator(func: typing.Callable):
-        @functools.wraps(func)
-        def wrapped_func(caller, *args, **kwargs):
-            start = time.perf_counter()
-            res = func(caller, *args, **kwargs)
-            stop = time.perf_counter()
-            source = ".".join((caller.__class__.__module__, caller.__class__.__name__))
-            topic = f"{caller.address}"
-            samp_time = _process_obj(res, trace_oldest=trace_oldest)
-            logger.debug(
-                ",".join(
-                    [
-                        source,
-                        topic,
-                        f"{samp_time}",
-                        f"{stop}",
-                        f"{(stop - start) * 1e3:0.4f}",
-                    ]
-                )
-            )
-            return res
-
-        return wrapped_func if logger.level == logging.DEBUG else func
-
-    return profiling_decorator
-
-
-def profile_subpub(trace_oldest: bool = True):
-    """
-    Decorator to profile a subscriber-publisher method in an ezmsg Unit
-    by logging its execution time and other details.
-
-    Args:
-        trace_oldest (bool): If True, trace the oldest sample time; otherwise, trace the newest.
-
-    Returns:
-        Callable: The decorated async task with profiling.
-    """
-
-    def profiling_decorator(func: typing.Callable):
-        @functools.wraps(func)
-        async def wrapped_task(unit: ez.Unit, msg: typing.Any = None):
-            source = ".".join((unit.__class__.__module__, unit.__class__.__name__))
-            topic = f"{unit.address}"
-            start = time.perf_counter()
-            async for stream, obj in func(unit, msg):
-                stop = time.perf_counter()
-                samp_time = _process_obj(obj, trace_oldest=trace_oldest)
-                logger.debug(
-                    ",".join(
-                        [
-                            source,
-                            topic,
-                            f"{samp_time}",
-                            f"{stop}",
-                            f"{(stop - start) * 1e3:0.4f}",
-                        ]
-                    )
-                )
-                start = stop
-                yield stream, obj
-
-        return wrapped_task if logger.level == logging.DEBUG else func
-
-    return profiling_decorator
+"""
+Backwards-compatible re-exports from ezmsg.baseproc.util.profile.
+
+New code should import directly from ezmsg.baseproc instead.
+"""
+
+from ezmsg.baseproc.util.profile import (
+    HEADER,
+    _setup_logger,
+    get_logger_path,
+    logger,
+    profile_method,
+    profile_subpub,
+)
+
+__all__ = [
+    "HEADER",
+    "get_logger_path",
+    "logger",
+    "profile_method",
+    "profile_subpub",
+    "_setup_logger",
+]

ezmsg/sigproc/util/sparse.py

@@ -1,10 +1,10 @@
+"""Methods for sparse array signal processing operations."""
+
 import numpy as np
 import sparse
 
 
-def sliding_win_oneaxis_old(
-    s: sparse.SparseArray, nwin: int, axis: int, step: int = 1
-) -> sparse.SparseArray:
+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.
@@ -23,16 +23,12 @@ def sliding_win_oneaxis_old(
     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
-    ]
+    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:
+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:
@@ -72,9 +68,7 @@ def sliding_win_oneaxis(
     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
-        )
+        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)
@@ -112,9 +106,7 @@ def sliding_win_oneaxis(
         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
-        )
+        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)

ezmsg/sigproc/util/typeresolution.py

@@ -1,83 +1,17 @@
-from types import UnionType
-import typing
-from typing_extensions import get_original_bases
-
-
-def resolve_typevar(cls: type, target_typevar: typing.TypeVar) -> type:
-    """
-    Resolve the concrete type bound to a TypeVar in a class hierarchy.
-    This function traverses the method resolution order (MRO) of the class
-    and checks the original bases of each class in the MRO for the TypeVar.
-    If the TypeVar is found, it returns the concrete type bound to it.
-    If the TypeVar is not found, it raises a TypeError.
-    Args:
-        cls (type): The class to inspect.
-        target_typevar (typing.TypeVar): The TypeVar to resolve.
-    Returns:
-        type: The concrete type bound to the TypeVar.
-    """
-    for base in cls.__mro__:
-        orig_bases = get_original_bases(base)
-        for orig_base in orig_bases:
-            origin = typing.get_origin(orig_base)
-            if origin is None:
-                continue
-            params = getattr(origin, "__parameters__", ())
-            if not params:
-                continue
-            if target_typevar in params:
-                index = params.index(target_typevar)
-                args = typing.get_args(orig_base)
-                try:
-                    return args[index]
-                except IndexError:
-                    pass
-    raise TypeError(f"Could not resolve {target_typevar} in {cls}")
-
-
-TypeLike = typing.Union[type[typing.Any], typing.Any, type(None), None]
-
-
-def check_message_type_compatibility(type1: TypeLike, type2: TypeLike) -> bool:
-    """
-    Check if two types are compatible for message passing.
-    Returns True if:
-    - Both are None/NoneType
-    - Either is typing.Any
-    - type1 is a subclass of type2, which includes
-        - type1 and type2 are concrete types and type1 is a subclass of type2
-        - type1 is None/NoneType and type2 is typing.Optional, or
-        - type1 is subtype of the non-None inner type of type2 if type2 is Optional
-    - type1 is a Union/Optional type and all inner types are compatible with type2
-    Args:
-        type1: First type to compare
-        type2: Second type to compare
-    Returns:
-        bool: True if the types are compatible, False otherwise
-    """
-    # If either is Any, they are compatible
-    if type1 is typing.Any or type2 is typing.Any:
-        return True
-
-    # Handle None as NoneType
-    if type1 is None:
-        type1 = type(None)
-    if type2 is None:
-        type2 = type(None)
-
-    # Handle if type1 is Optional/Union type
-    if typing.get_origin(type1) in {typing.Union, UnionType}:
-        return all(
-            check_message_type_compatibility(inner_type, type2)
-            for inner_type in typing.get_args(type1)
-        )
-
-    # Regular issubclass check. Handles cases like:
-    # - type1 is a subclass of concrete type2
-    # - type1 is a subclass of the inner type of type2 if type2 is Optional
-    # - type1 is a subclass of one of the inner types of type2 if type2 is Union
-    # - type1 is NoneType and type2 is Optional or Union[None, ...] or Union[NoneType, ...]
-    try:
-        return issubclass(type1, type2)
-    except TypeError:
-        return False
+"""
+Backwards-compatible re-exports from ezmsg.baseproc.util.typeresolution.
+
+New code should import directly from ezmsg.baseproc instead.
+"""
+
+from ezmsg.baseproc.util.typeresolution import (
+    TypeLike,
+    check_message_type_compatibility,
+    resolve_typevar,
+)
+
+__all__ = [
+    "TypeLike",
+    "check_message_type_compatibility",
+    "resolve_typevar",
+]

ezmsg/sigproc/wavelets.py

@@ -1,18 +1,18 @@
 import typing
 
+import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
 import pywt
-import ezmsg.core as ez
-from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.messages.util import replace
-
-from .base import (
+from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
     processor_state,
 )
-from .filterbank import filterbank, FilterbankMode, MinPhaseMode
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
+from .filterbank import FilterbankMode, MinPhaseMode, filterbank
 
 
 class CWTSettings(ez.Settings):
@@ -37,9 +37,7 @@ class CWTState:
     last_conv_samp: npt.NDArray | None = None
 
 
-class CWTTransformer(
-    BaseStatefulTransformer[CWTSettings, AxisArray, AxisArray, CWTState]
-):
+class CWTTransformer(BaseStatefulTransformer[CWTSettings, AxisArray, AxisArray, CWTState]):
     def _hash_message(self, message: AxisArray) -> int:
         ax_idx = message.get_axis_idx(self.settings.axis)
         in_shape = message.data.shape[:ax_idx] + message.data.shape[ax_idx + 1 :]
@@ -107,25 +105,18 @@ class CWTTransformer(
         # Create output template
         ax_idx = message.get_axis_idx(self.settings.axis)
         in_shape = message.data.shape[:ax_idx] + message.data.shape[ax_idx + 1 :]
-        freqs = (
-            pywt.scale2frequency(wavelet, scales, precision)
-            / message.axes[self.settings.axis].gain
-        )
+        freqs = pywt.scale2frequency(wavelet, scales, precision) / message.axes[self.settings.axis].gain
         dummy_shape = in_shape + (len(scales), 0)
         self._state.template = AxisArray(
             np.zeros(dummy_shape, dtype=dt_cplx if wavelet.complex_cwt else dt_data),
-            dims=message.dims[:ax_idx]
-            + message.dims[ax_idx + 1 :]
-            + ["freq", self.settings.axis],
+            dims=message.dims[:ax_idx] + message.dims[ax_idx + 1 :] + ["freq", self.settings.axis],
             axes={
                 **message.axes,
                 "freq": AxisArray.CoordinateAxis(unit="Hz", data=freqs, dims=["freq"]),
             },
             key=message.key,
         )
-        self._state.last_conv_samp = np.zeros(
-            dummy_shape[:-1] + (1,), dtype=self._state.template.data.dtype
-        )
+        self._state.last_conv_samp = np.zeros(dummy_shape[:-1] + (1,), dtype=self._state.template.data.dtype)
 
     def _process(self, message: AxisArray) -> AxisArray:
         conv_msg = self._state.fbgen.send(message)