ezmsg-sigproc 1.4.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

ezmsg/sigproc/synth.py

@@ -1,18 +1,19 @@
 import asyncio
-from dataclasses import replace, field
+from dataclasses import field
 import time
-from typing import Optional, Generator, AsyncGenerator, Union
+import typing
 
 import numpy as np
 import ezmsg.core as ez
 from ezmsg.util.generator import consumer
 from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
 
 from .butterworthfilter import ButterworthFilter, ButterworthFilterSettings
 from .base import GenAxisArray
 
 
-def clock(dispatch_rate: Optional[float]) -> Generator[ez.Flag, None, None]:
+def clock(dispatch_rate: float | None) -> typing.Generator[ez.Flag, None, None]:
     """
     Construct a generator that yields events at a specified rate.
 
@@ -32,7 +33,7 @@ def clock(dispatch_rate: Optional[float]) -> Generator[ez.Flag, None, None]:
         yield ez.Flag()
 
 
-async def aclock(dispatch_rate: Optional[float]) -> AsyncGenerator[ez.Flag, None]:
+async def aclock(dispatch_rate: float | None) -> typing.AsyncGenerator[ez.Flag, None]:
     """
     ``asyncio`` version of :obj:`clock`.
 
@@ -53,12 +54,12 @@ class ClockSettings(ez.Settings):
     """Settings for :obj:`Clock`. See :obj:`clock` for parameter description."""
 
     # Message dispatch rate (Hz), or None (fast as possible)
-    dispatch_rate: Optional[float]
+    dispatch_rate: float | None
 
 
 class ClockState(ez.State):
     cur_settings: ClockSettings
-    gen: AsyncGenerator
+    gen: typing.AsyncGenerator
 
 
 class Clock(ez.Unit):
@@ -83,7 +84,7 @@ class Clock(ez.Unit):
         self.construct_generator()
 
     @ez.publisher(OUTPUT_CLOCK)
-    async def generate(self) -> AsyncGenerator:
+    async def generate(self) -> typing.AsyncGenerator:
         while True:
             out = await self.STATE.gen.__anext__()
             if out:
@@ -93,11 +94,11 @@ class Clock(ez.Unit):
 # COUNTER - Generate incrementing integer. fs and dispatch_rate parameters combine to give many options. #
 async def acounter(
     n_time: int,
-    fs: Optional[float],
+    fs: float | None,
     n_ch: int = 1,
-    dispatch_rate: Optional[Union[float, str]] = None,
-    mod: Optional[int] = None,
-) -> AsyncGenerator[AxisArray, None]:
+    dispatch_rate: float | str | None = None,
+    mod: int | None = None,
+) -> typing.AsyncGenerator[AxisArray, None]:
     """
     Construct an asynchronous generator to generate AxisArray objects at a specified rate
     and with the specified sampling rate.
@@ -138,6 +139,17 @@ async def acounter(
 
     n_sent: int = 0  # It is convenient to know how many samples we have sent.
     clock_zero: float = time.time()  # time associated with first sample
+    template = AxisArray(
+        data=np.array([[]]),
+        dims=["time", "ch"],
+        axes={
+            "time": AxisArray.TimeAxis(fs=fs),
+            "ch": AxisArray.CoordinateAxis(
+                data=np.array([f"Ch{_}" for _ in range(n_ch)]), dims=["ch"]
+            ),
+        },
+        key="acounter",
+    )
 
     while True:
         # 1. Sleep, if necessary, until we are at the end of the current block
@@ -167,10 +179,13 @@ async def acounter(
             # offset += clock_zero  # ??
 
         # 4. yield output
-        yield AxisArray(
-            block_samp,
-            dims=["time", "ch"],
-            axes={"time": AxisArray.Axis.TimeAxis(fs=fs, offset=offset)},
+        yield replace(
+            template,
+            data=block_samp,
+            axes={
+                "time": replace(template.axes["time"], offset=offset),
+                "ch": template.axes["ch"],
+            },
         )
 
         # 5. Update state for next iteration (after next yield)
@@ -192,14 +207,14 @@ class CounterSettings(ez.Settings):
     # Message dispatch rate (Hz), 'realtime', 'ext_clock', or None (fast as possible)
     #  Note: if dispatch_rate is a float then time offsets will be synthetic and the
     #  system will run faster or slower than wall clock time.
-    dispatch_rate: Optional[Union[float, str]] = None
+    dispatch_rate: float | str | None = None
 
     # If set to an integer, counter will rollover
-    mod: Optional[int] = None
+    mod: int | None = None
 
 
 class CounterState(ez.State):
-    gen: AsyncGenerator[AxisArray, Optional[ez.Flag]]
+    gen: typing.AsyncGenerator[AxisArray, ez.Flag | None]
     cur_settings: CounterSettings
     new_generator: asyncio.Event
 
@@ -248,7 +263,7 @@ class Counter(ez.Unit):
             yield self.OUTPUT_SIGNAL, out
 
     @ez.publisher(OUTPUT_SIGNAL)
-    async def run_generator(self) -> AsyncGenerator:
+    async def run_generator(self) -> typing.AsyncGenerator:
         while True:
             await self.STATE.new_generator.wait()
             self.STATE.new_generator.clear()
@@ -263,16 +278,17 @@ class Counter(ez.Unit):
 
 @consumer
 def sin(
-    axis: Optional[str] = "time",
+    axis: str | None = "time",
     freq: float = 1.0,
     amp: float = 1.0,
     phase: float = 0.0,
-) -> Generator[AxisArray, AxisArray, None]:
+) -> typing.Generator[AxisArray, AxisArray, None]:
     """
     Construct a generator of sinusoidal waveforms in AxisArray objects.
 
     Args:
         axis: The name of the axis over which the sinusoid passes.
