py-neuromodulation 0.1.4__tar.gz → 0.1.7__tar.gz

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/.github/workflows/tests.yml

@@ -43,17 +43,13 @@ jobs:
         with:
           packages: binutils qtbase5-dev qt5-qmake libpugixml1v5
       - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v7
         with:
-          version: "0.4.12"
-          enable-cache: true
+          python-version: "${{ matrix.python }}"
+          enable-cache: auto
+          activate-environment: "true"
           cache-dependency-glob: "**/pyproject.toml"
-      - name: Install Python and dependencies
-        run: |
-          uv python install ${{ matrix.python }}
-          uv venv
-          uv pip install .[test]
+      - name: Install dependencies
+        run: uv pip install .[test]
       - name: Run tests
-        run: |
-          ${{ (runner.os == 'Windows' && '.venv\Scripts\activate') || 'source .venv/bin/activate' }}
-          pytest -n auto tests/
+        run: pytest -n auto tests/

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py_neuromodulation
-Version: 0.1.4
+Version: 0.1.7
 Summary: Real-time analysis of intracranial neurophysiology recordings.
 Project-URL: Homepage, https://neuromodulation.github.io/py_neuromodulation/
 Project-URL: Documentation, https://neuromodulation.github.io/py_neuromodulation/
@@ -92,9 +92,18 @@ Requires-Dist: pytest-xdist; extra == 'test'
 Requires-Dist: pytest>=8.0.2; extra == 'test'
 Description-Content-Type: text/x-rst
 
+
+
 py_neuromodulation
 ==================
 
+Journal of Open Source Science publication:
+
+.. image:: https://joss.theoj.org/papers/10.21105/joss.08258/status.svg
+   :target: https://doi.org/10.21105/joss.08258
+
+
+
 Documentation: https://neuromodulation.github.io/py_neuromodulation/
 
 Analyzing neural data can be a troublesome, trial and error prone,

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/README.rst

@@ -1,6 +1,15 @@
+
+
 py_neuromodulation
 ==================
 
+Journal of Open Source Science publication:
+
+.. image:: https://joss.theoj.org/papers/10.21105/joss.08258/status.svg
+   :target: https://doi.org/10.21105/joss.08258
+
+
+
 Documentation: https://neuromodulation.github.io/py_neuromodulation/
 
 Analyzing neural data can be a troublesome, trial and error prone,

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/docs/source/index.rst

@@ -51,6 +51,14 @@ The original intention for writing this toolbox was movement decoding from invas
 The application however could be any neural decoding and analysis problem.
 *py_neuromodulation* offers wrappers around common practice machine learning methods for efficient analysis.
 
+
+Journal of Open Source Software publication
+-------------------------------------------
+
+.. image:: https://joss.theoj.org/papers/10.21105/joss.08258/status.svg
+   :target: https://doi.org/10.21105/joss.08258
+
+
 References
 ----------
 

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/default_settings.yaml

@@ -54,10 +54,10 @@ raw_normalization_settings:
   clip: 3
 
 preprocessing_filter:
-  bandstop_filter: true
-  lowpass_filter: true
-  highpass_filter: true
-  bandpass_filter: true
+  bandstop_filter: false
+  lowpass_filter: false
+  highpass_filter: false
+  bandpass_filter: false
   bandstop_filter_settings: [100, 160] # [low_hz, high_hz]
   bandpass_filter_settings: [3, 200] # [hz, _hz]
   lowpass_filter_cutoff_hz: 200
@@ -245,3 +245,4 @@ bispectrum_settings:
     mean: true
     sum: true
     var: true
+

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/features/fooof.py

@@ -87,17 +87,21 @@ class FooofAnalyzer(NMFeature):
 
         spectra = np.abs(rfft(data[:, -self.num_samples :]))  # type: ignore
 
-        self.fm.fit(self.f_vec, spectra, self.settings.freq_range_hz)
+        try:
+            self.fm.fit(self.f_vec, spectra, self.settings.freq_range_hz)
+        except:
+            failed_fits = list(range(len(self.ch_names)))
 
         if not self.fm.has_model or self.fm.null_inds_ is None:
-            raise RuntimeError("FOOOF failed to fit model to data.")
-
-        failed_fits: list[int] = self.fm.null_inds_
+            failed_fits = list(range(len(self.ch_names)))
+        else:
+            failed_fits: list[int] = self.fm.null_inds_
 
         feature_results = {}
         for ch_idx, ch_name in enumerate(self.ch_names):
             FIT_PASSED = ch_idx not in failed_fits
