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

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

@@ -2,9 +2,7 @@ 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 +21,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 +66,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 +104,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,9 +1,9 @@
 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
 
@@ -12,7 +12,7 @@ from .base import (
     BaseTransformerUnit,
     processor_state,
 )
-from .filterbank import filterbank, FilterbankMode, MinPhaseMode
+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)

ezmsg/sigproc/window.py

@@ -5,12 +5,12 @@ import typing
 import ezmsg.core as ez
 import numpy.typing as npt
 import sparse
-from array_api_compat import is_pydata_sparse_namespace, get_namespace
+from array_api_compat import get_namespace, is_pydata_sparse_namespace
 from ezmsg.util.messages.axisarray import (
     AxisArray,
+    replace,
     slice_along_axis,
     sliding_win_oneaxis,
-    replace,
 )
 
 from .base import (
@@ -18,8 +18,8 @@ from .base import (
     BaseTransformerUnit,
     processor_state,
 )
-from .util.sparse import sliding_win_oneaxis as sparse_sliding_win_oneaxis
 from .util.profile import profile_subpub
+from .util.sparse import sliding_win_oneaxis as sparse_sliding_win_oneaxis
 
 
 class Anchor(enum.Enum):
@@ -55,9 +55,7 @@ class WindowState:
     out_dims: list[str] | None = None
 
 
-class WindowTransformer(
-    BaseStatefulTransformer[WindowSettings, AxisArray, AxisArray, WindowState]
-):
+class WindowTransformer(BaseStatefulTransformer[WindowSettings, AxisArray, AxisArray, WindowState]):
     """
     Apply a sliding window along the specified axis to input streaming data.
     The `windowing` method is perhaps the most useful and versatile method in ezmsg.sigproc, but its parameterization
@@ -99,19 +97,13 @@ class WindowTransformer(
         # if self.settings.newaxis is None:
         #     ez.logger.warning("`newaxis=None` will be replaced with `newaxis='win'`.")
         #     object.__setattr__(self.settings, "newaxis", "win")
-        if (
-            self.settings.window_shift is None
-            and self.settings.zero_pad_until != "input"
-        ):
+        if self.settings.window_shift is None and self.settings.zero_pad_until != "input":
             ez.logger.warning(
                 "`zero_pad_until` must be 'input' if `window_shift` is None. "
                 f"Ignoring received argument value: {self.settings.zero_pad_until}"
             )
             object.__setattr__(self.settings, "zero_pad_until", "input")
-        elif (
-            self.settings.window_shift is not None
-            and self.settings.zero_pad_until == "input"
-        ):
+        elif self.settings.window_shift is not None and self.settings.zero_pad_until == "input":
             ez.logger.warning(
                 "windowing is non-deterministic with `zero_pad_until='input'` as it depends on the size "
                 "of the first input. We recommend using `zero_pad_until='shift'` when `window_shift` is float-valued."
@@ -135,9 +127,7 @@ class WindowTransformer(
     def _reset_state(self, message: AxisArray) -> None:
         _newaxis = self.settings.newaxis or "win"
         if not self._state.newaxis_warned and _newaxis in message.dims:
-            ez.logger.warning(
-                f"newaxis {_newaxis} present in input dims. Using {_newaxis}_win instead"
-            )
+            ez.logger.warning(f"newaxis {_newaxis} present in input dims. Using {_newaxis}_win instead")
             self._state.newaxis_warned = True
             self.settings.newaxis = f"{_newaxis}_win"
 
@@ -154,33 +144,20 @@ class WindowTransformer(
             self._state.window_shift_samples = int(self.settings.window_shift * fs)
         if self.settings.zero_pad_until == "none":
             req_samples = self._state.window_samples
-        elif (
-            self.settings.zero_pad_until == "shift"
-            and self.settings.window_shift is not None
-        ):
+        elif self.settings.zero_pad_until == "shift" and self.settings.window_shift is not None:
             req_samples = self._state.window_shift_samples
         else:  # i.e. zero_pad_until == "input"
             req_samples = message.data.shape[axis_idx]
         n_zero = max(0, self._state.window_samples - req_samples)
-        init_buffer_shape = (
-            message.data.shape[:axis_idx]
-            + (n_zero,)
-            + message.data.shape[axis_idx + 1 :]
-        )
+        init_buffer_shape = message.data.shape[:axis_idx] + (n_zero,) + message.data.shape[axis_idx + 1 :]
         self._state.buffer = xp.zeros(init_buffer_shape, dtype=message.data.dtype)
 
         # Prepare reusable parts of output
         if self._state.out_newaxis is None:
-            self._state.out_dims = (
-                list(message.dims[:axis_idx])
-                + [_newaxis]
-                + list(message.dims[axis_idx:])
-            )
+            self._state.out_dims = list(message.dims[:axis_idx]) + [_newaxis] + list(message.dims[axis_idx:])
             self._state.out_newaxis = replace(
                 axis_info,
-                gain=0.0
-                if self.settings.window_shift is None
-                else axis_info.gain * self._state.window_shift_samples,
+                gain=0.0 if self.settings.window_shift is None else axis_info.gain * self._state.window_shift_samples,
                 offset=0.0,  # offset modified per-msg below
             )
 
@@ -204,9 +181,7 @@ class WindowTransformer(
         # is generally faster than np.roll and slicing anyway, but this could still
         # be a performance bottleneck for large memory arrays.
         # A circular buffer might be faster.
-        self._state.buffer = xp.concatenate(
-            (self._state.buffer, message.data), axis=axis_idx
-        )
+        self._state.buffer = xp.concatenate((self._state.buffer, message.data), axis=axis_idx)
 
         # Create a vector of buffer timestamps to track axis `offset` in output(s)
         buffer_t0 = 0.0
@@ -222,9 +197,7 @@ class WindowTransformer(
         if self.settings.window_shift is not None and self._state.shift_deficit > 0:
             n_skip = min(self._state.buffer.shape[axis_idx], self._state.shift_deficit)
             if n_skip > 0:
-                self._state.buffer = slice_along_axis(
-                    self._state.buffer, slice(n_skip, None), axis_idx
-                )
+                self._state.buffer = slice_along_axis(self._state.buffer, slice(n_skip, None), axis_idx)
                 buffer_t0 += n_skip * axis_info.gain
                 buffer_tlen -= n_skip
                 self._state.shift_deficit -= n_skip
@@ -249,20 +222,12 @@ class WindowTransformer(
                 self._state.buffer, slice(-self._state.window_samples, None), axis_idx
             )
             out_dat = self._state.buffer.reshape(
-                self._state.buffer.shape[:axis_idx]
-                + (1,)
-                + self._state.buffer.shape[axis_idx:]
-            )
-            win_offset = buffer_t0 + axis_info.gain * (
-                buffer_tlen - self._state.window_samples
+                self._state.buffer.shape[:axis_idx] + (1,) + self._state.buffer.shape[axis_idx:]
             )
+            win_offset = buffer_t0 + axis_info.gain * (buffer_tlen - self._state.window_samples)
         elif self._state.buffer.shape[axis_idx] >= self._state.window_samples:
             # Deterministic window shifts.
-            sliding_win_fun = (
-                sparse_sliding_win_oneaxis
-                if is_pydata_sparse_namespace(xp)
-                else sliding_win_oneaxis
-            )
+            sliding_win_fun = sparse_sliding_win_oneaxis if is_pydata_sparse_namespace(xp) else sliding_win_oneaxis
             out_dat = sliding_win_fun(
                 self._state.buffer,
                 self._state.window_samples,
@@ -273,18 +238,12 @@ class WindowTransformer(
 
             # Drop expired beginning of buffer and update shift_deficit
             multi_shift = self._state.window_shift_samples * out_dat.shape[axis_idx]
-            self._state.shift_deficit = max(
-                0, multi_shift - self._state.buffer.shape[axis_idx]
-            )
-            self._state.buffer = slice_along_axis(
-                self._state.buffer, slice(multi_shift, None), axis_idx
-            )
+            self._state.shift_deficit = max(0, multi_shift - self._state.buffer.shape[axis_idx])
+            self._state.buffer = slice_along_axis(self._state.buffer, slice(multi_shift, None), axis_idx)
         else:
             # Not enough data to make a new window. Return empty data.
             empty_data_shape = (
-                message.data.shape[:axis_idx]
-                + (0, self._state.window_samples)
-                + message.data.shape[axis_idx + 1 :]
+                message.data.shape[:axis_idx] + (0, self._state.window_samples) + message.data.shape[axis_idx + 1 :]
             )
             out_dat = xp.zeros(empty_data_shape, dtype=message.data.dtype)
             # out_newaxis will have first timestamp in input... but mostly meaningless because output is size-zero.
@@ -305,9 +264,7 @@ class WindowTransformer(
         return msg_out
 
 
-class Window(
-    BaseTransformerUnit[WindowSettings, AxisArray, AxisArray, WindowTransformer]
-):
+class Window(BaseTransformerUnit[WindowSettings, AxisArray, AxisArray, WindowTransformer]):
     SETTINGS = WindowSettings
     INPUT_SIGNAL = ez.InputStream(AxisArray)
     OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
@@ -325,30 +282,19 @@ class Window(
         try:
             ret = self.processor(message)
             if ret.data.size > 0:
-                if (
-                    self.SETTINGS.newaxis is not None
-                    or self.SETTINGS.window_dur is None
-                ):
+                if self.SETTINGS.newaxis is not None or self.SETTINGS.window_dur is None:
                     # Multi-win mode or pass-through mode.
                     yield self.OUTPUT_SIGNAL, ret
                 else:
                     # We need to split out_msg into multiple yields, dropping newaxis.
                     axis_idx = ret.get_axis_idx("win")
                     win_axis = ret.axes["win"]
-                    offsets = win_axis.value(
-                        xp.asarray(range(ret.data.shape[axis_idx]))
-                    )
+                    offsets = win_axis.value(xp.asarray(range(ret.data.shape[axis_idx])))
                     for msg_ix in range(ret.data.shape[axis_idx]):
                         # Need to drop 'win' and replace self.SETTINGS.axis from axes.
                         _out_axes = {
-                            **{
-                                k: v
-                                for k, v in ret.axes.items()
-                                if k not in ["win", self.SETTINGS.axis]
-                            },
-                            self.SETTINGS.axis: replace(
-                                ret.axes[self.SETTINGS.axis], offset=offsets[msg_ix]
-                            ),
+                            **{k: v for k, v in ret.axes.items() if k not in ["win", self.SETTINGS.axis]},
+                            self.SETTINGS.axis: replace(ret.axes[self.SETTINGS.axis], offset=offsets[msg_ix]),
                         }
                         _ret = replace(
                             ret,

{ezmsg_sigproc-2.4.1.dist-info → ezmsg_sigproc-2.6.0.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 2.4.1
+Version: 2.6.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>
+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
-License-File: LICENSE.txt
+License-File: LICENSE
 Requires-Python: >=3.10.15
 Requires-Dist: array-api-compat>=1.11.1
+Requires-Dist: ezmsg-baseproc>=1.0.3
 Requires-Dist: ezmsg>=3.6.0
 Requires-Dist: numba>=0.61.0
 Requires-Dist: numpy>=1.26.0