+            Note: The axis must exist in the msg.axes and be of type AxisArray.LinearAxis.
         freq: The frequency of the sinusoid, in Hz.
         amp: The amplitude of the sinusoid.
         phase: The initial phase of the sinusoid, in radians.
@@ -304,7 +320,7 @@ class SinGeneratorSettings(ez.Settings):
     See :obj:`sin` for parameter descriptions.
     """
 
-    time_axis: Optional[str] = "time"
+    time_axis: str | None = "time"
     freq: float = 1.0  # Oscillation frequency in Hz
     amp: float = 1.0  # Amplitude
     phase: float = 0.0  # Phase offset (in radians)
@@ -338,7 +354,7 @@ class OscillatorSettings(ez.Settings):
     n_ch: int = 1
     """Number of channels to output per block"""
 
-    dispatch_rate: Optional[Union[float, str]] = None
+    dispatch_rate: float | str | None = None
     """(Hz) | 'realtime' | 'ext_clock'"""
 
     freq: float = 1.0
@@ -420,7 +436,7 @@ class RandomGenerator(ez.Unit):
 
     @ez.subscriber(INPUT_SIGNAL)
     @ez.publisher(OUTPUT_SIGNAL)
-    async def generate(self, msg: AxisArray) -> AsyncGenerator:
+    async def generate(self, msg: AxisArray) -> typing.AsyncGenerator:
         random_data = np.random.normal(
             size=msg.shape, loc=self.SETTINGS.loc, scale=self.SETTINGS.scale
         )
@@ -436,7 +452,7 @@ class NoiseSettings(ez.Settings):
     n_time: int  # Number of samples to output per block
     fs: float  # Sampling rate of signal output in Hz
     n_ch: int = 1  # Number of channels to output
-    dispatch_rate: Optional[Union[float, str]] = None
+    dispatch_rate: float | str | None = None
     """(Hz), 'realtime', or 'ext_clock'"""
     loc: float = 0.0  # DC offset
     scale: float = 1.0  # Scale (in standard deviations)
@@ -538,12 +554,12 @@ class Add(ez.Unit):
         self.STATE.queue_b.put_nowait(msg)
 
     @ez.publisher(OUTPUT_SIGNAL)
-    async def output(self) -> AsyncGenerator:
+    async def output(self) -> typing.AsyncGenerator:
         while True:
             a = await self.STATE.queue_a.get()
             b = await self.STATE.queue_b.get()
 
-            yield (self.OUTPUT_SIGNAL, replace(a, data=a.data + b.data))
+            yield self.OUTPUT_SIGNAL, replace(a, data=a.data + b.data)
 
 
 class EEGSynthSettings(ez.Settings):

ezmsg/sigproc/wavelets.py

@@ -1,4 +1,3 @@
-from dataclasses import replace
 import typing
 
 import numpy as np
@@ -6,6 +5,7 @@ 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 ezmsg.util.generator import consumer
 
 from .base import GenAxisArray
@@ -14,43 +14,61 @@ from .filterbank import filterbank, FilterbankMode, MinPhaseMode
 
 @consumer
 def cwt(
-    scales: typing.Union[list, tuple, npt.NDArray],
-    wavelet: typing.Union[str, pywt.ContinuousWavelet, pywt.Wavelet],
+    frequencies: list | tuple | npt.NDArray | None,
+    wavelet: str | pywt.ContinuousWavelet | pywt.Wavelet,
     min_phase: MinPhaseMode = MinPhaseMode.NONE,
     axis: str = "time",
+    scales: list | tuple | npt.NDArray | None = None,
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
     Perform a continuous wavelet transform.
     The function is equivalent to the :obj:`pywt.cwt` function, but is designed to work with streaming data.
 
     Args:
-        scales: The wavelet scales to use.
+        frequencies: The wavelet frequencies to use in Hz. If `None` provided then the scales will be used.
+          Note: frequencies will be sorted from smallest to largest.
         wavelet: Wavelet object or name of wavelet to use.
         min_phase: See filterbank MinPhaseMode for details.
         axis: The target axis for operation. Note that this will be moved to the -1th dimension
           because fft and matrix multiplication is much faster on the last axis.
+          This axis must be in the msg.axes and it must be of type AxisArray.LinearAxis.
+        scales: The scales to use. If None, the scales will be calculated from the frequencies.
+          Note: Scales will be sorted from largest to smallest.
+          Note: Use of scales is deprecated in favor of frequencies. Convert scales to frequencies using
+            `pywt.scale2frequency(wavelet, scales, precision=10) * fs` where fs is the sampling frequency.
 
     Returns:
         A primed Generator object that expects an :obj:`AxisArray` via `.send(axis_array)` of continuous data
         and yields an :obj:`AxisArray` with a continuous wavelet transform in its data.
     """