-            exp = self.fm.get_params("aperiodic_params", "exponent")[ch_idx]
+            if FIT_PASSED:
+                exp = self.fm.get_params("aperiodic_params", "exponent")[ch_idx]
 
             for feat in self.settings.aperiodic.get_enabled():
                 f_name = f"{ch_name}_fooof_a_{self.feat_name_map[feat]}"

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/features/sharpwaves.py

@@ -85,16 +85,16 @@ class SharpwaveSettings(NMBaseModel):
             self.estimator[est] = []
 
     @model_validator(mode="after")
-    def test_settings(cls, settings):
+    def test_settings(self):
         # check if all features are also enabled via an estimator
-        estimator_list = [est for list_ in settings.estimator.values() for est in list_]
+        estimator_list = [est for list_ in self.estimator.values() for est in list_]
 
-        for used_feature in settings.sharpwave_features.get_enabled():
+        for used_feature in self.sharpwave_features.get_enabled():
             assert (
                 used_feature in estimator_list
             ), f"Add estimator key for {used_feature}"
 
-        return settings
+        return self
 
 
 class SharpwaveAnalyzer(NMFeature):
@@ -151,7 +151,9 @@ class SharpwaveAnalyzer(NMFeature):
             self.filters = np.vstack([f for _, f in self.list_filter])
             self.filters = np.tile(self.filters[None, :, :], (len(self.ch_names), 1, 1))
         else:
-            self.filters = [np.tile(f, (len(self.ch_names), 1)) for _, f in self.list_filter]
+            self.filters = [
+                np.tile(f, (len(self.ch_names), 1)) for _, f in self.list_filter
+            ]
 
         self.used_features = self.sw_settings.sharpwave_features.get_enabled()
 
@@ -282,7 +284,9 @@ class SharpwaveAnalyzer(NMFeature):
                 if feature_name == "num_peaks":
                     key_name = f"{ch_name}_Sharpwave_{feature_name}_{filter_name}"
                     if len(waveform_results[feature_name]) == 1:
-                        dict_ch_features[key_name][key_name_pt] = waveform_results[feature_name][0]
+                        dict_ch_features[key_name][key_name_pt] = waveform_results[
+                            feature_name
+                        ][0]
                         continue
                     else:
                         raise ValueError("num_peaks should be a list with length 1")
@@ -317,8 +321,12 @@ class SharpwaveAnalyzer(NMFeature):
                 for ch_name in self.ch_names:
                     for filter_name in self.filter_names:
                         key_name = f"{ch_name}_Sharpwave_num_peaks_{filter_name}"
-                        feature_results[key_name] = np_mean([dict_ch_features[key_name]["Peak"],
-                                                            dict_ch_features[key_name]["Trough"]])
+                        feature_results[key_name] = np_mean(
+                            [
+                                dict_ch_features[key_name]["Peak"],
+                                dict_ch_features[key_name]["Trough"],
+                            ]
+                        )
         else:
             # otherwise, save all write all "flattened" key value pairs in feature_results
             for key, subdict in dict_ch_features.items():

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/processing/rereference.py

@@ -55,7 +55,7 @@ class ReReferencer(NMPreprocessor):
             # if ind not in channels_used:
             #    continue
             ref = refs[ind]
-            if ref.lower() == "none" or pd.isnull(ref):
+            if ref.lower() == "none" or pd.isnull(ref) or channels["status"][ind] != "good":
                 ref_idx = None
                 continue
             if ref.lower() == "average":
@@ -78,7 +78,12 @@ class ReReferencer(NMPreprocessor):
                         )
                     ref_idx.append(ch_names.index(ref_chan))
             ref_matrix[ind, ref_idx] = -1 / len(ref_idx)
+        
         self.ref_matrix = ref_matrix
