py-neuromodulation 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

tests/test_nm_filter.py

@@ -1,95 +0,0 @@
-"""Test the nm_filter module."""
-import numpy as np
-from py_neuromodulation import nm_filter
-import pytest
-
-
-class TestMNEFilterData:
-    """Test filter_data method of MNEFilter class."""
-
-    @pytest.mark.parametrize(
-        "filter_length",
-        ["500ms", "999ms", "1999ms", "3999ms", "2s"],
-    )
-    def test_filter_length(self, filter_length) -> None:
-        """Test different filter lengths."""
-        f_ranges = [
-            [13, 35],
-        ]
-        sfreq = 4000
-        duration = 10
-        times = np.linspace(0, duration, int(duration * sfreq))
-        bandpass_filter = nm_filter.MNEFilter(
-            f_ranges=f_ranges,
-            sfreq=sfreq,
-            filter_length=filter_length,
-            l_trans_bandwidth=8,  # transition bandwidth needs to be adjusted for smaller filter length
-            h_trans_bandwidth=8,
-            verbose=None,
-        )
-        oscill_freqs = 50
-        data = np.sin(2 * np.pi * times * oscill_freqs)
-        data_filtered = bandpass_filter.filter_data(data)
-        assert data_filtered.shape == (
-            1,
-            len(f_ranges),
-            duration * sfreq,
-        )
-
-    def test_filter_1d(self) -> None:
-        """Test filtering of 1d array with multiple frequency ranges."""
-        f_ranges = [
-            [4, 8],
-            [8, 12],
-            [13, 35],
-            [60, 200],
-            [200, 500],
-        ]
-        sfreq = 4000
-        duration = 10
-        times = np.linspace(0, duration, int(duration * sfreq))
-        bandpass_filter = nm_filter.MNEFilter(
-            f_ranges=f_ranges,
-            sfreq=sfreq,
-            filter_length="999ms",
-            l_trans_bandwidth=4,
-            h_trans_bandwidth=4,
-            verbose=None,
-        )
-        oscill_freqs = 50
-        data = np.sin(2 * np.pi * times * oscill_freqs)
-        data_filtered = bandpass_filter.filter_data(data)
-        assert data_filtered.shape == (
-            1,
-            len(f_ranges),
-            duration * sfreq,
-        )
-
-    def test_filter_2d(self) -> None:
-        """Test filtering of 2d array with multiple frequency ranges and multiple channels."""
-        f_ranges = [
-            [4, 8],
-            [8, 12],
-            [13, 35],
-            [60, 200],
-            [200, 500],
-        ]
-        sfreq = 4000
-        duration = 10
-        times = np.linspace(0, duration, int(duration * sfreq))
-        bandpass_filter = nm_filter.MNEFilter(
-            f_ranges=f_ranges,
-            sfreq=sfreq,
-            filter_length="999ms",
-            l_trans_bandwidth=4,
-            h_trans_bandwidth=4,
-            verbose=None,
-        )
-        oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
-        data = np.sin(2 * np.pi * times * oscill_freqs)
-        data_filtered = bandpass_filter.filter_data(data)
-        assert data_filtered.shape == (
-            oscill_freqs.shape[0],
-            len(f_ranges),
-            duration * sfreq,
-        )

tests/test_nm_resample.py

@@ -1,63 +0,0 @@
-"""Test the nm_resample module."""
-import numpy as np
-
-from py_neuromodulation import nm_resample
-
-
-def test_upsample():
-    """Test case where data is upsampled."""
-    sfreq_old = 4000.0
-    duration = 10
-    times = np.linspace(0, duration, int(duration * sfreq_old))
-    oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
-    data = np.sin(2 * np.pi * times * oscill_freqs)
-
-    sfreq_new = 1000.0
-    resample = nm_resample.Resampler(
-        resample_freq_hz=sfreq_new,
-        sfreq=sfreq_old,
-    )
-    data_resampled = resample.process(data)
-    assert data_resampled.shape[-1] == int(duration * sfreq_new)
-    # This test only works when ratio of old and new sfreq is an integer
-    # It will also only work up to a certain decimal precision.
-    resampled_naive = data[..., :: int(sfreq_old / sfreq_new)]
-    np.testing.assert_array_almost_equal(
-        data[..., :: int(sfreq_old / sfreq_new)],
-        resampled_naive,
-        decimal=2,
-    )
-
-
-def test_downsample():
-    """Test case where data is downsampled."""
-    sfreq_old = 1000.0
-    duration = 10
-    times = np.linspace(0, duration, int(duration * sfreq_old))
-    oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
-    data = np.sin(2 * np.pi * times * oscill_freqs)
-
-    sfreq_new = 4000.0
-    resample = nm_resample.Resampler(
-        resample_freq_hz=sfreq_new,
-        sfreq=sfreq_old,
-    )
-    data_resampled = resample.process(data)
-    assert data_resampled.shape[-1] == int(duration * sfreq_new)
-
-
-def test_no_resample():
-    """Test case where no resampling is performed."""
-    sfreq_old = 1000.0
-    duration = 10
-    times = np.linspace(0, duration, int(duration * sfreq_old))
-    oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
-    data = np.sin(2 * np.pi * times * oscill_freqs)
-
-    sfreq_new = 1000.0
-    resample = nm_resample.Resampler(
-        resample_freq_hz=sfreq_new,
-        sfreq=sfreq_old,
-    )
-    data_resampled = resample.process(data)
-    np.testing.assert_array_almost_equal(data, data_resampled)