-    msg_out: typing.Optional[AxisArray] = None
+    precision = 10
+    msg_out: AxisArray | None = None
 
     # Check parameters
-    scales = np.array(scales)
-    assert np.all(scales > 0), "Scales must be positive."
-    assert scales.ndim == 1, "Scales must be a 1D list, tuple, or array."
+    if frequencies is None and scales is None:
+        raise ValueError("Either frequencies or scales must be provided.")
+    if frequencies is not None and scales is not None:
+        raise ValueError("Only one of frequencies or scales can be provided.")
+    if scales is not None:
+        scales = np.sort(scales)[::-1]
+        assert np.all(scales > 0), "scales must be positive."
+        assert scales.ndim == 1, "scales must be a 1D list, tuple, or array."
+
     if not isinstance(wavelet, (pywt.ContinuousWavelet, pywt.Wavelet)):
         wavelet = pywt.DiscreteContinuousWavelet(wavelet)
-    precision = 10
+
+    if frequencies is not None:
+        frequencies = np.sort(frequencies)
+        assert np.all(frequencies > 0), "frequencies must be positive."
+        assert frequencies.ndim == 1, "frequencies must be a 1D list, tuple, or array."
 
     # State variables
-    neg_rt_scales = -np.sqrt(scales)[:, None]
+    neg_rt_scales: npt.NDArray | None = None
     int_psi, wave_xvec = pywt.integrate_wavelet(wavelet, precision=precision)
     int_psi = np.conj(int_psi) if wavelet.complex_cwt else int_psi
