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

tests/test_feature_sampling_rates.py

@@ -1,143 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-
-from py_neuromodulation import (
-    nm_settings,
-    nm_stream_offline,
-    nm_define_nmchannels,
-    nm_stream_abc,
-)
-
-
-def get_example_settings(test_arr: np.array) -> nm_stream_abc.PNStream:
-    settings = nm_settings.set_settings_fast_compute(
-        nm_settings.get_default_settings()
-    )
-
-    nm_channels = nm_define_nmchannels.get_default_channels_from_data(test_arr)
-
-    return settings, nm_channels
-
-
-def test_different_sampling_rate_100Hz():
-    sampling_rate_features = 100
-
-    arr_test = np.random.random([2, 1020])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["sampling_rate_features_hz"] = sampling_rate_features
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-
-    df = stream.run(arr_test)
-
-    # check the difference between time points
-
-    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
-
-
-def test_different_sampling_rate_10Hz():
-    sampling_rate_features = 10
-
-    arr_test = np.random.random([2, 1200])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["sampling_rate_features_hz"] = sampling_rate_features
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-
-    df = stream.run(arr_test)
-
-    # check the difference between time points
-
-    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
-
-
-def test_different_sampling_rate_1Hz():
-    sampling_rate_features = 1
-
-    arr_test = np.random.random([2, 3000])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["sampling_rate_features_hz"] = sampling_rate_features
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-
-    df = stream.run(arr_test)
-
-    # check the difference between time points
-
-    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
-
-
-def test_different_sampling_rate_0DOT1Hz():
-    sampling_rate_features = 0.1
-
-    arr_test = np.random.random([2, 30000])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["sampling_rate_features_hz"] = sampling_rate_features
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-
-    df = stream.run(arr_test)
-
-    # check the difference between time points
-
-    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
-
-
-def test_wrong_initalization_of_segment_length_features_ms_and_osc_window_length():
-    segment_length_features_ms = 800
-
-    arr_test = np.random.random([2, 1200])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["segment_length_features_ms"] = 800
-    settings["fft_settings"]["windowlength_ms"] = 1000
-
-    with pytest.raises(Exception):
-        stream = nm_stream_offline.Stream(
-            sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-        )
-
-
-def test_different_segment_lengths():
-    segment_length_features_ms = 800
-
-    arr_test = np.random.random([2, 1200])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["segment_length_features_ms"] = segment_length_features_ms
-    settings["fft_settings"]["windowlength_ms"] = segment_length_features_ms
-
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-
-    df_seglength_800 = stream.run(arr_test)
-
-    segment_length_features_ms = 1000
-
-    arr_test = np.random.random([2, 1200])
-    settings, nm_channels = get_example_settings(arr_test)
-
-    settings["segment_length_features_ms"] = segment_length_features_ms
-    settings["fft_settings"]["windowlength_ms"] = segment_length_features_ms
-
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-
-    df_seglength_1000 = stream.run(arr_test)
-    # check the difference between time points
-
-    assert (
-        df_seglength_1000.iloc[0]["ch0-avgref_fft_theta_mean"]
-        != df_seglength_800.iloc[0]["ch0-avgref_fft_theta_mean"]
-    )

tests/test_fooof.py

@@ -1,16 +0,0 @@
-from py_neuromodulation import nm_generator
-
-
-def test_fooof_features(setup_default_stream_fast_compute):
-
-    data, stream = setup_default_stream_fast_compute
-
-    generator = nm_generator.raw_data_generator(
-        data, stream.settings, stream.sfreq
-    )
-    data_batch = next(generator, None)
-    feature_series = stream.run_analysis.process(data_batch)
-    # since the settings can define searching for "max_n_peaks" peaks
-    # there can be None's in the feature_series
-    # with a non successful fit, aperiodic features can also be None
-    assert feature_series is not None

tests/test_initalization_offline_stream.py