+        
+        # only index good channels
+        good_idxs = np.where(channels["status"] == "good")[0]
+        self.ref_matrix = self.ref_matrix[good_idxs, :][:, good_idxs]
 
     def process(self, data: np.ndarray) -> np.ndarray:
         """Rereference data according to the initialized ReReferencer class.

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/stream/data_processor.py

@@ -143,12 +143,17 @@ class DataProcessor:
     ) -> tuple[list[str], list[str], list[int], np.ndarray]:
         """Get used feature and label info from channels"""
         channels = self.channels
-        ch_names_used = channels[channels["used"] == 1]["new_name"].tolist()
-        ch_types_used = channels[channels["used"] == 1]["type"].tolist()
+        ch_names_used = channels.query("used == 1 and status == 'good'")["new_name"].tolist()
+        ch_types_used = channels.query("used == 1 and status == 'good'")["type"].tolist()
 
         # used channels for feature estimation
         feature_idx = np.where(channels["used"] & ~channels["target"])[0].tolist()
 
+        # remove the idxs of status == "bad"
+        feature_idx = [
+            idx for idx in feature_idx if channels.loc[idx, "status"] == "good"
+        ]
+
         # If multiple targets exist, select only the first
         label_idx = np.where(channels["target"] == 1)[0]
 

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/utils/channels.py

@@ -46,6 +46,7 @@ def set_channels(
             For this, the channel names must contain the substring "_L_" and/or
             "_R_" (lower or upper case). CAVE: Adjacent channels will be
             determined using the sort() function.
+            Re-reference can be also "average" for common-average-referencing
         bads :  str | list of str, default: None
             channels that should be marked as bad and not be used for
             average re-referencing etc.
@@ -127,9 +128,12 @@ def set_channels(
     if isinstance(reference, str):
         if reference.lower() == "default":
             df = _get_default_references(df=df, ch_names=ch_names, ch_types=ch_types)
+        elif reference.lower() == "average":
+            df["rereference"] = ["average" if df["used"][ch_idx] == 1 else "None"
+                                 for ch_idx in range(len(ch_names))]
         else:
             raise ValueError(
-                "`reference` must be either `default`, `None` or "
+                "`reference` must be either `default`, `None`, `average` or "
                 "an iterable of new reference channel names. "
                 f"Got: {reference}."
             )

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/utils/pydantic_extensions.py

@@ -5,10 +5,11 @@ from typing import (
     get_args,
     get_type_hints,
     Literal,
+    Unpack,
+    TypedDict,
     cast,
     Sequence,
 )
-from typing_extensions import Unpack, TypedDict
 from pydantic import BaseModel, GetCoreSchemaHandler, ConfigDict
 
 from pydantic_core import (
@@ -118,23 +119,13 @@ class _NMExtraFieldInputs(TypedDict, total=False):
     custom_metadata: dict[str, Any]
 
 
-class _NMFieldInfoInputs(_FieldInfoInputs, _NMExtraFieldInputs, total=False):
-    """Combine pydantic FieldInfo inputs with PyNM additional inputs"""
-
-    pass
-
-
-class _NMFromFieldInfoInputs(_FromFieldInfoInputs, _NMExtraFieldInputs, total=False):
-    """Combine pydantic FieldInfo.from_field inputs with PyNM additional inputs"""
-
-    pass
-
-
 class NMFieldInfo(FieldInfo):
     # Add default values for any other custom fields here
     _default_values = {}
 
-    def __init__(self, **kwargs: Unpack[_NMFieldInfoInputs]) -> None:
+    def __init__(
+        self, **kwargs: Unpack[_FieldInfoInputs | _NMExtraFieldInputs]
+    ) -> None:
         self.sequence: bool = kwargs.pop("sequence", False)  # type: ignore
         self.custom_metadata: dict[str, Any] = kwargs.pop("custom_metadata", {})
         super().__init__(**kwargs)
@@ -162,7 +153,7 @@ class NMFieldInfo(FieldInfo):
     @staticmethod
     def from_field(
         default: Any = PydanticUndefined,
-        **kwargs: Unpack[_NMFromFieldInfoInputs],
+        **kwargs: Unpack[_FromFieldInfoInputs | _NMExtraFieldInputs],
     ) -> "NMFieldInfo":
         if "annotation" in kwargs:
             raise TypeError('"annotation" is not permitted as a Field keyword argument')
@@ -178,7 +169,7 @@ class NMFieldInfo(FieldInfo):
 
 def NMField(
     default: Any = PydanticUndefined,
-    **kwargs: Unpack[_NMFromFieldInfoInputs],
+    **kwargs: Unpack[_FromFieldInfoInputs | _NMExtraFieldInputs],
 ) -> Any:
     return NMFieldInfo.from_field(default=default, **kwargs)
 
@@ -197,7 +188,7 @@ class NMBaseModel(BaseModel):
             super().__init__(*args, **kwargs)
             return
 
-        field_names = list(self.model_fields.keys())
+        field_names = list(self.__class__.model_fields.keys())
         # If we have more positional args than fields, that's an error
         if len(args) > len(field_names):
             raise ValueError(
@@ -238,7 +229,7 @@ class NMBaseModel(BaseModel):
 
     @property
     def fields(self) -> dict[str, FieldInfo | NMFieldInfo]:
-        return self.model_fields  # type: ignore
+        return self.__class__.model_fields  # type: ignore
 
     def serialize_with_metadata(self):
         result: dict[str, Any] = {"__field_type__": self.__class__.__name__}

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/py_neuromodulation/utils/types.py

@@ -135,17 +135,17 @@ class BoolSelector(NMBaseModel):
     def get_enabled(self):
         return [
             f
-            for f in self.model_fields.keys()
+            for f in self.__class__.model_fields.keys()
             if (isinstance(self[f], bool) and self[f])
         ]
 
     def enable_all(self):
-        for f in self.model_fields.keys():
+        for f in self.__class__.model_fields.keys():
             if isinstance(self[f], bool):
                 self[f] = True
 
     def disable_all(self):
-        for f in self.model_fields.keys():
+        for f in self.__class__.model_fields.keys():
             if isinstance(self[f], bool):
                 self[f] = False
 

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["hatchling"]
 
 [project]
 name = "py_neuromodulation"
-version = "0.1.4"
+version = "0.1.7"
 authors = [{ name = "Timon Merk", email = "timon.merk@charite.de" }]
 classifiers = [
   "Development Status :: 2 - Pre-Alpha",

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/tests/conftest.py

@@ -28,7 +28,67 @@ def setup_default_data():
 
 @pytest.fixture
 def setup_default_stream_fast_compute() -> tuple[np.ndarray, nm.Stream]:
-    """This test function sets a data batch and automatic initialized M1 dataframe
+    """This test function sets a data batch and automatic initialized M1 dataframe.
+    Only fft features is enabled.
+
+    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)
+
+    channels = nm.utils.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.NMSettings.get_default()
+    settings.reset()
+    settings.features.fft = True
+
+    stream = nm.Stream(
+        settings=settings,
+        channels=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_default_stream_fooof() -> tuple[np.ndarray, nm.Stream]:
+    """This test function sets a data batch and automatic initialized M1 dataframe.
+    Only fooof feature is enabled.
 
     Args:
         PATH_PYNEUROMODULATION (string): Path to py_neuromodulation repository

