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

tests/conftest.py

@@ -1,117 +0,0 @@
-import pytest
-import numpy as np
-
-from py_neuromodulation import (
-    nm_generator,
-    nm_stream_offline,
-    nm_settings,
-    nm_IO,
-    nm_define_nmchannels,
-)
-
-
-@pytest.fixture
-def setup_default_stream_fast_compute():
-    """This test function sets a data batch and automatic initialized M1 datafram
-
-    Args:
-        PATH_PYNEUROMODULATION (string): Path to py_neuromodulation repository
-
-    Returns:
-        ieeg_batch (np.ndarray): (channels, samples)
-        df_M1 (pd Dataframe): auto intialized table for rereferencing
-        settings_wrapper (settings.py): settings.json
-        fs (float): example sampling frequency
-    """
-
-    (
-        RUN_NAME,
-        PATH_RUN,
-        PATH_BIDS,
-        PATH_OUT,
-        datatype,
-    ) = nm_IO.get_paths_example_data()
-
-    (
-        raw,
-        data,
-        sfreq,
-        line_noise,
-        coord_list,
-        coord_names,
-    ) = nm_IO.read_BIDS_data(
-        PATH_RUN=PATH_RUN, BIDS_PATH=PATH_BIDS, datatype=datatype
-    )
-
-    nm_channels = nm_define_nmchannels.set_channels(
-        ch_names=raw.ch_names,
-        ch_types=raw.get_channel_types(),
-        reference="default",
-        bads=raw.info["bads"],
-        new_names="default",
-        used_types=("ecog", "dbs", "seeg"),
-        target_keywords=("MOV_RIGHT_CLEAN",),
-    )
-
-    settings = nm_settings.get_default_settings()
-    settings = nm_settings.reset_settings(settings)
-    settings["fooof"]["aperiodic"]["exponent"] = True
-    settings["fooof"]["aperiodic"]["offset"] = True
-    settings["features"]["fooof"] = True
-
-    stream = nm_stream_offline.Stream(
-        settings=settings,
-        nm_channels=nm_channels,
-        path_grids=None,
-        verbose=True,
-        sfreq=sfreq,
-        line_noise=line_noise,
-        coord_list=coord_list,
-        coord_names=coord_names,
-    )
-
-    return data, stream
-
-
-@pytest.fixture
-def setup_databatch():
-    """This test function sets a data batch and automatic initialized M1 datafram
-
-    Args:
-        PATH_PYNEUROMODULATION (string): Path to py_neuromodulation repository
-
-    Returns:
-        ieeg_batch (np.ndarray): (channels, samples)
-        df_M1 (pd Dataframe): auto intialized table for rereferencing
-        settings_wrapper (settings.py): settings.json
-        fs (float): example sampling frequency
-    """
-
-    (
-        RUN_NAME,
-        PATH_RUN,
-        PATH_BIDS,
-        PATH_OUT,
-        datatype,
-    ) = nm_IO.get_paths_example_data()
-
-    (
-        raw,
-        data,
-        sfreq,
-        line_noise,
-        coord_list,
-        coord_names,
-    ) = nm_IO.read_BIDS_data(
-        PATH_RUN=PATH_RUN, BIDS_PATH=PATH_BIDS, datatype=datatype
-    )
-
-    settings = nm_settings.get_default_settings()
-    settings = nm_settings.set_settings_fast_compute(settings)
-
-    generator = nm_generator.raw_data_generator(
-        data, settings, int(np.floor(sfreq))
-    )
-    data_batch = next(generator, None)
-
-    return [raw.ch_names, raw.get_channel_types(), raw.info["bads"], data_batch]

tests/test_all_examples.py

@@ -1,10 +0,0 @@
-from pathlib import Path
-import pytest
-import subprocess
-import runpy
-
-
-@pytest.mark.parametrize("example_filename", Path("examples").glob("*.py"))
-def test_run_through_all_test(example_filename):
-    print(f"Running {example_filename}")
-    runpy.run_path(example_filename)

tests/test_all_features.py

@@ -1,63 +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_stream(test_arr: np.array) -> nm_stream_abc.PNStream:
-    settings = nm_settings.get_default_settings()
-    settings["features"]["raw_hjorth"] = True
-    settings["features"]["return_raw"] = True
-    settings["features"]["bandpass_filter"] = True
-    settings["features"]["stft"] = True
-    settings["features"]["fft"] = True
-    settings["features"]["sharpwave_analysis"] = True
-    settings["features"]["fooof"] = True
-    settings["features"]["bursts"] = True
-    settings["features"]["linelength"] = True
-    settings["features"]["nolds"] = False
-    settings["features"]["mne_connectivity"] = False
-    settings["features"]["coherence"] = False
-
-    nm_channels = nm_define_nmchannels.get_default_channels_from_data(test_arr)
-
-    stream = nm_stream_offline.Stream(
-        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
-    )
-    return stream
-
-
-def test_all_features_random_array():
-    """This test runs's through all enabled features, and check's if they break
-    """
-    np.random.seed(0)
-    arr = np.random.random([2, 2000])
-    stream = get_example_stream(arr)
-
-    df = stream.run(arr)
-
-    assert df.shape[0] != 0  # terrible test
-
-
-def test_all_features_zero_array():
-
-    arr = np.zeros([2, 2000])
-    stream = get_example_stream(arr)
-
-    df = stream.run(arr)
-
-
-def test_all_features_NaN_array():
-
-    arr = np.empty([2, 2000])
-    arr[:] = np.nan
-
-    stream = get_example_stream(arr)
-
-    df = stream.run(arr)