@@ -1,41 +0,0 @@
-import numpy as np
-import pytest
-
-import py_neuromodulation as nm
-
-
-def test_stream_init():
-    """Test if stream initialization with passed data will setup nm_channels correctly"""
-    np.random.seed(0)
-    data = np.random.random((10, 1000))
-    sfreq = 100
-    stream = nm.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=11)
-
-    assert stream.nm_channels.shape[0] == 10
-    assert stream.settings["sampling_rate_features_hz"] == 11
-
-
-def test_stream_init_no_sfreq():
-    """Check if stream initialization without sfreq will raise an error"""
-    np.random.seed(0)
-    data = np.random.random((10, 1000))
-    with pytest.raises(Exception):
-        nm.Stream(data=data, sampling_rate_features_hz=11)
-
-
-def test_init_warning_no_used_channel():
-    """Check if a warning is raised when a stream is initialized with nm_channels, but no row has used == 1 and target == 0"""
-    np.random.seed(0)
-    data = np.random.random((10, 1000))
-    sfreq = 1000
-    stream = nm.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=11)
-    channels = stream.nm_channels
-    channels["used"] = 0
-
-    with pytest.raises(Exception):
-        nm.Stream(
-            sfreq=sfreq,
-            data=data,
-            nm_channels=channels,
-            sampling_rate_features_hz=11,
-        )

tests/test_multiprocessing.py

@@ -1,58 +0,0 @@
-import py_neuromodulation as pn
-import numpy as np
-from py_neuromodulation import nm_settings
-import pytest
-
-
-@pytest.fixture
-def get_stream():
-    NUM_CHANNELS = 10
-    NUM_DATA = 10000
-    sfreq = 1000  # Hz
-    sampling_rate_features_hz = 3  # Hz
-
-    data = np.random.random([NUM_CHANNELS, NUM_DATA])
-
-    stream = pn.Stream(
-        sfreq=sfreq,
-        data=data,
-        sampling_rate_features_hz=sampling_rate_features_hz,
-    )
-    stream.nm_channels.loc[0, "target"] = 1
-    stream.nm_channels.loc[0, "used"] = 0
-    stream.settings["postprocessing"]["feature_normalization"] = False
-    stream.settings["segment_length_features_ms"] = 5000
-    for feature in stream.settings["features"]:
-        stream.settings["features"][feature] = False
-    stream.settings["features"]["nolds"] = False
-    stream.settings["features"]["fooof"] = True
-    stream.settings["features"]["bursts"] = False
-    stream.settings["features"]["mne_connectivity"] = False
-    stream.settings["coherence"]["channels"] = [["ch1", "ch2"]]
-    return stream
-
-
-def test_setting_exception(get_stream):
-    stream = get_stream
-    stream.settings["features"]["burst"] = True
-
-    with pytest.raises(Exception) as e_info:
-        stream.run(parallel=True, n_jobs=-1)
-
-
-def test_multiprocessing_and_sequntial_features(get_stream):
-    stream_seq = get_stream
-    features_sequential = stream_seq.run(parallel=False)
-
-    stream_par = get_stream
-    features_multiprocessing = stream_par.run(parallel=True, n_jobs=-1)
-
-    for column in features_sequential.columns:
-        if "fooof" in column:
-            # fooof results are different in multiprocessing and sequential processing
-            # This tests fails on Linux and Windows but passes on Mac OS; no idea why
-            continue
-
-        assert features_sequential[column].equals(
-            features_multiprocessing[column]
-        ), f"Column {column} is not equal between sequential and parallel dataframes computation"

tests/test_nan_values.py

@@ -1,29 +0,0 @@
-import numpy as np
-
-import py_neuromodulation as nm
-
-
-def test_stream_with_none_data():
-    """Test if passing None as the data to a Stream object results in None features."""
-
-    fs = 1000
-    data = np.random.random([2, 2000])
-    data[0, :] = None
-
-    stream = nm.Stream(fs, data)
-
-    features = stream.run(data)
-
-    # assert if all features if name ch0 are None
-    assert len(
-        [f for f in features.columns if "ch0" in f and features[f].isna().all()]
-    ) == len([f for f in features if "ch0" in f])
-
-    # and check if all features of the second channel are not None
-    assert len(
-        [
-            f
-            for f in features.columns
-            if "ch1" in f and features[f].notna().all()
-        ]
-    ) == len([f for f in features if "ch1" in f])

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"
-        )