{py_neuromodulation-0.1.4 → py_neuromodulation-0.1.7}/tests/test_all_features.py

@@ -25,20 +25,23 @@ def test_all_features_random_array():
         arr, out_dir="./test_data", experiment_name="test_all_features_random_array"
     )
 
-    assert df.shape[0] != 0  # terrible test
+    assert df.shape[0] != 0  # check if not exception was raised
 
 
 def test_all_features_zero_array():
     arr = np.zeros([2, 2000])
 
     stream = get_example_stream(arr)
-    stream.settings.features.fooof = False  # Can't use fooof with 0s (log(0) undefined)
+    #stream.settings.features.fooof = False  # Can't use fooof with 0s (log(0) undefined)
 
     df = stream.run(
         arr, out_dir="./test_data", experiment_name="test_all_features_zero_array"
     )
 
-    assert df.shape[0] != 0  # terrible test
+    # the issue is here that some features, like bandpass activity will be very high
+    # negative values,
+    # TODO: think about how to check that
+    assert df.shape[0] != 0  # check if not exception was raised
 
 
 def test_all_features_NaN_array():
@@ -46,10 +49,10 @@ def test_all_features_NaN_array():
     arr[:] = np.nan
 
     stream = get_example_stream(arr)
-    stream.settings.features.fooof = False  # Can't use fooof nan values
+    #stream.settings.features.fooof = False  # Can't use fooof nan values
 
     df = stream.run(
         arr, out_dir="./test_data", experiment_name="test_all_features_NaN_array"
     )
 
-    assert df.shape[0] != 0  # terrible test
+    assert df.shape[0] != 0  # check if not exception was raised

py_neuromodulation-0.1.7/tests/test_bad_channels.py

