ezmsg-sigproc 1.2.2__py3-none-any.whl → 2.10.0__py3-none-any.whl

ezmsg_sigproc-2.10.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ezmsg-sigproc
+Version: 2.10.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
+License-File: LICENSE
+Requires-Python: >=3.10.15
+Requires-Dist: array-api-compat>=1.11.1
+Requires-Dist: ezmsg-baseproc>=1.1.0
+Requires-Dist: ezmsg>=3.6.0
+Requires-Dist: numba>=0.61.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pywavelets>=1.6.0
+Requires-Dist: scipy>=1.13.1
+Requires-Dist: sparse>=0.15.4
+Description-Content-Type: text/markdown
+
+# ezmsg-sigproc
+
+Signal processing primitives for the [ezmsg](https://www.ezmsg.org) message-passing framework.
+
+## Features
+
+* **Filtering** - Chebyshev, comb filters, and more
+* **Spectral analysis** - Spectrogram, spectrum, and wavelet transforms
+* **Resampling** - Downsample, decimate, and resample operations
+* **Windowing** - Sliding windows and buffering utilities
+* **Math operations** - Arithmetic, log, abs, difference, and more
+* **Signal generation** - Synthetic signal generators
+
+All modules use `AxisArray` as the primary data structure for passing signals between components.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install ezmsg-sigproc
+```
+
+Or install from GitHub for the latest development version:
+
+```bash
+pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev
+```
+
+## Documentation
+
+Full documentation is available at [ezmsg.org](https://www.ezmsg.org).
+
+## Development
+
+We use [`uv`](https://docs.astral.sh/uv/) for development.
+
+1. Fork and clone the repository
+2. `uv sync` to create a virtual environment and install dependencies
+3. `uv run pre-commit install` to set up linting and formatting hooks
+4. `uv run pytest tests` to run the test suite
+5. Submit a PR against the `dev` branch

ezmsg_sigproc-2.10.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
+ezmsg/sigproc/__version__.py,sha256=2cFLkHY3I9n23ToIWm38PohvvIEYjdsebREPVvOKAiU,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/aggregate.py,sha256=7Hdz1m-S6Cl9h0oRQHeS_UTGBemhOB4XdFyX6cGcdHo,9362
+ezmsg/sigproc/bandpower.py,sha256=dAhH56sUrXNhcRFymTTwjdM_KcU5OxFzrR_sxIPAxyw,2264
+ezmsg/sigproc/base.py,sha256=SJvKEb8gw6mUMwlV5sH0iPG0bXrgS8tvkPwhI-j89MQ,3672
+ezmsg/sigproc/butterworthfilter.py,sha256=NKTGkgjvlmC1Dc9gD2Z6UBzUq12KicfnczrzM5ZTosk,5255
+ezmsg/sigproc/butterworthzerophase.py,sha256=CU6cXkI6j1LQCEz0sr2IthAPCq_TEtbvSb7h2Nw1w74,11820
+ezmsg/sigproc/cheby.py,sha256=B8pGt5_pOBpNZCmaibNl_NKkyuasd8ZEJXeTDCTaino,3711
+ezmsg/sigproc/combfilter.py,sha256=MSxr1I-jBePW_9AuCiv3RQ1HUNxIsNhLk0q1Iu8ikAw,4766
+ezmsg/sigproc/coordinatespaces.py,sha256=bp_0fTS9b27OQqLoFzgE3f9rb287P8y0S1dWWGrS08o,5298
+ezmsg/sigproc/decimate.py,sha256=DCX9p4ZrcGoQ9di-jmPKqiKERTkvTAtSqLg8chQLp84,2336
+ezmsg/sigproc/denormalize.py,sha256=OACzoINCISNUmZcR2pqWfxi3p8uuBLCz1PMw4XNwOCs,3035
+ezmsg/sigproc/detrend.py,sha256=2C-dhVy-ty4b22aE07kIF3VjqCoFitoZqyrX6hAjXYQ,894
+ezmsg/sigproc/diff.py,sha256=nDf9-XywZKlfeainIeubl_NccmkuAdLjYMcWSPMquss,3179
+ezmsg/sigproc/downsample.py,sha256=Jqxt1Va1FrQLH1wUQpP0U79iQARTTHEKklKHy7yGL2o,3679
+ezmsg/sigproc/ewma.py,sha256=ecLq1ZlON85NWdW_5cz9chWirxjf4y9zCPMOt3IqQuk,7723
+ezmsg/sigproc/ewmfilter.py,sha256=9AuvVn3TDdf5R4bVolYNM46AtDVHFJa8MLGltY6mYPE,4795
+ezmsg/sigproc/extract_axis.py,sha256=T2e9zW8N0bwOj4_zlB3I0oT0iwaBijpzF6wrFsCfD24,1593
+ezmsg/sigproc/fbcca.py,sha256=JYFWsMDRJEWwUNujr4EsFL5t1ux-cnBGamNVrCRO_RA,12043
+ezmsg/sigproc/filter.py,sha256=IWg3J5IGVdv7kfp4zaKRzfjEuRa5xNzcq6fHtq4tPCM,11604
+ezmsg/sigproc/filterbank.py,sha256=tD7fn4dZzEvsmp_sSn16VVJ4WcJ5sN5lsSuNTLDCQZ8,13056
+ezmsg/sigproc/filterbankdesign.py,sha256=vLXQVJwoFEK4V6umqzcr1PJKcwv6pGO29klSWQXk7y0,4712
+ezmsg/sigproc/fir_hilbert.py,sha256=ByZDsDFjbJx-EgLZF85vZCPQbprQaiMEuG2dyvTPiDY,10855
+ezmsg/sigproc/fir_pmc.py,sha256=Ze2pd9K8XrdDhgJZG2E7x-5C2hfd6kIns4bYjTJsBvc,6997
+ezmsg/sigproc/firfilter.py,sha256=7r_I476nYuixJsuwc_hQ0Fbq8WB0gnYBZUKs3zultOQ,3790
+ezmsg/sigproc/gaussiansmoothing.py,sha256=BfXm9YQoOtieM4ABK2KRgxeQz055rd7mqtTVqmjT3Rk,2672
+ezmsg/sigproc/kaiser.py,sha256=dIwgHbLXUHPtdotsGNLE9VG_clhcMgvVnSoFkMVgF9M,3483
+ezmsg/sigproc/linear.py,sha256=b3NRzQNBvdU2jqenZT9XXFHax9Mavbj2xFiVxOwl1Ms,4662
+ezmsg/sigproc/messages.py,sha256=KQczHTeifn4BZycChN8ZcpfZoQW3lC_xuFmN72QT97s,925
+ezmsg/sigproc/quantize.py,sha256=uSM2z2xXwL0dgSltyzLEmlKjaJZ2meA3PDWX8_bM0Hs,2195
+ezmsg/sigproc/resample.py,sha256=3mm9pvxryNVhQuTCIMW3ToUkUfbVOCsIgvXUiurit1Y,11389
+ezmsg/sigproc/rollingscaler.py,sha256=e-smSKDhmDD2nWIf6I77CtRxQp_7sHS268SGPi7aXp8,8499
+ezmsg/sigproc/sampler.py,sha256=iOk2YoUX22u9iTjFKimzP5V074RDBVcmswgfyxvZRZo,10761
+ezmsg/sigproc/scaler.py,sha256=oBZa6uzyftChvk6aqBD5clil6pedx3IF-dptrb74EA0,5888
+ezmsg/sigproc/signalinjector.py,sha256=mB62H2b-ScgPtH1jajEpxgDHqdb-RKekQfgyNncsE8Y,2874
+ezmsg/sigproc/slicer.py,sha256=xLXxWf722V08ytVwvPimYjDKKj0pkC2HjdgCVaoaOvs,5195
+ezmsg/sigproc/spectral.py,sha256=wFzuihS7qJZMQcp0ds_qCG-zCbvh5DyhFRjn2wA9TWQ,322
+ezmsg/sigproc/spectrogram.py,sha256=g8xYWENzle6O5uEF-vfjsF5gOSDnJTwiu3ZudicO470,2893
+ezmsg/sigproc/spectrum.py,sha256=AAxrywIYpAPENRWvaaM2VjcKEaqMt6ra1E3Ao26jdZs,9523
+ezmsg/sigproc/transpose.py,sha256=uRGieeYRFTO9gAhWzkq49f-Qo49rpDQhn9r3nLuwx4I,4983
+ezmsg/sigproc/wavelets.py,sha256=mN9TrZencyvKBfnuMiGZ_lzrE1O7DhVo05EYgCjXncg,7428
+ezmsg/sigproc/window.py,sha256=ZlawY4TPbLc46qIgcKhP4X7dpMDo4zNlnfzgV1eFaGU,15335
+ezmsg/sigproc/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/math/abs.py,sha256=Zrt0xhGnhf90Vk00S1PYkbeCOQshqkvh1HLj26N4AL0,979
+ezmsg/sigproc/math/add.py,sha256=UikpS_vhaY58ssf46C1r4_tnRUFMl86xCmd5Y8GFZ1Q,3666
+ezmsg/sigproc/math/clip.py,sha256=1D6mUlOzBB7L35G_KKYZmfg7nYlbuDdITV4EH0R-yUo,1529
+ezmsg/sigproc/math/difference.py,sha256=uUYZgbLe-GrFSN6EOFjs9fQZllp827IluxL6m8TJuH8,4791
+ezmsg/sigproc/math/invert.py,sha256=nz8jbfvDoez6s9NmAprBtTAI5oSDj0wNUPk8j13XiVk,855
+ezmsg/sigproc/math/log.py,sha256=JhjSqLnQnvx_3F4txRYHuUPSJ12Yj2HvRTsCMNvlxpo,2022
+ezmsg/sigproc/math/scale.py,sha256=4_xHcHNuf13E1fxIF5vbkPfkN4En6zkfPIKID7lCERk,1133
+ezmsg/sigproc/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ezmsg/sigproc/util/asio.py,sha256=aAj0e7OoBvkRy28k05HL2s9YPCTxOddc05xMN-qd4lQ,577
+ezmsg/sigproc/util/axisarray_buffer.py,sha256=TGDeC6CXmmp7OUuiGd6xYQijRGYDE4QGdWxjK5Vs3nE,14057
+ezmsg/sigproc/util/buffer.py,sha256=83Gm0IuowmcMlXgLFB_rz8_ZPhkwG4DNNejyWJDKJl8,19658
+ezmsg/sigproc/util/message.py,sha256=ppN3IYtIAwrxWG9JOvgWFn1wDdIumkEzYFfqpH9VQkY,338
+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.10.0.dist-info/METADATA,sha256=lsHkW6Abh6GK3bOOl5MHtXthhwOQWuVUrByPz2AYOfk,1909
+ezmsg_sigproc-2.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ezmsg_sigproc-2.10.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-2.10.0.dist-info/RECORD,,

{ezmsg_sigproc-1.2.2.dist-info → ezmsg_sigproc-2.10.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

ezmsg/sigproc/synth.py

@@ -1,411 +0,0 @@
-import asyncio
-import time
-from dataclasses import dataclass, replace, field
-
-import ezmsg.core as ez
-import numpy as np
-
-from ezmsg.util.messages.axisarray import AxisArray
-
-from .butterworthfilter import ButterworthFilter, ButterworthFilterSettings
-
-from typing import Optional, AsyncGenerator, Union
-
-
-class ClockSettings(ez.Settings):
-    # Message dispatch rate (Hz), or None (fast as possible)
-    dispatch_rate: Optional[float]
-
-
-class ClockState(ez.State):
-    cur_settings: ClockSettings
-
-
-class Clock(ez.Unit):
-    SETTINGS: ClockSettings
-    STATE: ClockState
-
-    INPUT_SETTINGS = ez.InputStream(ClockSettings)
-    OUTPUT_CLOCK = ez.OutputStream(ez.Flag)
-
-    def initialize(self) -> None:
-        self.STATE.cur_settings = self.SETTINGS
-
-    @ez.subscriber(INPUT_SETTINGS)
-    async def on_settings(self, msg: ClockSettings) -> None:
-        self.STATE.cur_settings = msg
-
-    @ez.publisher(OUTPUT_CLOCK)
-    async def generate(self) -> AsyncGenerator:
-        while True:
-            if self.STATE.cur_settings.dispatch_rate is not None:
-                await asyncio.sleep(1.0 / self.STATE.cur_settings.dispatch_rate)
-            yield self.OUTPUT_CLOCK, ez.Flag
-
-
-class CounterSettings(ez.Settings):
-    """
-    TODO: Adapt this to use ezmsg.util.rate?
-    NOTE: This module uses asyncio.sleep to delay appropriately in realtime mode.
-    This method of sleeping/yielding execution priority has quirky behavior with
-    sub-millisecond sleep periods which may result in unexpected behavior (e.g.
-    fs = 2000, n_time = 1, realtime = True -- may result in ~1400 msgs/sec)
-    """
-
-    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 synthesize
-
-    # Message dispatch rate (Hz), 'realtime', 'ext_clock', or None (fast as possible)
-    dispatch_rate: Optional[Union[float, str]] = None
-
-    # If set to an integer, counter will rollover
-    mod: Optional[int] = None
-
-
-class CounterState(ez.State):
-    cur_settings: CounterSettings
-    samp: int = 0  # current sample counter
-    clock_event: asyncio.Event
-
-
-class Counter(ez.Unit):
-    """Generates monotonically increasing counter"""
-
-    SETTINGS: CounterSettings
-    STATE: CounterState
-
-    INPUT_CLOCK = ez.InputStream(ez.Flag)
-    INPUT_SETTINGS = ez.InputStream(CounterSettings)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    def initialize(self) -> None:
-        self.STATE.clock_event = asyncio.Event()
-        self.STATE.clock_event.clear()
-        self.validate_settings(self.SETTINGS)
-
-    @ez.subscriber(INPUT_SETTINGS)
-    async def on_settings(self, msg: CounterSettings) -> None:
-        self.validate_settings(msg)
-
-    def validate_settings(self, settings: CounterSettings) -> None:
-        if isinstance(
-            settings.dispatch_rate, str
-        ) and self.SETTINGS.dispatch_rate not in ["realtime", "ext_clock"]:
-            raise ValueError(f"Unknown dispatch_rate: {self.SETTINGS.dispatch_rate}")
-
-        self.STATE.cur_settings = settings
-
-    @ez.subscriber(INPUT_CLOCK)
-    async def on_clock(self, _: ez.Flag):
-        self.STATE.clock_event.set()
-
-    @ez.publisher(OUTPUT_SIGNAL)
-    async def publish(self) -> AsyncGenerator:
-        while True:
-            block_dur = self.STATE.cur_settings.n_time / self.STATE.cur_settings.fs
-
-            dispatch_rate = self.STATE.cur_settings.dispatch_rate
-            if dispatch_rate is not None:
-                if isinstance(dispatch_rate, str):
-                    if dispatch_rate == "realtime":
-                        await asyncio.sleep(block_dur)
-                    elif dispatch_rate == "ext_clock":
-                        await self.STATE.clock_event.wait()
-                        self.STATE.clock_event.clear()
-                else:
-                    await asyncio.sleep(1.0 / dispatch_rate)
-
-            block_samp = np.arange(self.STATE.cur_settings.n_time)[:, np.newaxis]
-
-            t_samp = block_samp + self.STATE.samp
-            self.STATE.samp = t_samp[-1] + 1
-
-            if self.STATE.cur_settings.mod is not None:
-                t_samp %= self.STATE.cur_settings.mod
-                self.STATE.samp %= self.STATE.cur_settings.mod
-
-            t_samp = np.tile(t_samp, (1, self.STATE.cur_settings.n_ch))
-
-            offset_adj = self.STATE.cur_settings.n_time / self.STATE.cur_settings.fs
-
-            out = AxisArray(
-                t_samp,
-                dims=["time", "ch"],
-                axes=dict(
-                    time=AxisArray.Axis.TimeAxis(
-                        fs=self.STATE.cur_settings.fs, offset=time.time() - offset_adj
-                    )
-                ),
-            )
-
-            yield self.OUTPUT_SIGNAL, out
-
-
-class SinGeneratorSettings(ez.Settings):
-    time_axis: Optional[str] = "time"
-    freq: float = 1.0  # Oscillation frequency in Hz
-    amp: float = 1.0  # Amplitude
-    phase: float = 0.0  # Phase offset (in radians)
-
-
-class SinGeneratorState(ez.State):
-    ang_freq: float  # pre-calculated angular frequency in radians
-
-
-class SinGenerator(ez.Unit):
-    SETTINGS: SinGeneratorSettings
-    STATE: SinGeneratorState
-
-    INPUT_SIGNAL = ez.InputStream(AxisArray)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    def initialize(self) -> None:
-        self.STATE.ang_freq = 2.0 * np.pi * self.SETTINGS.freq
-
-    @ez.subscriber(INPUT_SIGNAL)
-    @ez.publisher(OUTPUT_SIGNAL)
-    async def generate(self, msg: AxisArray) -> AsyncGenerator:
-        """
-        msg is assumed to be a monotonically increasing counter ..
-        .. or at least a counter with an intelligently chosen modulus
-        """
-        axis_name = self.SETTINGS.time_axis
-        if axis_name is None:
-            axis_name = msg.dims[0]
-        fs = 1.0 / msg.get_axis(axis_name).gain
-        t_sec = msg.data / fs
-        w = self.STATE.ang_freq * t_sec
-        out_data = self.SETTINGS.amp * np.sin(w + self.SETTINGS.phase)
-        yield (self.OUTPUT_SIGNAL, replace(msg, data=out_data))
-
-
-class OscillatorSettings(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 per block
-    dispatch_rate: Optional[Union[float, str]] = None  # (Hz) | 'realtime' | 'ext_clock'
-    freq: float = 1.0  # Oscillation frequency in Hz
-    amp: float = 1.0  # Amplitude
-    phase: float = 0.0  # Phase offset (in radians)
-    sync: bool = False  # Adjust `freq` to sync with sampling rate
-
-
-class Oscillator(ez.Collection):
-    SETTINGS: OscillatorSettings
-
-    INPUT_CLOCK = ez.InputStream(ez.Flag)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    COUNTER = Counter()
-    SIN = SinGenerator()
-
-    def configure(self) -> None:
-        # Calculate synchronous settings if necessary
-        freq = self.SETTINGS.freq
-        mod = None
-        if self.SETTINGS.sync:
-            period = 1.0 / self.SETTINGS.freq
-            mod = round(period * self.SETTINGS.fs)
-            freq = 1.0 / (mod / self.SETTINGS.fs)
-
-        self.COUNTER.apply_settings(
-            CounterSettings(
-                n_time=self.SETTINGS.n_time,
-                fs=self.SETTINGS.fs,
-                n_ch=self.SETTINGS.n_ch,
-                dispatch_rate=self.SETTINGS.dispatch_rate,
-                mod=mod,
-            )
-        )
-
-        self.SIN.apply_settings(
-            SinGeneratorSettings(
-                freq=freq, amp=self.SETTINGS.amp, phase=self.SETTINGS.phase
-            )
-        )
-
-    def network(self) -> ez.NetworkDefinition:
-        return (
-            (self.INPUT_CLOCK, self.COUNTER.INPUT_CLOCK),
-            (self.COUNTER.OUTPUT_SIGNAL, self.SIN.INPUT_SIGNAL),
-            (self.SIN.OUTPUT_SIGNAL, self.OUTPUT_SIGNAL),
-        )
-
-
-class RandomGeneratorSettings(ez.Settings):
-    loc: float = 0.0
-    scale: float = 1.0
-
-
-class RandomGenerator(ez.Unit):
-    SETTINGS: RandomGeneratorSettings
-
-    INPUT_SIGNAL = ez.InputStream(AxisArray)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    @ez.subscriber(INPUT_SIGNAL)
-    @ez.publisher(OUTPUT_SIGNAL)
-    async def generate(self, msg: AxisArray) -> AsyncGenerator:
-        random_data = np.random.normal(
-            size=msg.shape, loc=self.SETTINGS.loc, scale=self.SETTINGS.scale
-        )
-
-        yield self.OUTPUT_SIGNAL, replace(msg, data=random_data)
-
-
-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  # (Hz), 'realtime', or 'ext_clock'
-    loc: float = 0.0  # DC offset
-    scale: float = 1.0  # Scale (in standard deviations)
-
-
-WhiteNoiseSettings = NoiseSettings
-
-
-class WhiteNoise(ez.Collection):
-    SETTINGS: NoiseSettings
-
-    INPUT_CLOCK = ez.InputStream(ez.Flag)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    COUNTER = Counter()
-    RANDOM = RandomGenerator()
-
-    def configure(self) -> None:
-        self.RANDOM.apply_settings(
-            RandomGeneratorSettings(loc=self.SETTINGS.loc, scale=self.SETTINGS.scale)
-        )
-
-        self.COUNTER.apply_settings(
-            CounterSettings(
-                n_time=self.SETTINGS.n_time,
-                fs=self.SETTINGS.fs,
-                n_ch=self.SETTINGS.n_ch,
-                dispatch_rate=self.SETTINGS.dispatch_rate,
-                mod=None,
-            )
-        )
-
-    def network(self) -> ez.NetworkDefinition:
-        return (
-            (self.INPUT_CLOCK, self.COUNTER.INPUT_CLOCK),
-            (self.COUNTER.OUTPUT_SIGNAL, self.RANDOM.INPUT_SIGNAL),
-            (self.RANDOM.OUTPUT_SIGNAL, self.OUTPUT_SIGNAL),
-        )
-
-
-PinkNoiseSettings = NoiseSettings
-
-
-class PinkNoise(ez.Collection):
-    SETTINGS: PinkNoiseSettings
-
-    INPUT_CLOCK = ez.InputStream(ez.Flag)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    WHITE_NOISE = WhiteNoise()
-    FILTER = ButterworthFilter()
-
-    def configure(self) -> None:
-        self.WHITE_NOISE.apply_settings(self.SETTINGS)
-        self.FILTER.apply_settings(
-            ButterworthFilterSettings(
-                axis="time", order=1, cutoff=self.SETTINGS.fs * 0.01  # Hz
-            )
-        )
-
-    def network(self) -> ez.NetworkDefinition:
-        return (
-            (self.INPUT_CLOCK, self.WHITE_NOISE.INPUT_CLOCK),
-            (self.WHITE_NOISE.OUTPUT_SIGNAL, self.FILTER.INPUT_SIGNAL),
-            (self.FILTER.OUTPUT_SIGNAL, self.OUTPUT_SIGNAL),
-        )
-
-
-class AddState(ez.State):
-    queue_a: "asyncio.Queue[AxisArray]" = field(default_factory=asyncio.Queue)
-    queue_b: "asyncio.Queue[AxisArray]" = field(default_factory=asyncio.Queue)
-
-
-class Add(ez.Unit):
-    """Add two signals together.  Assumes compatible/similar axes/dimensions."""
-
-    STATE: AddState
-
-    INPUT_SIGNAL_A = ez.InputStream(AxisArray)
-    INPUT_SIGNAL_B = ez.InputStream(AxisArray)
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    @ez.subscriber(INPUT_SIGNAL_A)
-    async def on_a(self, msg: AxisArray) -> None:
-        self.STATE.queue_a.put_nowait(msg)
-
-    @ez.subscriber(INPUT_SIGNAL_B)
-    async def on_b(self, msg: AxisArray) -> None:
-        self.STATE.queue_b.put_nowait(msg)
-
-    @ez.publisher(OUTPUT_SIGNAL)
-    async def output(self) -> 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))
-
-
-class EEGSynthSettings(ez.Settings):
-    fs: float = 500.0  # Hz
-    n_time: int = 100
-    alpha_freq: float = 10.5  # Hz
-    n_ch: int = 8
-
-
-class EEGSynth(ez.Collection):
-    SETTINGS: EEGSynthSettings
-
-    OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
-
-    CLOCK = Clock()
-    NOISE = PinkNoise()
-    OSC = Oscillator()
-    ADD = Add()
-
-    def configure(self) -> None:
-        self.CLOCK.apply_settings(
-            ClockSettings(dispatch_rate=self.SETTINGS.fs / self.SETTINGS.n_time)
-        )
-
-        self.OSC.apply_settings(
-            OscillatorSettings(
-                n_time=self.SETTINGS.n_time,
-                fs=self.SETTINGS.fs,
-                n_ch=self.SETTINGS.n_ch,
-                dispatch_rate="ext_clock",
-                freq=self.SETTINGS.alpha_freq,
-            )
-        )
-
-        self.NOISE.apply_settings(
-            PinkNoiseSettings(
-                n_time=self.SETTINGS.n_time,
-                fs=self.SETTINGS.fs,
-                n_ch=self.SETTINGS.n_ch,
-                dispatch_rate="ext_clock",
-                scale=5.0,
-            )
-        )
-
-    def network(self) -> ez.NetworkDefinition:
-        return (
-            (self.CLOCK.OUTPUT_CLOCK, self.OSC.INPUT_CLOCK),
-            (self.CLOCK.OUTPUT_CLOCK, self.NOISE.INPUT_CLOCK),
-            (self.OSC.OUTPUT_SIGNAL, self.ADD.INPUT_SIGNAL_A),
-            (self.NOISE.OUTPUT_SIGNAL, self.ADD.INPUT_SIGNAL_B),
-            (self.ADD.OUTPUT_SIGNAL, self.OUTPUT_SIGNAL),
-        )

ezmsg_sigproc-1.2.2.dist-info/METADATA

@@ -1,36 +0,0 @@
-Metadata-Version: 2.1
-Name: ezmsg-sigproc
-Version: 1.2.2
-Summary: Timeseries signal processing implementations in ezmsg
-Home-page: https://github.com/iscoe/ezmsg
-Author: Griffin Milsap
-Author-email: griffin.milsap@jhuapl.edu
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: ezmsg >=3.3.0
-Requires-Dist: numpy >=1.19.5
-Requires-Dist: scipy >=1.6.3
-Provides-Extra: test
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
-
-# ezmsg.sigproc
-
-Timeseries signal processing implementations for ezmsg
-
-## Installation
-`pip install ezmsg-sigproc`
-
-## Dependencies
-* `ezmsg`
-* `numpy`
-* `scipy`
-
-## Setup (Development)
-1. Install `ezmsg` either using `pip install ezmsg` or set up the repo for development as described in the `ezmsg` readme.
-2. `cd` to this directory (`ezmsg-sigproc`) and run `pip install -e .`
-3. Signal processing modules are available under `import ezmsg.sigproc`
-

ezmsg_sigproc-1.2.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-ezmsg/sigproc/__init__.py,sha256=e3S0EcDGJlWIp2hddSFjvt633jfeZ4W7VyAeLpfTWVM,37
-ezmsg/sigproc/__version__.py,sha256=uuf4VNtTNA93fMhoAur9YafzaKJFnczY-H1SSCSuRVQ,22
-ezmsg/sigproc/butterworthfilter.py,sha256=rCS6nUg7_qV3N0A4dN07akRvCeOjisnNYZa-FpZJrj0,2144
-ezmsg/sigproc/decimate.py,sha256=xQgyGSrje9hiNjMpEpGOyAUluTxm5zgY66GcKur7oYs,1328
-ezmsg/sigproc/downsample.py,sha256=UYP5tPsnJusLR4_YB11FmjadOZgKkgXKclt8vidPAUM,2069
-ezmsg/sigproc/ewmfilter.py,sha256=WL9fhW_Z9L6u_n5xiI_XnK7o44QmQ8jXZSAcvzBn_Mw,3930
-ezmsg/sigproc/filter.py,sha256=iPTIIaiO7N68H7gL-SDBJNug6FzXAf2IIclTXIYB71k,4819
-ezmsg/sigproc/messages.py,sha256=JU9l_QNL7SKY54ac9SARKf5tSxWqSAyUqvfvoamHzKs,963
-ezmsg/sigproc/sampler.py,sha256=xPRWz648jio1pz8U2nwm9sdcB5jypwtvnkcDc9tilTU,10107
-ezmsg/sigproc/spectral.py,sha256=xF4xiE7D_xo7ly3sV-TZRoUUHRAcw_yo-cjk93x9vAw,4172
-ezmsg/sigproc/synth.py,sha256=Rjm_q7yF2Qd9ZxuclwC1bsCKb3dMly3a--_AGkswzmc,12929
-ezmsg/sigproc/window.py,sha256=-Qcit-Jrwfrjr7oD6waSMOTA0dVCOKMDjDqJMx4Wp2s,5616
-ezmsg_sigproc-1.2.2.dist-info/LICENSE.txt,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
-ezmsg_sigproc-1.2.2.dist-info/METADATA,sha256=gtVo3s4SRvt_P-8AsAZJhXSZ3ooQsM8pCY1uimxvaeg,1058
-ezmsg_sigproc-1.2.2.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-ezmsg_sigproc-1.2.2.dist-info/top_level.txt,sha256=Xas7TrqbpgKTacz3JJh_2R81t8Dusuk9QtHzyu5VXPQ,6
-ezmsg_sigproc-1.2.2.dist-info/RECORD,,

ezmsg_sigproc-1.2.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-ezmsg