-    template: typing.Optional[AxisArray] = None
-    fbgen: typing.Optional[typing.Generator[AxisArray, AxisArray, None]] = None
-    last_conv_samp: typing.Optional[npt.NDArray] = None
+    template: AxisArray | None = None
+    fbgen: typing.Generator[AxisArray, AxisArray, None] | None = None
+    last_conv_samp: npt.NDArray | None = None
 
     # Reset if input changed
     check_input = {
@@ -76,6 +94,12 @@ def cwt(
             check_input["shape"] = in_shape
             check_input["key"] = msg_in.key
 
+            if frequencies is not None:
+                scales = pywt.frequency2scale(
+                    wavelet, frequencies * msg_in.axes[axis].gain, precision=precision
+                )
+            neg_rt_scales = -np.sqrt(scales)[:, None]
+
             # convert int_psi, wave_xvec to the same precision as the data
             dt_data = msg_in.data.dtype  # _check_dtype(msg_in.data)
             dt_cplx = np.result_type(dt_data, np.complex64)
@@ -103,7 +127,6 @@ def cwt(
                 pywt.scale2frequency(wavelet, scales, precision)
                 / msg_in.axes[axis].gain
             )
-            fstep = (freqs[1] - freqs[0]) if len(freqs) > 1 else 1.0
             # Create output template
             dummy_shape = in_shape + (len(scales), 0)
             template = AxisArray(
@@ -113,7 +136,9 @@ def cwt(
                 dims=msg_in.dims[:ax_idx] + msg_in.dims[ax_idx + 1 :] + ["freq", axis],
                 axes={
                     **msg_in.axes,
-                    "freq": AxisArray.Axis("Hz", offset=freqs[0], gain=fstep),
+                    "freq": AxisArray.CoordinateAxis(
+                        unit="Hz", data=freqs, dims=["freq"]
+                    ),
                 },
                 key=msg_in.key,
             )
@@ -147,8 +172,8 @@ class CWTSettings(ez.Settings):
     See :obj:`cwt` for argument details.
     """
 
-    scales: typing.Union[list, tuple, npt.NDArray]
-    wavelet: typing.Union[str, pywt.ContinuousWavelet, pywt.Wavelet]
+    scales: list | tuple | npt.NDArray
+    wavelet: str | pywt.ContinuousWavelet | pywt.Wavelet
     min_phase: MinPhaseMode = MinPhaseMode.NONE
     axis: str = "time"
 

ezmsg/sigproc/window.py

@@ -1,4 +1,3 @@
-from dataclasses import replace
 import traceback
 import typing
 
@@ -9,6 +8,7 @@ from ezmsg.util.messages.axisarray import (
     AxisArray,
     slice_along_axis,
     sliding_win_oneaxis,
+    replace,
 )
 from ezmsg.util.generator import consumer
 
@@ -17,10 +17,10 @@ from .base import GenAxisArray
 
 @consumer
 def windowing(
-    axis: typing.Optional[str] = None,
+    axis: str | None = None,
     newaxis: str = "win",
-    window_dur: typing.Optional[float] = None,
-    window_shift: typing.Optional[float] = None,
+    window_dur: float | None = None,
+    window_shift: float | None = None,
     zero_pad_until: str = "input",
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
@@ -31,6 +31,7 @@ def windowing(
     Args:
         axis: The axis along which to segment windows.
             If None, defaults to the first dimension of the first seen AxisArray.
+            Note: The windowed axis must be an AxisArray.LinearAxis, not an AxisArray.CoordinateAxis.
         newaxis: New axis on which windows are delimited, immediately
         preceding the target windowed axis. The data length along newaxis may be 0 if
         this most recent push did not provide enough data for a new window.
@@ -71,15 +72,15 @@ def windowing(
     msg_out = AxisArray(np.array([]), dims=[""])
 
     # State variables
-    buffer: typing.Optional[npt.NDArray] = None
-    window_samples: typing.Optional[int] = None
-    window_shift_samples: typing.Optional[int] = None
+    buffer: npt.NDArray | None = None
+    window_samples: int | None = None
+    window_shift_samples: int | None = None
     # Number of incoming samples to ignore. Only relevant when shift > window.:
     shift_deficit: int = 0
     b_1to1 = window_shift is None
     newaxis_warned: bool = b_1to1
-    out_newaxis: typing.Optional[AxisArray.Axis] = None
-    out_dims: typing.Optional[typing.List[str]] = None
+    out_newaxis: AxisArray.LinearAxis | None = None
+    out_dims: list[str] | None = None
 
     check_inputs = {"samp_shape": None, "fs": None, "key": None}
 
@@ -215,10 +216,10 @@ def windowing(
 
 
 class WindowSettings(ez.Settings):
-    axis: typing.Optional[str] = None
-    newaxis: typing.Optional[str] = None  # new axis for output. No new axes if None
-    window_dur: typing.Optional[float] = None  # Sec. passthrough if None
-    window_shift: typing.Optional[float] = None  # Sec. Use "1:1 mode" if None
+    axis: str | None = None
+    newaxis: str | None = None  # new axis for output. No new axes if None
+    window_dur: float | None = None  # Sec. passthrough if None
+    window_shift: float | None = None  # Sec. Use "1:1 mode" if None
     zero_pad_until: str = "full"  # "full", "shift", "input", "none"
 
 

{ezmsg_sigproc-1.4.2.dist-info → ezmsg_sigproc-1.6.0.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.3
 Name: ezmsg-sigproc
-Version: 1.4.2
+Version: 1.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>
-License-Expression: MIT
-License-File: LICENSE.txt
-Requires-Python: >=3.9
-Requires-Dist: ezmsg>=3.5.0
+License: MIT
+Requires-Python: >=3.10.15
+Requires-Dist: ezmsg>=3.6.0
 Requires-Dist: numpy>=1.26.0
 Requires-Dist: pywavelets>=1.6.0
 Requires-Dist: scipy>=1.13.1

ezmsg_sigproc-1.6.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
+ezmsg/sigproc/__version__.py,sha256=Ry70pc5l-IBhT9gahlkNwZPp4g0CzVEWqsat9H-UASY,411
+ezmsg/sigproc/activation.py,sha256=LM-MtaNvFvmBZ1_EPNu--4K3-wIzsb7CUQ00fvMM69g,2642
+ezmsg/sigproc/affinetransform.py,sha256=R2P1f5JdNSpr30x8Pxoqv-J-nAasGl_UZR8o7sVqlaQ,8740
+ezmsg/sigproc/aggregate.py,sha256=6BqAujWe7_zzGPDJz7yh4ofPzJTU5z2lrclX-IuqXDU,6235
+ezmsg/sigproc/bandpower.py,sha256=Mx8iUU-UMWKK5sgCXvxpUSA3522rW8Jg96asrT8MdpA,2180
+ezmsg/sigproc/base.py,sha256=vut0BLjgc0mxYRbs7tDd9XzwRFA2_GcsgXZmIYovR0Y,1248
+ezmsg/sigproc/butterworthfilter.py,sha256=vZTY37FfLwa24bRZmeZGyO5323824wJosUrrZarb0_o,5402
+ezmsg/sigproc/cheby.py,sha256=yds5y1fOeBE1ljyH_EreBLxqFX4UetxB_3rwz3omHyc,3394
+ezmsg/sigproc/decimate.py,sha256=Cu2weOIKGoo_pUSpA90N47kuzcT6s7OAa1HaF7u3cY0,1286
+ezmsg/sigproc/downsample.py,sha256=oJ0VOZ0UrLAhce2bolSom23LD8Ob-8LCOmzqkrZCJ0E,3454
+ezmsg/sigproc/ewmfilter.py,sha256=EPlocRdKORj575VV1YUzcNsVcq-pYgdEJ7_m9WfpVnY,4795
+ezmsg/sigproc/filter.py,sha256=n3_gColSPXe4pI-A2VDKfrdFHZgC-k4kqB8H6tnGIws,6969
+ezmsg/sigproc/filterbank.py,sha256=pySLNGppnG6Dx9r5jQpNSyWhd9qmvj6up2udG7RMNok,12410
+ezmsg/sigproc/messages.py,sha256=y_twVPK7TxRj8ajmuSuBuxwvLTgyv9OF7Y7v9bw1tfs,926
+ezmsg/sigproc/sampler.py,sha256=ljZuToiC5p4Jx2cJPXJ4tOtv3nBOBGMEaz7ad7Nec8U,12735
+ezmsg/sigproc/scaler.py,sha256=5uCgVbZHV9iCsAVnc9Pz7hKIXnaIiA9ssiTCce_QHlU,9550
+ezmsg/sigproc/signalinjector.py,sha256=-_cln7Ljny0WWrjBV3HZhhONLEkEphsgLS30AWlxcOE,2590
+ezmsg/sigproc/slicer.py,sha256=n6JGOkkY2ur5K1STsLQDSvFhEjT2ZLiSxmggK6qEmpc,5731
+ezmsg/sigproc/spectral.py,sha256=_2qO6as4Nesmc9V1WW2EXNMH5pPz8aVTEcIPOi4-g2o,322
+ezmsg/sigproc/spectrogram.py,sha256=Xc3zXKjVwG0-NLzKEsVKv253Sk50t2U1SlqEJ_ll36k,3086
+ezmsg/sigproc/spectrum.py,sha256=ZhsWlxUiTaWc8qgNZ5NWqsU_fNmjb4V5532mNA8Bd5Y,9396
+ezmsg/sigproc/synth.py,sha256=kobTQwAyiNZLbpJIUNxI6SOiuKm0aca2G5pSjuB4K9E,18823
+ezmsg/sigproc/wavelets.py,sha256=bwlqyUESrOWAiI_gECbaKJj0PflnFMmuYtNridBTfNs,7955
+ezmsg/sigproc/window.py,sha256=eIxdtni6BwDmpko6m_WJnUDO3VHb5y7jM6nU9WyzIsM,13056
+ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/math/abs.py,sha256=Hjnn2x8djWLUDVqvxRC4V7jOvgEtdU6CCHGpfVZ0uOY,931
+ezmsg/sigproc/math/clip.py,sha256=UpFLP_IkrY6bo4WcIpO4Czbttg7n6hybAihOGy-3nGs,1144
+ezmsg/sigproc/math/difference.py,sha256=I96Md2pyfCU5TSw35u1uS6FaPJRv0JpHQVhrTHv1BQ0,2196
+ezmsg/sigproc/math/invert.py,sha256=T6PEhBCquKRJQF6LfUgqjXKSBsS_tvi4BJAqJ_5VCjw,895
+ezmsg/sigproc/math/log.py,sha256=i-iF2WDH18RWapYwlhAsiDdhzvuJY9mDWrNtjfuiyL8,1572
+ezmsg/sigproc/math/scale.py,sha256=lQKF02Mv9nTWfgc4OcMpQMCx993p57GSN-AADeO2fjY,1063
+ezmsg_sigproc-1.6.0.dist-info/METADATA,sha256=-Y0s91NhAEO_KWsBo1KQKPQE4IDyU-xp51rOa8FuUAo,2343
+ezmsg_sigproc-1.6.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+ezmsg_sigproc-1.6.0.dist-info/licenses/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-1.6.0.dist-info/RECORD,,

{ezmsg_sigproc-1.4.2.dist-info → ezmsg_sigproc-1.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any

ezmsg_sigproc-1.4.2.dist-info/RECORD

@@ -1,35 +0,0 @@
-ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
-ezmsg/sigproc/__version__.py,sha256=tX44urJsC0QN5SJ51xsM0HeojA_8Xx7NXFEGAkYlNE4,411
-ezmsg/sigproc/activation.py,sha256=amvVjO-1BcChgK0VQi44i7-Tmz_2FK1xb-BTC52_DO0,2642
-ezmsg/sigproc/affinetransform.py,sha256=a5xt6LSymlV3gNSdCjWdtUoi9kOkWiYx6oeiGEIphYI,8802
-ezmsg/sigproc/aggregate.py,sha256=Wnvz1xXDQhdVkTfVPOmhdmjgIhR_YQhioo8Dwh4BaoE,5615
-ezmsg/sigproc/bandpower.py,sha256=QPktf3v7sojDHhwUVcK3UNPU-Dm4sf2QQw3qmYWZ1r0,2228
-ezmsg/sigproc/base.py,sha256=vut0BLjgc0mxYRbs7tDd9XzwRFA2_GcsgXZmIYovR0Y,1248
-ezmsg/sigproc/butterworthfilter.py,sha256=vTESZAAcQhWLI8yIMOApsGAYgjv2ekCZsTIliFjEkc8,5345
-ezmsg/sigproc/decimate.py,sha256=zNxJXauE4Z54Yy7tpN9_oJuW0I0ppQRWhSpwb3Ri2gc,1473
-ezmsg/sigproc/downsample.py,sha256=0TOhWkg7B9g3FDcewHINZiNuo28JyXRtgTYvZ7C8ImM,3384
-ezmsg/sigproc/ewmfilter.py,sha256=XzTmouRa7AnPjTiI32-oumwm4ZfOl6uPPUSldExNpAs,4516
-ezmsg/sigproc/filter.py,sha256=x3ytFowxg4O0QFQeMDFmQieV86H-6Q3Mkt3ThRIOh60,8301
-ezmsg/sigproc/filterbank.py,sha256=Rhs7AKWy36lrMlzftEbYPXPW-FwZZ-QUCEp_QFG9mFU,12443
-ezmsg/sigproc/messages.py,sha256=KpYCWWRD5itVAq0-Lf8qd7ErEE1A9qdm2p7O8Y4zEFA,955
-ezmsg/sigproc/sampler.py,sha256=Zv5eq9CLpE8ui4HyZzBEqxwqBf--IbexS7zBx3qKp3w,12733
-ezmsg/sigproc/scaler.py,sha256=2Hi4XWWvUtPOVOfIyX0Dr0cZEdbTobZOoMXKh9Vszlk,5944
-ezmsg/sigproc/signalinjector.py,sha256=T1yvigk9WYujYqubd15UAF6hNmSqS9J7rCzaPYENoEA,2644
-ezmsg/sigproc/slicer.py,sha256=ffawSqhO06lC5TXg_Ujg0eP2EuF98McQiUdlwxn3psI,5072
-ezmsg/sigproc/spectral.py,sha256=_2qO6as4Nesmc9V1WW2EXNMH5pPz8aVTEcIPOi4-g2o,322
-ezmsg/sigproc/spectrogram.py,sha256=16By4VWln7UvZ8IV_TdNAFaJDgkzvVKXWpnsoZoiW1M,3146
-ezmsg/sigproc/spectrum.py,sha256=a75d6q6o3dAuqX6ZuFv6AfHYDOMuhA01OVCugzFMUSQ,9415
-ezmsg/sigproc/synth.py,sha256=ygJRI9Seqhrg13lUhcA6XSpxcEr3LL1NupviSQLrC9o,18351
-ezmsg/sigproc/wavelets.py,sha256=_3jI52NzksD1WNnHx03F2p4V2uGN_MtBbLsJGRjeyoE,6596
-ezmsg/sigproc/window.py,sha256=A697XG2YyR9ywmzfxJIXovi6wPwDhBI9UUeShNJFKgM,13094
-ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ezmsg/sigproc/math/abs.py,sha256=hqS_sbLqAKSlguj3_rsfeWzOe6233tMxXfjDPg1fi2g,918
-ezmsg/sigproc/math/clip.py,sha256=xIfc6fEfiNh7ILG3IYxcuCd5VBqmWXmDliGi_dKVJpM,1131
-ezmsg/sigproc/math/difference.py,sha256=s3al1WzUZXsG2XYzOprRcKP-VD9J5FwYx578_SKG0vg,2183
-ezmsg/sigproc/math/invert.py,sha256=H8df1u8OVb5TOkRC8p5EW7R17kHdLOYqXVH_axy5bkI,882
-ezmsg/sigproc/math/log.py,sha256=oot0tT0wVvdI0UlPOqj1tQLDn_gIxf8em_b4NfJRmW0,1559
-ezmsg/sigproc/math/scale.py,sha256=iIQuJAr5pzCiMqzi2YdzLc1agQBKBOcngdNZlLO3X_o,1050
-ezmsg_sigproc-1.4.2.dist-info/METADATA,sha256=islU0_cvDjX0iqp202X5_eD-Qu37_9wKsBOo_cKcV8c,2376
-ezmsg_sigproc-1.4.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ezmsg_sigproc-1.4.2.dist-info/licenses/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
-ezmsg_sigproc-1.4.2.dist-info/RECORD,,