tests/test_normalization_settings.py

@@ -1,146 +0,0 @@
-import os
-import unittest
-import pytest
-import numpy as np
-
-from py_neuromodulation import nm_normalization
-
-
-def test_raw_normalization_init():
-    with pytest.raises(Exception):
-        nm_normalization.RawNormalizer(
-            sfreq=1000,
-            sampling_rate_features_hz=500,
-            normalization_method="meann",
-            normalization_time_s=30,
-            clip=3,
-        )
-
-
-def test_feature_normalization_init():
-    with pytest.raises(Exception):
-        nm_normalization.FeatureNormalizer(
-            sampling_rate_features_hz=500,
-            normalization_method="meann",
-            normalization_time_s=30,
-            clip=3,
-        )
-
-
-def test_process_norm_features():
-    norm = nm_normalization.FeatureNormalizer(
-        sampling_rate_features_hz=500,
-        normalization_method="mean",
-        normalization_time_s=30,
-        clip=3,
-    )
-    data = np.ones([1, 5])
-    data_normed = norm.process(data)
-
-    assert np.all(np.isfinite(data_normed) == True)
-
-    assert np.all(np.equal(data, norm.previous) == 1)
-
-
-def test_previous_size_FeatureNorm():
-    norm = nm_normalization.FeatureNormalizer(
-        sampling_rate_features_hz=10,
-        normalization_method="zscore",
-        normalization_time_s=10,
-        clip=3,
-    )
-
-    num_features = 5
-
-    for _ in range(150):
-        np.random.seed(0)
-        data = norm.process(np.random.random([1, num_features]))
-
-    assert norm.previous.shape[0] < norm.num_samples_normalize
-
-
-def test_zscore_feature_analysis():
-    norm = nm_normalization.FeatureNormalizer(
-        sampling_rate_features_hz=10,
-        normalization_method="zscore",
-        normalization_time_s=30,
-        clip=False,
-    )
-
-    num_features = 5
-
-    for _ in range(400):
-        np.random.seed(0)
-        data_to_norm = np.random.random([1, num_features])
-        data_normed = norm.process(data_to_norm)
-
-    expect_res = (
-        norm.previous[:, 0].std() * data_normed[0, 0]
-        + norm.previous[:, 0].mean()
-    )
-
-    assert pytest.approx(expect_res, 0.1) == data_to_norm[0, 0]
-
-
-def test_zscore_raw_analysis():
-    norm = nm_normalization.RawNormalizer(
-        sampling_rate_features_hz=10,
-        normalization_method="zscore",
-        normalization_time_s=30,
-        sfreq=10,
-        clip=False,
-    )
-
-    num_samples = 100
-
-    for _ in range(400):
-        data_to_norm = np.random.random([1, num_samples])
-        data_normed = norm.process(data_to_norm)
-
-    expect_res = (
-        norm.previous[:, 0].std() * data_normed[0, 0]
-        + norm.previous[:, 0].mean()
-    )
-
-    np.testing.assert_allclose(
-        expect_res, data_to_norm[0, 0], rtol=0.1, atol=0.1
-    )
-
-
-def test_all_norm_methods_raw():
-    for norm_method in [e.value for e in nm_normalization.NORM_METHODS]:
-        norm = nm_normalization.RawNormalizer(
-            sampling_rate_features_hz=10,
-            normalization_method=norm_method,
-            normalization_time_s=30,
-            sfreq=10,
-            clip=False,
-        )
-
-        num_samples = 10
-
-        for _ in range(10):
-            np.random.seed(0)
-            data_to_norm = np.random.random([1, num_samples])
-            data_normed = norm.process(data_to_norm)
-
-        assert np.all(np.isfinite(data_normed) == True)
-
-
-def test_all_norm_methods_feature():
-    for norm_method in [e.value for e in nm_normalization.NORM_METHODS]:
-        norm = nm_normalization.FeatureNormalizer(
-            sampling_rate_features_hz=10,
-            normalization_method=norm_method,
-            normalization_time_s=30,
-            clip=False,
-        )
-
-        num_samples = 10
-
-        for i in range(10):
-            np.random.seed(i)
-            data_to_norm = np.random.random([1, num_samples])
-            data_normed = norm.process(data_to_norm)
-
-        assert np.all(np.isfinite(data_normed) == True)

tests/test_notch_filter.py

@@ -1,31 +0,0 @@
-import numpy as np
-import pytest
-from scipy import fft, signal
-
-from py_neuromodulation import nm_filter
-
-
-def test_notch_filter_setup():
-
-    # by Nyquist theorem, frequencies are computed up to half sfreq
-    for sfreq in [150, 200, 500, 1000]:
-        line_noise = 50
-
-        notch_filter = nm_filter.NotchFilter(sfreq, line_noise)
-
-        # the computed filter is saved in self.filter_bank
-
-        data = np.random.random(sfreq)
-        filtered_dat = notch_filter.process(data)
-
-        Z_filtered = np.abs(fft.rfft(filtered_dat))
-        Z_nonfiltered = np.abs(fft.rfft(data))
-        freqs = fft.rfftfreq(sfreq, 1 / sfreq)
-        idx = (np.abs(freqs - line_noise)).argmin()
-
-        assert np.mean(Z_filtered[idx - 1 : idx + 1]) < np.mean(
-            Z_nonfiltered[idx - 1 : idx + 1]
-        ), (
-            f"testing notch filter with sampling frequency {line_noise} failed"
-            f" for comparison fft power vs no filtering"
-        )