ezmsg-sigproc 2.11.0__py3-none-any.whl → 2.13.0__py3-none-any.whl

ezmsg/sigproc/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.11.0'
-__version_tuple__ = version_tuple = (2, 11, 0)
+__version__ = version = '2.13.0'
+__version_tuple__ = version_tuple = (2, 13, 0)
 
 __commit_id__ = commit_id = None

ezmsg/sigproc/affinetransform.py

@@ -14,9 +14,9 @@ from pathlib import Path
 import ezmsg.core as ez
 import numpy as np
 import numpy.typing as npt
+from array_api_compat import get_namespace
 from ezmsg.baseproc import (
     BaseStatefulTransformer,
-    BaseTransformer,
     BaseTransformerUnit,
     processor_state,
 )
@@ -24,6 +24,117 @@ from ezmsg.util.messages.axisarray import AxisArray, AxisBase
 from ezmsg.util.messages.util import replace
 
 
+def _find_block_diagonal_clusters(weights: np.ndarray) -> list[tuple[np.ndarray, np.ndarray]] | None:
+    """Detect block-diagonal structure in a weight matrix.
+
+    Finds connected components in the bipartite graph of non-zero weights,
+    where input channels and output channels are separate node sets.
+
+    Args:
+        weights: 2-D weight matrix of shape (n_in, n_out).
+
+    Returns:
+        List of (input_indices, output_indices) tuples, one per block, or
+        None if the matrix is not block-diagonal (single connected component).
+    """
+    if weights.ndim != 2:
+        return None
+
+    n_in, n_out = weights.shape
+    if n_in + n_out <= 2:
+        return None
+
+    from scipy.sparse import coo_matrix
+    from scipy.sparse.csgraph import connected_components
+
+    rows, cols = np.nonzero(weights)
+    if len(rows) == 0:
+        return None
+
+    # Bipartite graph: input nodes [0, n_in), output nodes [n_in, n_in + n_out)
+    shifted_cols = cols + n_in
+    adj_rows = np.concatenate([rows, shifted_cols])
+    adj_cols = np.concatenate([shifted_cols, rows])
+    adj_data = np.ones(len(adj_rows), dtype=bool)
+    n_nodes = n_in + n_out
+    adj = coo_matrix((adj_data, (adj_rows, adj_cols)), shape=(n_nodes, n_nodes))
+
+    n_components, labels = connected_components(adj, directed=False)
+
+    if n_components <= 1:
+        return None
+
+    clusters = []
+    for comp in range(n_components):
+        members = np.where(labels == comp)[0]
+        in_idx = np.sort(members[members < n_in])
+        out_idx = np.sort(members[members >= n_in] - n_in)
+        if len(in_idx) > 0 and len(out_idx) > 0:
+            clusters.append((in_idx, out_idx))
+
+    return clusters if len(clusters) > 1 else None
+
+
+def _max_cross_cluster_weight(weights: np.ndarray, clusters: list[tuple[np.ndarray, np.ndarray]]) -> float:
+    """Return the maximum absolute weight between different clusters."""
+    mask = np.zeros(weights.shape, dtype=bool)
+    for in_idx, out_idx in clusters:
+        mask[np.ix_(in_idx, out_idx)] = True
+    cross = np.abs(weights[~mask])
+    return float(cross.max()) if cross.size > 0 else 0.0
+
+
+def _merge_small_clusters(
+    clusters: list[tuple[np.ndarray, np.ndarray]], min_size: int
+) -> list[tuple[np.ndarray, np.ndarray]]:
+    """Merge clusters smaller than *min_size* into combined groups.
+
+    Small clusters are greedily concatenated until each merged group has
+    at least *min_size* channels (measured as ``max(n_in, n_out)``).
+    Any leftover small clusters that don't reach the threshold are
+    combined into a final group.
+
+    The merged group's sub-weight-matrix will contain the original small
+    diagonal blocks with zeros between them — a dense matmul on that
+    sub-matrix is cheaper than iterating over many tiny matmuls.
+    """
+    if min_size <= 1:
+        return clusters
+
+    large = []
+    small = []
+    for cluster in clusters:
+        in_idx, out_idx = cluster
+        if max(len(in_idx), len(out_idx)) >= min_size:
+            large.append(cluster)
+        else:
+            small.append(cluster)
+
+    if not small:
+        return clusters
+
+    current_in: list[np.ndarray] = []
+    current_out: list[np.ndarray] = []
+    current_in_size = 0
+    current_out_size = 0
+    for in_idx, out_idx in small:
+        current_in.append(in_idx)
+        current_out.append(out_idx)
+        current_in_size += len(in_idx)
+        current_out_size += len(out_idx)
+        if max(current_in_size, current_out_size) >= min_size:
+            large.append((np.sort(np.concatenate(current_in)), np.sort(np.concatenate(current_out))))
+            current_in = []
+            current_out = []
+            current_in_size = 0
+            current_out_size = 0
+
+    if current_in:
+        large.append((np.sort(np.concatenate(current_in)), np.sort(np.concatenate(current_out))))
+
+    return large
+
+
 class AffineTransformSettings(ez.Settings):
     """
     Settings for :obj:`AffineTransform`.
@@ -38,11 +149,32 @@ class AffineTransformSettings(ez.Settings):
     right_multiply: bool = True
     """Set False to transpose the weights before applying."""
 
+    channel_clusters: list[list[int]] | None = None
+    """Optional explicit input channel cluster specification for block-diagonal optimization.
+
+    Each element is a list of input channel indices forming one cluster. The
+    corresponding output indices are derived automatically from the non-zero
+    columns of the weight matrix for those input rows.
+
+    When provided, the weight matrix is decomposed into per-cluster sub-matrices
+    and multiplied separately, which is faster when cross-cluster weights are zero.
+
+    If None, block-diagonal structure is auto-detected from the zero pattern
+    of the weights."""
+
+    min_cluster_size: int = 32
+    """Minimum number of channels per cluster for the block-diagonal optimization.
+    Clusters smaller than this are greedily merged together to avoid excessive
+    Python loop overhead. Set to 1 to disable merging."""
+
 
 @processor_state
 class AffineTransformState:
     weights: npt.NDArray | None = None
     new_axis: AxisBase | None = None
+    n_out: int = 0
+    clusters: list | None = None
+    """list of (in_indices_xp, out_indices_xp, sub_weights_xp) tuples when block-diagonal."""
 
 
 class AffineTransformTransformer(
@@ -85,11 +217,60 @@ class AffineTransformTransformer(
 
         self._state.weights = weights
 
+        # Note: If weights were scipy.sparse BSR then maybe we could use automate this next part.
+        #  However, that would break compatibility with Array API.
+
+        # --- Block-diagonal cluster detection ---
+        # Clusters are a list of (input_indices, output_indices) tuples.
+        n_in, n_out = weights.shape
+        if self.settings.channel_clusters is not None:
+            # Validate input index bounds
+            all_in = np.concatenate([np.asarray(group) for group in self.settings.channel_clusters])
+            if np.any((all_in < 0) | (all_in >= n_in)):
+                raise ValueError(
+                    "channel_clusters contains out-of-range input indices " f"(valid range: 0..{n_in - 1})"
+                )
+
+            # Derive output indices from non-zero weights for each input cluster
+            clusters = []
+            for group in self.settings.channel_clusters:
+                in_idx = np.asarray(group)
+                out_idx = np.where(np.any(weights[in_idx, :] != 0, axis=0))[0]
+                clusters.append((in_idx, out_idx))
+
+            max_cross = _max_cross_cluster_weight(weights, clusters)
+            if max_cross > 0:
+                ez.logger.warning(
+                    f"Non-zero cross-cluster weights detected (max abs: {max_cross:.2e}). "
+                    "These will be ignored in block-diagonal multiplication."
+                )
+        else:
+            clusters = _find_block_diagonal_clusters(weights)
+            if clusters is not None:
+                ez.logger.info(
+                    f"Auto-detected {len(clusters)} block-diagonal clusters "
+                    f"(sizes: {[(len(i), len(o)) for i, o in clusters]})"
+                )
+
+        # Merge small clusters to avoid excessive loop overhead
+        if clusters is not None:
+            clusters = _merge_small_clusters(clusters, self.settings.min_cluster_size)
+
+        if clusters is not None and len(clusters) > 1:
+            self._state.n_out = n_out
+            self._state.clusters = [
+                (in_idx, out_idx, np.ascontiguousarray(weights[np.ix_(in_idx, out_idx)]))
+                for in_idx, out_idx in clusters
+            ]
+            self._state.weights = None
+        else:
+            self._state.clusters = None
+
+        # --- Axis label handling (for non-square transforms, non-cluster path) ---
         axis = self.settings.axis or message.dims[-1]
-        if axis in message.axes and hasattr(message.axes[axis], "data") and weights.shape[0] != weights.shape[1]:
+        if axis in message.axes and hasattr(message.axes[axis], "data") and n_in != n_out:
             in_labels = message.axes[axis].data
             new_labels = []
-            n_in, n_out = weights.shape
             if len(in_labels) != n_in:
                 ez.logger.warning(f"Received {len(in_labels)} for {n_in} inputs. Check upstream labels.")
             else:
@@ -111,23 +292,70 @@ class AffineTransformTransformer(
 
             self._state.new_axis = replace(message.axes[axis], data=np.array(new_labels))
 
+        # Convert to match message.data namespace for efficient operations in _process
+        xp = get_namespace(message.data)
+        if self._state.weights is not None:
+            self._state.weights = xp.asarray(self._state.weights)
+        if self._state.clusters is not None:
+            self._state.clusters = [
+                (xp.asarray(in_idx), xp.asarray(out_idx), xp.asarray(sub_w))
+                for in_idx, out_idx, sub_w in self._state.clusters
+            ]
+
+    def _block_diagonal_matmul(self, xp, data, axis_idx):
+        """Perform matmul using block-diagonal decomposition.
+
+        For each cluster, gathers input channels via ``xp.take``, performs a
+        matmul with the cluster's sub-weight matrix, and writes the result
+        directly into the pre-allocated output at the cluster's output indices.
+        Omitted output channels naturally remain zero.
+        """
+        needs_permute = axis_idx not in [-1, data.ndim - 1]
+        if needs_permute:
+            dim_perm = list(range(data.ndim))
+            dim_perm.append(dim_perm.pop(axis_idx))
+            data = xp.permute_dims(data, dim_perm)
+
+        # Pre-allocate output (omitted channels stay zero)
+        out_shape = data.shape[:-1] + (self._state.n_out,)
+        result = xp.zeros(out_shape, dtype=data.dtype)
+
+        for in_idx, out_idx, sub_weights in self._state.clusters:
+            chunk = xp.take(data, in_idx, axis=data.ndim - 1)
+            result[..., out_idx] = xp.matmul(chunk, sub_weights)
+
+        if needs_permute:
+            inv_dim_perm = list(range(result.ndim))
+            inv_dim_perm.insert(axis_idx, inv_dim_perm.pop(-1))
+            result = xp.permute_dims(result, inv_dim_perm)
+
+        return result
+
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
         axis = self.settings.axis or message.dims[-1]
         axis_idx = message.get_axis_idx(axis)
         data = message.data
 
-        if data.shape[axis_idx] == (self._state.weights.shape[0] - 1):
-            # The weights are stacked A|B where A is the transform and B is a single row
-            #  in the equation y = Ax + B. This supports NeuroKey's weights matrices.
-            sample_shape = data.shape[:axis_idx] + (1,) + data.shape[axis_idx + 1 :]
-            data = np.concatenate((data, np.ones(sample_shape).astype(data.dtype)), axis=axis_idx)
-
-        if axis_idx in [-1, len(message.dims) - 1]:
-            data = np.matmul(data, self._state.weights)
+        if self._state.clusters is not None:
+            data = self._block_diagonal_matmul(xp, data, axis_idx)
         else:
-            data = np.moveaxis(data, axis_idx, -1)
-            data = np.matmul(data, self._state.weights)
-            data = np.moveaxis(data, -1, axis_idx)
+            if data.shape[axis_idx] == (self._state.weights.shape[0] - 1):
+                # The weights are stacked A|B where A is the transform and B is a single row
+                #  in the equation y = Ax + B. This supports NeuroKey's weights matrices.
+                sample_shape = data.shape[:axis_idx] + (1,) + data.shape[axis_idx + 1 :]
+                data = xp.concat((data, xp.ones(sample_shape, dtype=data.dtype)), axis=axis_idx)
+
+            if axis_idx in [-1, len(message.dims) - 1]:
+                data = xp.matmul(data, self._state.weights)
+            else:
+                perm = list(range(data.ndim))
+                perm.append(perm.pop(axis_idx))
+                data = xp.permute_dims(data, perm)
+                data = xp.matmul(data, self._state.weights)
+                inv_perm = list(range(data.ndim))
+                inv_perm.insert(axis_idx, inv_perm.pop(-1))
+                data = xp.permute_dims(data, inv_perm)
 
         replace_kwargs = {"data": data}
         if self._state.new_axis is not None:
@@ -144,6 +372,8 @@ def affine_transform(
     weights: np.ndarray | str | Path,
     axis: str | None = None,
     right_multiply: bool = True,
+    channel_clusters: list[list[int]] | None = None,
+    min_cluster_size: int = 32,
 ) -> AffineTransformTransformer:
     """
     Perform affine transformations on streaming data.