tests/test_bispectra.py

@@ -1,70 +0,0 @@
-import pytest
-import mne
-import numpy as np
-
-from py_neuromodulation import (
-    nm_analysis,
-    nm_decode,
-    nm_define_nmchannels,
-    nm_IO,
-    nm_plots,
-    nm_settings,
-    nm_stream_offline,
-)
-
-
-def test_bispectrum():
-    (
-        RUN_NAME,
-        PATH_RUN,
-        PATH_BIDS,
-        PATH_OUT,
-        datatype,
-    ) = nm_IO.get_paths_example_data()
-
-    (
-        raw,
-        data,
-        sfreq,
-        line_noise,
-        coord_list,
-        coord_names,
-    ) = nm_IO.read_BIDS_data(
-        PATH_RUN=PATH_RUN, BIDS_PATH=PATH_BIDS, datatype=datatype
-    )
-
-    ch_names = raw.ch_names[4]
-    ch_types = raw.get_channel_types()[4]
-
-    nm_channels = nm_define_nmchannels.set_channels(
-        ch_names=[ch_names],
-        ch_types=[ch_types],
-        reference="default",
-        bads=None,
-        new_names="default",
-        used_types=("ecog", "dbs", "seeg"),
-        target_keywords=("MOV_RIGHT_CLEAN",),
-    )
-
-    settings = nm_settings.get_default_settings()
-    settings = nm_settings.reset_settings(settings)
-
-    settings["features"]["bispectrum"] = True
-
-    stream = nm_stream_offline.Stream(
-        settings=settings,
-        nm_channels=nm_channels,
-        path_grids=None,
-        verbose=True,
-        sfreq=sfreq,
-        line_noise=line_noise,
-        coord_list=coord_list,
-        coord_names=coord_names,
-    )
-
-    features = stream.run(np.expand_dims(data[3, :], axis=0))
-
-    assert (
-        features["ECOG_RIGHT_1_Bispectrum_phase_mean_whole_fband_range"].sum()
-        != 0
-    )

tests/test_bursts.py

@@ -1,105 +0,0 @@
-import pytest
-import numpy as np
-from py_neuromodulation import (
-    nm_bursts,
-    nm_settings,
-    nm_stream_offline,
-    nm_define_nmchannels,
-)
-
-
-def test_init_wrong_fband():
-    settings = nm_settings.get_default_settings()
-    settings["burst_settings"]["frequency_bands"] = ["wrong_band"]
-    with pytest.raises(Exception):
-        nm_bursts.Burst.test_settings(
-            settings,
-            [
-                "ch1",
-                "ch2",
-            ],
-            1000,
-        )
-
-
-def test_init_wrong_treshold():
-    settings = nm_settings.get_default_settings()
-    settings["burst_settings"]["threshold"] = -1
-    with pytest.raises(Exception):
-        nm_bursts.Burst.test_settings(
-            settings,
-            [
-                "ch1",
-                "ch2",
-            ],
-            1000,
-        )
-
-
-def test_init_wrong_timeduration():
-    settings = nm_settings.get_default_settings()
-    settings["burst_settings"]["time_duration_s"] = -1
-    with pytest.raises(Exception):
-        nm_bursts.Burst.test_settings(
-            settings,
-            [
-                "ch1",
-                "ch2",
-            ],
-            1000,
-        )
-
-
-def test_init_wrong_burst_feature_init():
-    settings = nm_settings.get_default_settings()
-    settings["burst_settings"]["burst_features"]["duration"] = -1
-    with pytest.raises(Exception):
-        nm_bursts.Burst.test_settings(
-            settings,
-            [
-                "ch1",
-                "ch2",
-            ],
-            1000,
-        )
-
-
-def test_bursting_duration():
-    np.random.seed(0)
-    settings = nm_settings.get_default_settings()
-    settings["features"]["bursts"] = True
-    settings["postprocessing"]["feature_normalization"] = False
-    TIME_DURATION = 10
-    sfreq = 1000
-    NUM_CH = 1
-    time_points_beta = np.arange(0, 1, 1 / sfreq)
-    beta_freq = 18
-
-    beta_wave = np.sin(2 * np.pi * beta_freq * time_points_beta)
-
-    ch_names = ["ch0"]
-
-    bursts = nm_bursts.Burst(settings, ch_names, sfreq)
-
-    for _ in range(10):
-        np.random.seed(0)
-        data = np.random.random([NUM_CH, 1 * sfreq])
-        f = bursts.calc_feature(data, {})
-
-    np.random.seed(0)
-    # the percentile of the hilbert transform of a continuous oscillation will be high
-    # select better max amplitude
-    bursts = nm_bursts.Burst(settings, ch_names, sfreq)
-    f_burst = bursts.calc_feature(
-        beta_wave + np.random.random([NUM_CH, 1 * sfreq]), {}
-    )
-
-    assert (
-        f["ch0_bursts_low beta_amplitude_max"]
-        < f_burst["ch0_bursts_low beta_amplitude_max"]
-    )
-
-    assert (
-        f["ch0_bursts_low beta_duration_max"]
-        < f_burst["ch0_bursts_low beta_duration_max"]
-    )

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