@@ -0,0 +1,22 @@
+# create a test with two channels, one bad, check then if 
+# features are only calculated for the good channel
+
+import numpy as np
+import pandas as pd
+import pytest
+from numpy.testing import assert_allclose
+import py_neuromodulation as nm
+
+def test_bad_channels_feature_extraction(setup_default_stream_fast_compute):
+    default_stream: tuple[np.ndarray, nm.Stream] = setup_default_stream_fast_compute
+    data, stream = default_stream
+
+    # make ecog channels status bad, else good
+    stream.channels["status"] = ["bad" if ch == "ecog" else "good" for ch in stream.channels["type"]]
+
+    features = stream.run(data, out_dir="./test_data",
+              experiment_name="test_bad_channels_feature_extraction")
+
+    # check if features were only computed for channels starting with LFP, no ECoG
+    assert all([f.startswith("LFP") for f in list(features.columns) if f != "time"]), \
+        "Features were computed for non-DBS channels, which should not happen."

py_neuromodulation-0.1.7/tests/test_fooof.py

@@ -0,0 +1,52 @@
+import py_neuromodulation as nm
+import numpy as np
+
+
+def test_fooof_features(setup_default_stream_fooof):
+    default_stream: tuple[np.ndarray, nm.Stream] = setup_default_stream_fooof
+    data, stream = default_stream
+
+    generator = nm.stream.RawDataGenerator(
+        data,
+        stream.sfreq,
+        stream.settings.sampling_rate_features_hz,
+        stream.settings.segment_length_features_ms,
+    )
+
+    _, data_batch = next(generator, None)
+    feature_series = stream.data_processor.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
+
+def test_fooof_zero_values(setup_default_stream_fooof):
+    default_stream: tuple[np.ndarray, nm.Stream] = setup_default_stream_fooof
+    data, stream = default_stream
+    data_zeros = np.zeros_like(data)
+
+    generator = nm.stream.RawDataGenerator(
+        data_zeros,
+        stream.sfreq,
+        stream.settings.sampling_rate_features_hz,
+        stream.settings.segment_length_features_ms,
+    )
+
+    _, data_batch = next(generator, None)
+    feature_series = stream.data_processor.process(data_batch)
+
+    assert all(value is None for value in feature_series.values()), \
+        "Expected all feature values to be None for zero input data."
+
+def test_fooof_zero_values_multiple_iterations(setup_default_stream_fooof):
+    default_stream: tuple[np.ndarray, nm.Stream] = setup_default_stream_fooof
+    data, stream = default_stream
+    stream.settings.postprocessing["feature_normalization"] = True
+    data_zeros = np.zeros_like(data)
+
+    features = stream.run(data_zeros, out_dir="./test_data",
+                          experiment_name="test_fooof_zero_values_multiple_iterations")
+
+    # convert all None values to zero, and check sum of all features except time column
+    assert np.nan_to_num(features.iloc[:, :-1]).sum().sum() == 0, \
+        "Expected all feature values to be zero for zero input data."

py_neuromodulation-0.1.7/tests/test_nan_values.py

@@ -0,0 +1,68 @@
+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(sfreq=fs, data=data)
+
+    features = stream.run(
+        data, out_dir="./test_data", experiment_name="test_stream_with_none_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])
+
+def test_stream_with_nan_and_non_nan_data_in_one_channel():
+    """Test if passing a mix of NaN and non-NaN data to a Stream object results in correct features."""
+
+    fs = 1000
+    data = np.random.random([2, 3000])
+    nan_start = 1000
+    nan_end = 2000
+    data[0, nan_start:nan_end] = None # Introduce NaNs in the first channel
+
+    stream = nm.Stream(sfreq=fs, data=data)
+
+    features = stream.run(
+        data, out_dir="./test_data", experiment_name="test_stream_with_nan_and_non_nan_data"
+    )
+
+    idx_nan_features = (features["time"] > nan_start) & (features["time"] < nan_end + stream.settings.segment_length_features_ms)
+    idx_not_nan_features = ~idx_nan_features
+
+    features_not_time = features.drop(columns=["time"])
+    features_ch0 = features_not_time.filter(like="ch0")
+
+    assert features_ch0[idx_nan_features].isna().all().all(), \
+        "Expected all features to be NaN in the time range with NaN data."
+    assert features_ch0[idx_not_nan_features].notna().all().all(), \
+        "Expected all features to be non-NaN in the time range with non-NaN data."
+
+def test_stream_with_only_nan_data():
+    """Test if passing only NaN data to a Stream object results in all features being None."""
+
+    fs = 1000
+    data = np.random.random([2, 2000])
+    data[:] = None  # Set all data to NaN
+
+    stream = nm.Stream(sfreq=fs, data=data)
+
+    features = stream.run(
+        data, out_dir="./test_data", experiment_name="test_stream_with_only_nan_data"
+    )
+
+    assert features.filter(like="ch").isna().all().all(), "Expected all features to be NaN."