@@ -152,19 +382,25 @@ def affine_transform(
         weights: An array of weights or a path to a file with weights compatible with np.loadtxt.
         axis: The name of the axis to apply the transformation to. Defaults to the leading (0th) axis in the array.
         right_multiply: Set False to transpose the weights before applying.
+        channel_clusters: Optional explicit channel cluster specification. See
+            :attr:`AffineTransformSettings.channel_clusters`.
+        min_cluster_size: Minimum channels per cluster; smaller clusters are merged. See
+            :attr:`AffineTransformSettings.min_cluster_size`.
 
     Returns:
         :obj:`AffineTransformTransformer`.
     """
     return AffineTransformTransformer(
-        AffineTransformSettings(weights=weights, axis=axis, right_multiply=right_multiply)
+        AffineTransformSettings(
+            weights=weights,
+            axis=axis,
+            right_multiply=right_multiply,
+            channel_clusters=channel_clusters,
+            min_cluster_size=min_cluster_size,
+        )
     )
 
 
-def zeros_for_noop(data: npt.NDArray, **ignore_kwargs) -> npt.NDArray:
-    return np.zeros_like(data)
-
-
 class CommonRereferenceSettings(ez.Settings):
     """
     Settings for :obj:`CommonRereference`
@@ -179,35 +415,64 @@ class CommonRereferenceSettings(ez.Settings):
     include_current: bool = True
     """Set False to exclude each channel from participating in the calculation of its reference."""
 
+    channel_clusters: list[list[int]] | None = None
+    """Optional channel clusters for per-cluster rereferencing. Each element is a
+    list of channel indices forming one cluster. The common reference is computed
+    independently within each cluster. If None, all channels form a single cluster."""
+
+
+@processor_state
+class CommonRereferenceState:
+    clusters: list | None = None
+    """list of xp arrays of channel indices, one per cluster."""
+
+
+class CommonRereferenceTransformer(
+    BaseStatefulTransformer[CommonRereferenceSettings, AxisArray, AxisArray, CommonRereferenceState]
+):
+    def _hash_message(self, message: AxisArray) -> int:
+        axis = self.settings.axis or message.dims[-1]
+        axis_idx = message.get_axis_idx(axis)
+        return hash((message.key, message.data.shape[axis_idx]))
+
+    def _reset_state(self, message: AxisArray) -> None:
+        xp = get_namespace(message.data)
+        axis = self.settings.axis or message.dims[-1]
+        axis_idx = message.get_axis_idx(axis)
+        n_chans = message.data.shape[axis_idx]
+
+        if self.settings.channel_clusters is not None:
+            self._state.clusters = [xp.asarray(group) for group in self.settings.channel_clusters]
+        else:
+            self._state.clusters = [xp.arange(n_chans)]
 
-class CommonRereferenceTransformer(BaseTransformer[CommonRereferenceSettings, AxisArray, AxisArray]):
     def _process(self, message: AxisArray) -> AxisArray:
         if self.settings.mode == "passthrough":
             return message
 
+        xp = get_namespace(message.data)
         axis = self.settings.axis or message.dims[-1]
         axis_idx = message.get_axis_idx(axis)
+        func = {"mean": xp.mean, "median": np.median}[self.settings.mode]
 
-        func = {"mean": np.mean, "median": np.median, "passthrough": zeros_for_noop}[self.settings.mode]
+        # Use result_type to match dtype promotion from data - float operations.
+        out_dtype = np.result_type(message.data.dtype, np.float64)
+        output = xp.zeros(message.data.shape, dtype=out_dtype)
 
-        ref_data = func(message.data, axis=axis_idx, keepdims=True)
+        for cluster_idx in self._state.clusters:
+            cluster_data = xp.take(message.data, cluster_idx, axis=axis_idx)
+            ref_data = func(cluster_data, axis=axis_idx, keepdims=True)
 
-        if not self.settings.include_current:
-            # Typical `CAR = x[0]/N + x[1]/N + ... x[i-1]/N + x[i]/N + x[i+1]/N + ... + x[N-1]/N`
-            # and is the same for all i, so it is calculated only once in `ref_data`.
-            # However, if we had excluded the current channel,
-            # then we would have omitted the contribution of the current channel:
-            # `CAR[i] = x[0]/(N-1) + x[1]/(N-1) + ... x[i-1]/(N-1) + x[i+1]/(N-1) + ... + x[N-1]/(N-1)`
-            # The majority of the calculation is the same as when the current channel is included;
-            # we need only rescale CAR so the divisor is `N-1` instead of `N`, then subtract the contribution
-            # from the current channel (i.e., `x[i] / (N-1)`)
-            #  i.e., `CAR[i] = (N / (N-1)) * common_CAR - x[i]/(N-1)`
-            # We can use broadcasting subtraction instead of looping over channels.
-            N = message.data.shape[axis_idx]
-            ref_data = (N / (N - 1)) * ref_data - message.data / (N - 1)
-            # Note: I profiled using AffineTransformTransformer; it's ~30x slower than this implementation.
+            if not self.settings.include_current:
+                N = cluster_data.shape[axis_idx]
+                ref_data = (N / (N - 1)) * ref_data - cluster_data / (N - 1)
 
-        return replace(message, data=message.data - ref_data)
+            # Write per-cluster result into output at the correct axis position
+            idx = [slice(None)] * output.ndim
+            idx[axis_idx] = cluster_idx
+            output[tuple(idx)] = cluster_data - ref_data
+
+        return replace(message, data=output)
 
 
 class CommonRereference(
@@ -217,19 +482,26 @@ class CommonRereference(
 
 
 def common_rereference(
-    mode: str = "mean", axis: str | None = None, include_current: bool = True
+    mode: str = "mean",
+    axis: str | None = None,
+    include_current: bool = True,
+    channel_clusters: list[list[int]] | None = None,
 ) -> CommonRereferenceTransformer:
     """
     Perform common average referencing (CAR) on streaming data.
 
     Args:
         mode: The statistical mode to apply -- either "mean" or "median"
-        axis: The name of hte axis to apply the transformation to.
+        axis: The name of the axis to apply the transformation to.
         include_current: Set False to exclude each channel from participating in the calculation of its reference.
+        channel_clusters: Optional channel clusters for per-cluster rereferencing. See
+            :attr:`CommonRereferenceSettings.channel_clusters`.
 
     Returns:
         :obj:`CommonRereferenceTransformer`
     """
     return CommonRereferenceTransformer(
-        CommonRereferenceSettings(mode=mode, axis=axis, include_current=include_current)
+        CommonRereferenceSettings(
+            mode=mode, axis=axis, include_current=include_current, channel_clusters=channel_clusters
+        )
     )

ezmsg/sigproc/merge.py

@@ -0,0 +1,358 @@
+"""Time-aligned merge of two AxisArray streams along a non-time axis."""
+
+from __future__ import annotations
+
+import typing
+
+import ezmsg.core as ez
+import numpy as np
+from array_api_compat import get_namespace
+from ezmsg.baseproc.protocols import processor_state
+from ezmsg.baseproc.stateful import BaseStatefulTransformer
+from ezmsg.baseproc.units import BaseProcessorUnit
+from ezmsg.util.messages.axisarray import AxisArray, CoordinateAxis
+from ezmsg.util.messages.util import replace
+
+from .util.axisarray_buffer import HybridAxisArrayBuffer
+
+
+class MergeSettings(ez.Settings):
+    axis: str = "ch"
+    """Axis along which to concatenate the two signals."""
+
+    align_axis: str | None = "time"
+    """Axis used for alignment. If None, defaults to the first dimension."""
+
+    buffer_dur: float = 10.0
+    """Buffer duration in seconds for each input stream."""
+
+    relabel_axis: bool = True
+    """Whether to relabel coordinate axis labels to ensure uniqueness."""
+
+    label_a: str = "_a"
+    """Suffix appended to signal A labels when relabel_axis is True."""
+
+    label_b: str = "_b"
+    """Suffix appended to signal B labels when relabel_axis is True."""
+
+    new_key: str | None = None
+    """Output AxisArray key. If None, uses the key from signal A."""
+
+
+@processor_state
+class MergeState:
+    # Common state
+    gain: float | None = None
+    align_axis: str | None = None
+    aligned: bool = False
+    merged_concat_axis: CoordinateAxis | None = None
+
+    # A state
+    buf_a: HybridAxisArrayBuffer | None = None
+    concat_axis_a: CoordinateAxis | None = None
+    a_concat_dim: int | None = None
+    a_other_dims: tuple[int, ...] | None = None
+
+    # B state
+    buf_b: HybridAxisArrayBuffer | None = None
+    concat_axis_b: CoordinateAxis | None = None
+    b_concat_dim: int | None = None
+    b_other_dims: tuple[int, ...] | None = None
+
+
+class MergeProcessor(BaseStatefulTransformer[MergeSettings, AxisArray, AxisArray | None, MergeState]):
+    """Processor that time-aligns two AxisArray streams and concatenates them.
+
+    Input A flows through the standard ``__call__`` / ``_process`` path,
+    getting automatic ``_hash_message`` / ``_reset_state`` handling from
+    :class:`BaseStatefulTransformer`.  Input B flows through :meth:`push_b`,
+    which independently tracks its own structure.
+
+    Invalidation rules:
+
+    - Gain mismatch (either input vs stored common gain) → full reset.
+    - Concat-axis dimensionality change → per-input buffer reset +
+      alignment and merged-axis cache invalidation.
+    - Non-align/non-concat axis shape change → per-input buffer reset +
+      alignment invalidation.
+    """
+
+    # -- Structural extraction helpers ---------------------------------------
+
+    def _extract_gain(self, message: AxisArray) -> float | None:
+        """Extract the align-axis gain from a message."""
+        align_name = self.settings.align_axis or message.dims[0]
+        ax = message.axes.get(align_name)
+        if ax is not None and hasattr(ax, "gain"):
+            return ax.gain
+        if ax is not None and hasattr(ax, "data") and len(ax.data) > 1:
+            return float(ax.data[-1] - ax.data[0]) / (len(ax.data) - 1)
+        return None
+
+    # -- Reset helpers -------------------------------------------------------
+
+    def _full_reset(self, align_axis: str) -> None:
+        """Reset all state — both inputs and common merge state."""
+        self._state.align_axis = align_axis
+        self._state.buf_a = HybridAxisArrayBuffer(duration=self.settings.buffer_dur, axis=align_axis)
+        self._state.buf_b = HybridAxisArrayBuffer(duration=self.settings.buffer_dur, axis=align_axis)
+        self._state.gain = None
+        self._state.aligned = False
+        self._state.concat_axis_a = None
+        self._state.concat_axis_b = None
+        self._state.merged_concat_axis = None
+        self._state.a_concat_dim = None
+        self._state.a_other_dims = None
+        self._state.b_concat_dim = None
+        self._state.b_other_dims = None
+
+    def _reset_a_state(self) -> None:
+        """Reset input-A buffer and concat-axis cache."""
+        self._state.buf_a = HybridAxisArrayBuffer(duration=self.settings.buffer_dur, axis=self._state.align_axis)
+        self._state.concat_axis_a = None
+
+    def _reset_b_state(self) -> None:
+        """Reset input-B buffer and concat-axis cache."""
+        self._state.buf_b = HybridAxisArrayBuffer(duration=self.settings.buffer_dur, axis=self._state.align_axis)
+        self._state.concat_axis_b = None
+
+    # -- BaseStatefulTransformer interface ------------------------------------
+
+    def _hash_message(self, message: AxisArray) -> int:
+        """Hash the align-axis gain only.
+
+        Gain changes trigger a full reset via ``_reset_state``.  Concat-axis
+        and non-merge dimension changes are handled as partial resets inside
+        ``_process`` and ``push_b``.
+        """
+        return hash(self._extract_gain(message))
+
+    def _reset_state(self, message: AxisArray) -> None:
+        """Full reset — called by the base class when gain changes."""
+        align_axis = self.settings.align_axis or message.dims[0]
+        self._full_reset(align_axis)
+
+    def _process(self, message: AxisArray) -> AxisArray | None:
+        """Process input A: detect structural changes, buffer, try merge."""
+        # Detect per-input structural changes.
+        align_idx = message.dims.index(self._state.align_axis)
+        concat_idx = message.dims.index(self.settings.axis) if self.settings.axis in message.dims else None
+        concat_dim = message.data.shape[concat_idx] if concat_idx is not None else None
+        other_dims = tuple(s for i, s in enumerate(message.data.shape) if i != align_idx and i != concat_idx)
+
+        if self._state.a_concat_dim is not None and concat_dim != self._state.a_concat_dim:
+            self._reset_a_state()
+            self._state.aligned = False
+            self._state.merged_concat_axis = None
+        elif self._state.a_other_dims is not None and other_dims != self._state.a_other_dims:
+            self._reset_a_state()
+            self._state.aligned = False
+
+        self._state.a_concat_dim = concat_dim
+        self._state.a_other_dims = other_dims
+
+        self._state.buf_a.write(message)
+        if self._state.gain is None:
+            self._state.gain = self._state.buf_a.axis_gain
+        self._update_concat_axis(message, "a")
+        return self._try_merge()
+
+    # -- Input B entry point ------------------------------------------------
+
+    def push_b(self, message: AxisArray) -> AxisArray | None:
+        """Process input B: check gain, detect structural changes, buffer, try merge."""
+        align_axis = self.settings.align_axis or message.dims[0]
+
+        # Gain compatibility check.
+        b_gain = self._extract_gain(message)
+        if self._state.gain is not None and b_gain != self._state.gain:
+            self._full_reset(align_axis)
+            # Set the base-class hash so the next compatible A goes straight
+            # to _process instead of triggering another full reset.
+            self._hash = self._hash_message(message)
+
+        # Lazy-create buf_b if B arrives before A.
+        if self._state.buf_b is None:
+            if self._state.align_axis is None:
+                self._state.align_axis = align_axis
+            self._state.buf_b = HybridAxisArrayBuffer(duration=self.settings.buffer_dur, axis=align_axis)
+
+        # Detect per-input structural changes.
+        align_idx = message.dims.index(align_axis)
+        concat_idx = message.dims.index(self.settings.axis) if self.settings.axis in message.dims else None
+        concat_dim = message.data.shape[concat_idx] if concat_idx is not None else None
+        other_dims = tuple(s for i, s in enumerate(message.data.shape) if i != align_idx and i != concat_idx)
+
+        if self._state.b_concat_dim is not None and concat_dim != self._state.b_concat_dim:
+            self._reset_b_state()
+            self._state.aligned = False
+            self._state.merged_concat_axis = None
+        elif self._state.b_other_dims is not None and other_dims != self._state.b_other_dims:
+            self._reset_b_state()
+            self._state.aligned = False
+
+        self._state.b_concat_dim = concat_dim
+        self._state.b_other_dims = other_dims
+
+        self._state.buf_b.write(message)
+        if self._state.gain is None:
+            self._state.gain = self._state.buf_b.axis_gain
+        self._update_concat_axis(message, "b")
+        return self._try_merge()
+
+    # -- Concat-axis caching ------------------------------------------------
+
+    def _update_concat_axis(self, message: AxisArray, which: str) -> None:
+        """Track each input's concat-axis labels; invalidate cache on change."""
+        concat_dim = self.settings.axis
+        if concat_dim not in message.axes:
+            return
+        ax = message.axes[concat_dim]
+        if not hasattr(ax, "data"):
+            return
+
+        if which == "a":
+            if self._state.concat_axis_a is None or not np.array_equal(self._state.concat_axis_a.data, ax.data):
+                self._state.concat_axis_a = ax
+                self._state.merged_concat_axis = None
+        else:
+            if self._state.concat_axis_b is None or not np.array_equal(self._state.concat_axis_b.data, ax.data):
+                self._state.concat_axis_b = ax
+                self._state.merged_concat_axis = None
+
+    def _build_merged_concat_axis(self) -> CoordinateAxis | None:
+        """Build the merged CoordinateAxis from the two cached per-input axes."""
+        if self._state.concat_axis_a is None or self._state.concat_axis_b is None:
+            return None
+        if self.settings.relabel_axis:
+            labels_a = np.array([str(lbl) + self.settings.label_a for lbl in self._state.concat_axis_a.data])
+            labels_b = np.array([str(lbl) + self.settings.label_b for lbl in self._state.concat_axis_b.data])
+        else:
+            labels_a = self._state.concat_axis_a.data
+            labels_b = self._state.concat_axis_b.data
+        return CoordinateAxis(
+            data=np.concatenate([labels_a, labels_b]),
+            dims=self._state.concat_axis_a.dims,
+            unit=self._state.concat_axis_a.unit,
+        )
+
+    # -- Core merge logic ---------------------------------------------------
+
+    def _try_merge(self) -> AxisArray | None:
+        """Align and read from both buffers, returning the merged result.
+
+        Initial alignment is performed once.  After the first successful
+        merge the two streams are assumed to share a common clock and
+        never drop samples, so we simply read
+        ``min(available_a, available_b)`` on every subsequent call.
+        """
+        if self._state.buf_a is None or self._state.buf_b is None:
+            return None
+        if self._state.buf_a.is_empty() or self._state.buf_b.is_empty():
+            return None
+
+        gain = self._state.gain
+
+        # --- Initial alignment (runs only until the first successful merge) ---
+        if not self._state.aligned:
+            first_a = self._state.buf_a.axis_first_value
+            final_a = self._state.buf_a.axis_final_value
+            first_b = self._state.buf_b.axis_first_value
+            final_b = self._state.buf_b.axis_final_value
+
+            overlap_start = max(first_a, first_b)
+            overlap_end = min(final_a, final_b)
+
+            if overlap_end < overlap_start - gain / 2:
+                if final_a < first_b:
+                    self._state.buf_a.seek(self._state.buf_a.available())
+                elif final_b < first_a:
+                    self._state.buf_b.seek(self._state.buf_b.available())
+                return None
+
+            if first_a < overlap_start - gain / 2:
+                self._state.buf_a.seek(int(round((overlap_start - first_a) / gain)))
+            if first_b < overlap_start - gain / 2:
+                self._state.buf_b.seek(int(round((overlap_start - first_b) / gain)))
+
+        # --- Read aligned samples ---
+        n_read = min(self._state.buf_a.available(), self._state.buf_b.available())
+        if n_read <= 0:
+            return None
+
+        aa_a = self._state.buf_a.read(n_read)
+        aa_b = self._state.buf_b.read(n_read)
+        if aa_a is None or aa_b is None:
+            return None
+
+        if not self._state.aligned:
+            axis_a = aa_a.axes.get(self._state.align_axis)
+            axis_b = aa_b.axes.get(self._state.align_axis)
+            if axis_a is not None and axis_b is not None:
+                off_a = axis_a.value(0) if hasattr(axis_a, "value") else None
+                off_b = axis_b.value(0) if hasattr(axis_b, "value") else None
+                if off_a is not None and off_b is not None:
+                    if not np.isclose(off_a, off_b, atol=abs(gain) * 1e-6):
+                        raise RuntimeError(
+                            f"Offset mismatch after alignment: " f"off_a={off_a}, off_b={off_b}, gain={gain}"
+                        )
+            self._state.aligned = True
+
+        return self._concat(aa_a, aa_b)
+
+    def _concat(self, a: AxisArray, b: AxisArray) -> AxisArray:
+        """Concatenate *a* and *b* along the configured merge axis."""
+        merge_dim = self.settings.axis
+
+        # If the merge dim doesn't exist in an input, add it as a trailing axis.
+        if merge_dim not in a.dims:
+            xp = get_namespace(a.data)
+            a = replace(a, data=xp.expand_dims(a.data, axis=-1), dims=[*a.dims, merge_dim])
+        if merge_dim not in b.dims:
+            xp = get_namespace(b.data)
+            b = replace(b, data=xp.expand_dims(b.data, axis=-1), dims=[*b.dims, merge_dim])
+
+        # Use the cached merged axis (rebuilt lazily when labels change).
+        if self._state.merged_concat_axis is None:
+            self._state.merged_concat_axis = self._build_merged_concat_axis()
+
+        key = self.settings.new_key if self.settings.new_key is not None else a.key
+        result = AxisArray.concatenate(a, b, dim=merge_dim, axis=self._state.merged_concat_axis)
+        if key != result.key:
+            result = replace(result, key=key)
+        return result
+
+
+class Merge(BaseProcessorUnit[MergeSettings]):
+    """Merge two AxisArray streams by time-aligning and concatenating along a non-time axis.
+
+    Input A routes through the processor's ``__acall__`` (triggering
+    hash-based reset when the stream structure changes).  Input B
+    routes through ``push_b`` which independently tracks its own structure.
+
+    Inherits ``INPUT_SETTINGS`` and ``on_settings`` → ``create_processor``
+    from :class:`BaseProcessorUnit`.
+    """
+
+    SETTINGS = MergeSettings
+
+    INPUT_SIGNAL_A = ez.InputStream(AxisArray)
+    INPUT_SIGNAL_B = ez.InputStream(AxisArray)
+    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
+
+    def create_processor(self) -> None:
+        self.processor = MergeProcessor(settings=self.SETTINGS)
+
+    @ez.subscriber(INPUT_SIGNAL_A, zero_copy=True)
+    @ez.publisher(OUTPUT_SIGNAL)
+    async def on_a(self, msg: AxisArray) -> typing.AsyncGenerator:
+        result = await self.processor.__acall__(msg)
+        if result is not None:
+            yield self.OUTPUT_SIGNAL, result
+
+    @ez.subscriber(INPUT_SIGNAL_B, zero_copy=True)
+    @ez.publisher(OUTPUT_SIGNAL)
+    async def on_b(self, msg: AxisArray) -> typing.AsyncGenerator:
+        result = self.processor.push_b(msg)
+        if result is not None:
+            yield self.OUTPUT_SIGNAL, result

ezmsg/sigproc/quantize.py

@@ -1,5 +1,5 @@
 import ezmsg.core as ez
-import numpy as np
+from array_api_compat import get_namespace
 from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
 from ezmsg.util.messages.axisarray import AxisArray, replace
 
@@ -33,32 +33,33 @@ class QuantizeTransformer(BaseTransformer[QuantizeSettings, AxisArray, AxisArray
         self,
         message: AxisArray,
     ) -> AxisArray:
+        xp = get_namespace(message.data)
         expected_range = self.settings.max_val - self.settings.min_val
         scale_factor = 2**self.settings.bits - 1
         clip_max = self.settings.max_val
 
         # Determine appropriate integer type based on bits
         if self.settings.bits <= 1:
-            dtype = bool
+            dtype = xp.bool
         elif self.settings.bits <= 8:
-            dtype = np.uint8
+            dtype = xp.uint8
         elif self.settings.bits <= 16:
-            dtype = np.uint16
+            dtype = xp.uint16
         elif self.settings.bits <= 32:
-            dtype = np.uint32
+            dtype = xp.uint32
         else:
-            dtype = np.uint64
+            dtype = xp.uint64
             if self.settings.bits == 64:
                 # The practical upper bound before converting to int is: 2**64 - 1025
                 #  Anything larger will wrap around to 0.
                 #
                 clip_max *= 1 - 2e-16
 
-        data = message.data.clip(self.settings.min_val, clip_max)
+        data = xp.clip(message.data, self.settings.min_val, clip_max)
         data = (data - self.settings.min_val) / expected_range
 
         # Scale to the quantized range [0, 2^bits - 1]
-        data = np.rint(scale_factor * data).astype(dtype)
+        data = xp.round(scale_factor * data).astype(dtype)
 
         # Create a new AxisArray with the quantized data
         return replace(message, data=data)

ezmsg/sigproc/rollingscaler.py

@@ -1,8 +1,9 @@
+import math
 from collections import deque
 
 import ezmsg.core as ez
-import numpy as np
 import numpy.typing as npt
+from array_api_compat import get_namespace
 from ezmsg.baseproc import (
     BaseAdaptiveTransformer,
     BaseAdaptiveTransformerUnit,
@@ -111,12 +112,13 @@ class RollingScalerProcessor(BaseAdaptiveTransformer[RollingScalerSettings, Axis
         return hash((message.key, samp_shape, gain))
 
     def _reset_state(self, message: AxisArray) -> None:
+        xp = get_namespace(message.data)
         ch = message.data.shape[-1]
-        self._state.mean = np.zeros(ch)
+        self._state.mean = xp.zeros(ch, dtype=xp.float64)
         self._state.N = 0
-        self._state.M2 = np.zeros(ch)
+        self._state.M2 = xp.zeros(ch, dtype=xp.float64)
         self._state.k_samples = (
-            int(np.ceil(self.settings.window_size / message.axes[self.settings.axis].gain))
+            math.ceil(self.settings.window_size / message.axes[self.settings.axis].gain)
             if self.settings.window_size is not None
             else self.settings.k_samples
         )
@@ -127,7 +129,7 @@ class RollingScalerProcessor(BaseAdaptiveTransformer[RollingScalerSettings, Axis
             ez.logger.warning("k_samples is None; z-score accumulation will be unbounded.")
         self._state.samples = deque(maxlen=self._state.k_samples)
         self._state.min_samples = (
-            int(np.ceil(self.settings.min_seconds / message.axes[self.settings.axis].gain))
+            math.ceil(self.settings.min_seconds / message.axes[self.settings.axis].gain)
             if self.settings.window_size is not None
             else self.settings.min_samples
         )
@@ -136,10 +138,11 @@ class RollingScalerProcessor(BaseAdaptiveTransformer[RollingScalerSettings, Axis
             self._state.min_samples = self._state.k_samples
 
     def _add_batch_stats(self, x: npt.NDArray) -> None:
-        x = np.asarray(x, dtype=np.float64)
+        xp = get_namespace(x)
+        x = xp.asarray(x, dtype=xp.float64)
         n_b = x.shape[0]
-        mean_b = np.mean(x, axis=0)
-        M2_b = np.sum((x - mean_b) ** 2, axis=0)
+        mean_b = xp.mean(x, axis=0)
+        M2_b = xp.sum((x - mean_b) ** 2, axis=0)
 
         if self._state.k_samples is not None and len(self._state.samples) == self._state.k_samples:
             n_old, mean_old, M2_old = self._state.samples.popleft()
@@ -148,8 +151,8 @@ class RollingScalerProcessor(BaseAdaptiveTransformer[RollingScalerSettings, Axis
 
             if N_new <= 0:
                 self._state.N = 0
-                self._state.mean = np.zeros_like(self._state.mean)
-                self._state.M2 = np.zeros_like(self._state.M2)
+                self._state.mean = xp.zeros_like(self._state.mean)
+                self._state.M2 = xp.zeros_like(self._state.M2)
             else:
                 delta = mean_old - self._state.mean
                 self._state.N = N_new
@@ -170,32 +173,37 @@ class RollingScalerProcessor(BaseAdaptiveTransformer[RollingScalerSettings, Axis
         self._add_batch_stats(x)
 
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
+
         if self._state.N == 0 or self._state.N < self._state.min_samples:
             if self.settings.update_with_signal:
                 x = message.data
                 if self.settings.artifact_z_thresh is not None and self._state.N > 0:
                     varis = self._state.M2 / self._state.N
-                    std = np.maximum(np.sqrt(varis), 1e-8)
-                    z = np.abs((x - self._state.mean) / std)
-                    mask = np.any(z > self.settings.artifact_z_thresh, axis=1)
+                    raw_std = varis**0.5
+                    std = xp.where(xp.isnan(raw_std), raw_std, xp.clip(raw_std, min=1e-8))
+                    z = xp.abs((x - self._state.mean) / std)
+                    mask = xp.any(z > self.settings.artifact_z_thresh, axis=1)
                     x = x[~mask]
                 if x.size > 0:
                     self._add_batch_stats(x)
             return message
 
         varis = self._state.M2 / self._state.N
-        std = np.maximum(np.sqrt(varis), 1e-8)
-        with np.errstate(divide="ignore", invalid="ignore"):
-            result = (message.data - self._state.mean) / std
-        result = np.nan_to_num(result, nan=0.0, posinf=0.0, neginf=0.0)
+        raw_std = varis**0.5
+        # Preserve NaN from negative variance (will be caught below), clip positive std to floor
+        std = xp.where(xp.isnan(raw_std), raw_std, xp.clip(raw_std, min=1e-8))
+        result = (message.data - self._state.mean) / std
+        # Replace NaN/inf with 0 (equivalent to nan_to_num with nan=0, posinf=0, neginf=0)
+        result = xp.where(xp.isfinite(result), result, xp.asarray(0.0, dtype=result.dtype))
         if self.settings.clip is not None:
-            result = np.clip(result, -self.settings.clip, self.settings.clip)
+            result = xp.clip(result, -self.settings.clip, self.settings.clip)
 
         if self.settings.update_with_signal:
             x = message.data
             if self.settings.artifact_z_thresh is not None:
-                z_scores = np.abs((x - self._state.mean) / std)
-                mask = np.any(z_scores > self.settings.artifact_z_thresh, axis=1)
+                z_scores = xp.abs((x - self._state.mean) / std)
+                mask = xp.any(z_scores > self.settings.artifact_z_thresh, axis=1)
                 x = x[~mask]
             if x.size > 0:
                 self._add_batch_stats(x)

ezmsg/sigproc/scaler.py

@@ -2,6 +2,7 @@ import typing
 
 import ezmsg.core as ez
 import numpy as np
+from array_api_compat import get_namespace
 from ezmsg.baseproc import (
     BaseStatefulTransformer,
     BaseTransformerUnit,
@@ -132,15 +133,20 @@ class AdaptiveStandardScalerTransformer(
             self._state.vars_sq_ewma.settings = replace(self._state.vars_sq_ewma.settings, accumulate=value)
 
     def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
+
         # Update step (respects accumulate setting via child EWMAs)
         mean_message = self._state.samps_ewma(message)
         var_sq_message = self._state.vars_sq_ewma(replace(message, data=message.data**2))
 
-        # Get step
+        # Get step: safe division avoids warnings from zero/negative variance
         varis = var_sq_message.data - mean_message.data**2
-        with np.errstate(divide="ignore", invalid="ignore"):
-            result = (message.data - mean_message.data) / (varis**0.5)
-        result[np.isnan(result)] = 0.0
+        std = varis**0.5
+        mask = std > 0
+        safe_std = xp.where(mask, std, xp.asarray(1.0, dtype=std.dtype))
+        result = xp.where(
+            mask, (message.data - mean_message.data) / safe_std, xp.asarray(0.0, dtype=message.data.dtype)
+        )
         return replace(message, data=result)
 
 

{ezmsg_sigproc-2.11.0.dist-info → ezmsg_sigproc-2.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 2.11.0
+Version: 2.13.0
 Summary: Timeseries signal processing implementations in ezmsg
 Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>, Kyle McGraw <kmcgraw@blackrockneuro.com>
 License-Expression: MIT

{ezmsg_sigproc-2.11.0.dist-info → ezmsg_sigproc-2.13.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
-ezmsg/sigproc/__version__.py,sha256=eqKbWb9LnxuZWE9-pafopBz45ugg0beSlKLIOIjeSzc,706
+ezmsg/sigproc/__version__.py,sha256=_4LOjlEcfZzfuqIlglDZmVBPO4LyQ8P97qO716YoUL8,706
 ezmsg/sigproc/activation.py,sha256=83vnTa3ZcC4Q3VSWcGfaqhCEqYRNySUOyVpMHZXfz-c,2755
 ezmsg/sigproc/adaptive_lattice_notch.py,sha256=ThUR48mbSHuThkimtD0j4IXNMrOVcpZgGhE7PCYfXhU,8818
-ezmsg/sigproc/affinetransform.py,sha256=jl7DiSa5Yb0qsmFJbfSiSeGmvK1SGoBgycFC5JU5DVY,9434
+ezmsg/sigproc/affinetransform.py,sha256=ZugiQg89Ly1I9SDgf0ZzgU2XdwVDmPrU7-orO9yrt7w,20210
 ezmsg/sigproc/aggregate.py,sha256=7Hdz1m-S6Cl9h0oRQHeS_UTGBemhOB4XdFyX6cGcdHo,9362
 ezmsg/sigproc/bandpower.py,sha256=dAhH56sUrXNhcRFymTTwjdM_KcU5OxFzrR_sxIPAxyw,2264
 ezmsg/sigproc/base.py,sha256=SJvKEb8gw6mUMwlV5sH0iPG0bXrgS8tvkPwhI-j89MQ,3672
@@ -29,12 +29,13 @@ ezmsg/sigproc/firfilter.py,sha256=7r_I476nYuixJsuwc_hQ0Fbq8WB0gnYBZUKs3zultOQ,37
 ezmsg/sigproc/gaussiansmoothing.py,sha256=BfXm9YQoOtieM4ABK2KRgxeQz055rd7mqtTVqmjT3Rk,2672
 ezmsg/sigproc/kaiser.py,sha256=dIwgHbLXUHPtdotsGNLE9VG_clhcMgvVnSoFkMVgF9M,3483
 ezmsg/sigproc/linear.py,sha256=b3NRzQNBvdU2jqenZT9XXFHax9Mavbj2xFiVxOwl1Ms,4662
+ezmsg/sigproc/merge.py,sha256=LmuN3LDIZF7DynMcjLp7eGc2G3Yxks9Zd8-luSqqXuA,15436
 ezmsg/sigproc/messages.py,sha256=KQczHTeifn4BZycChN8ZcpfZoQW3lC_xuFmN72QT97s,925
-ezmsg/sigproc/quantize.py,sha256=uSM2z2xXwL0dgSltyzLEmlKjaJZ2meA3PDWX8_bM0Hs,2195
+ezmsg/sigproc/quantize.py,sha256=y7T4_67BHZluX3gyl2anp8iL6EEI6JvsK7Pmp1vapsk,2268
 ezmsg/sigproc/resample.py,sha256=3mm9pvxryNVhQuTCIMW3ToUkUfbVOCsIgvXUiurit1Y,11389
-ezmsg/sigproc/rollingscaler.py,sha256=e-smSKDhmDD2nWIf6I77CtRxQp_7sHS268SGPi7aXp8,8499
+ezmsg/sigproc/rollingscaler.py,sha256=GcLctVAWTmx9J39r0-dt3e7C_hs25s7M0dDnKiGhkC4,8955
 ezmsg/sigproc/sampler.py,sha256=iOk2YoUX22u9iTjFKimzP5V074RDBVcmswgfyxvZRZo,10761
-ezmsg/sigproc/scaler.py,sha256=nCgShZufPId_b-Sbsc8Si31lbtOb3nPImNcnksd774w,6578
+ezmsg/sigproc/scaler.py,sha256=kVXjRbqoxJ5yJICGsGagRXYIDW3-oihSnbBj-n3s55o,6816
 ezmsg/sigproc/signalinjector.py,sha256=mB62H2b-ScgPtH1jajEpxgDHqdb-RKekQfgyNncsE8Y,2874
 ezmsg/sigproc/singlebandpow.py,sha256=BVlWhFI6zU3ME3EVdZbwf-FMz1d2sfuNFDKXs1hn5HM,4353
 ezmsg/sigproc/slicer.py,sha256=xLXxWf722V08ytVwvPimYjDKKj0pkC2HjdgCVaoaOvs,5195
@@ -61,7 +62,7 @@ ezmsg/sigproc/util/message.py,sha256=ppN3IYtIAwrxWG9JOvgWFn1wDdIumkEzYFfqpH9VQkY
 ezmsg/sigproc/util/profile.py,sha256=eVOo9pXgusrnH1yfRdd2RsM7Dbe2UpyC0LJ9MfGpB08,416
 ezmsg/sigproc/util/sparse.py,sha256=NjbJitCtO0B6CENTlyd9c-lHEJwoCan-T3DIgPyeShw,4834
 ezmsg/sigproc/util/typeresolution.py,sha256=fMFzLi63dqCIclGFLcMdM870OYxJnkeWw6aWKNMk718,362
-ezmsg_sigproc-2.11.0.dist-info/METADATA,sha256=8XB8fu3sNqsrwV-ff8xtlWUKsFdERMSqqkotMhfNtu0,1909
-ezmsg_sigproc-2.11.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ezmsg_sigproc-2.11.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
-ezmsg_sigproc-2.11.0.dist-info/RECORD,,
+ezmsg_sigproc-2.13.0.dist-info/METADATA,sha256=RXENX541lABAic8oUDuT8vQwx9nlWY9JETyXYKxdeTQ,1909
+ezmsg_sigproc-2.13.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ezmsg_sigproc-2.13.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-2.13.0.dist-info/RECORD,,