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

py_neuromodulation/{nm_projection.py → processing/projection.py}

@@ -1,11 +1,11 @@
 import numpy as np
-import pandas as pd
 from pydantic import Field
-from py_neuromodulation.nm_types import NMBaseModel
+from py_neuromodulation.utils.types import NMBaseModel
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from py_neuromodulation.nm_settings import NMSettings
+    from py_neuromodulation import NMSettings
+    import pandas as pd
 
 
 class ProjectionSettings(NMBaseModel):
@@ -16,16 +16,16 @@ class Projection:
     def __init__(
         self,
         settings: "NMSettings",
-        grid_cortex: pd.DataFrame,
-        grid_subcortex: pd.DataFrame,
+        grid_cortex: "pd.DataFrame",
+        grid_subcortex: "pd.DataFrame",
         coords: dict,
-        nm_channels: pd.DataFrame,
+        channels: "pd.DataFrame",
         plot_projection: bool = False,
     ) -> None:
         self.grid_cortex = grid_cortex
         self.grid_subcortex = grid_subcortex
         self.coords = coords
-        self.nm_channels = nm_channels
+        self.channels = channels
         self.project_cortex = settings.postprocessing.project_cortex
         self.project_subcortex = settings.postprocessing.project_subcortex
         self.max_dist_cortex = settings.project_cortex_settings.max_dist_mm
@@ -78,7 +78,7 @@ class Projection:
             )[0]
 
         if plot_projection:
-            from py_neuromodulation.nm_plots import NM_Plot
+            from py_neuromodulation.analysis.plots import NM_Plot
 
             nmplotter = NM_Plot(
                 ecog_strip=self.ecog_strip,
@@ -90,7 +90,7 @@ class Projection:
             nmplotter.plot_cortex()
 
     def remove_not_used_ch_from_coords(self):
-        ch_not_used = self.nm_channels.query('(used==0) or (status=="bad")').name
+        ch_not_used = self.channels.query('(used==0) or (status=="bad")').name
         if len(ch_not_used) > 0:
             for ch in ch_not_used:
                 for key_ in self.coords:
@@ -196,7 +196,7 @@ class Projection:
         """Initialize channel names via nm_channel new_name column"""
 
         if self.project_cortex:
-            self.ecog_channels = self.nm_channels.query(
+            self.ecog_channels = self.channels.query(
                 '(type=="ecog") and (used == 1) and (status=="good")'
             ).name.to_list()
 
@@ -206,11 +206,11 @@ class Projection:
                     self.ecog_channels.remove(ecog_channel)
             # write ecog_channels to be new_name
             self.ecog_channels = list(
-                self.nm_channels.query("name == @self.ecog_channels").new_name
+                self.channels.query("name == @self.ecog_channels").new_name
             )
 
         if self.project_subcortex:
-            self.lfp_channels = self.nm_channels.query(
+            self.lfp_channels = self.channels.query(
                 '(type=="lfp" or type=="seeg" or type=="dbs") \
               and (used == 1) and (status=="good")'
             ).name.to_list()
@@ -222,11 +222,11 @@ class Projection:
                     self.lfp_channels.remove(lfp_channel)
             # write lfp_channels to be new_name
             self.lfp_channels = list(
-                self.nm_channels.query("name == @self.lfp_channels").new_name
+                self.channels.query("name == @self.lfp_channels").new_name
             )
 
     def init_projection_run(self, feature_dict: dict) -> None:
-        """Initialize indexes for respective channels in feature series computed by nm_features.py"""
+        """Initialize indexes for respective channels in feature series computed by features.py"""
         #  here it is assumed that only one hemisphere is recorded at a time!
         if self.project_cortex:
             for ecog_channel in self.ecog_channels:

py_neuromodulation/{nm_rereference.py → processing/rereference.py}

@@ -3,14 +3,14 @@
 import numpy as np
 import pandas as pd
 
-from py_neuromodulation.nm_preprocessing import NMPreprocessor
+from py_neuromodulation.utils.types import NMPreprocessor
 
 
 class ReReferencer(NMPreprocessor):
     def __init__(
         self,
         sfreq: float,
-        nm_channels: pd.DataFrame,
+        channels: pd.DataFrame,
     ) -> None:
         """Initialize real-time rereference information.
 
@@ -18,9 +18,9 @@ class ReReferencer(NMPreprocessor):
         ----------
         sfreq : float
             Sampling frequency. Is not used, only kept for compatibility.
-        nm_channels : Pandas DataFrame
+        channels : Pandas DataFrame
             Dataframe containing information about rereferencing, as
-            specified in nm_channels.csv.
+            specified in channels.csv.
 
 
         Raises:
@@ -30,27 +30,27 @@ class ReReferencer(NMPreprocessor):
 
         self.ref_matrix: np.ndarray | None
 
-        nm_channels = nm_channels[nm_channels["used"] == 1].reset_index(drop=True)
-        # (channels_used,) = np.where((nm_channels.used == 1))
+        channels = channels[channels["used"] == 1].reset_index(drop=True)
+        # (channels_used,) = np.where((channels.used == 1))
 
-        ch_names = nm_channels["name"].tolist()
+        ch_names = channels["name"].tolist()
 
         # no re-referencing is being performed when there is a single channel present only
-        if nm_channels.shape[0] in (0, 1):
+        if channels.shape[0] in (0, 1):
             self.ref_matrix = None
             return
 
-        ch_types = nm_channels["type"]
-        refs = nm_channels["rereference"]
+        ch_types = channels["type"]
+        refs = channels["rereference"]
 
         type_map = {}
         for ch_type in ch_types.unique():
             type_map[ch_type] = np.where(
-                (ch_types == ch_type) & (nm_channels["status"] == "good")
+                (ch_types == ch_type) & (channels["status"] == "good")
             )[0]
 
-        ref_matrix = np.zeros((len(nm_channels), len(nm_channels)))
-        for ind in range(len(nm_channels)):
+        ref_matrix = np.zeros((len(channels), len(channels)))
+        for ind in range(len(channels)):
             ref_matrix[ind, ind] = 1
             # if ind not in channels_used:
             #    continue

py_neuromodulation/{nm_resample.py → processing/resample.py}

@@ -1,10 +1,7 @@
 """Module for resampling."""
 
 import numpy as np
-from py_neuromodulation.nm_types import NMBaseModel, Field
-
-
-from py_neuromodulation.nm_preprocessing import NMPreprocessor
+from py_neuromodulation.utils.types import NMBaseModel, Field, NMPreprocessor
 
 
 class ResamplerSettings(NMBaseModel):

py_neuromodulation/stream/__init__.py

@@ -0,0 +1,3 @@
+from .generator import RawDataGenerator
+from .mnelsl_player import LSLOfflinePlayer
+from .mnelsl_stream import LSLStream

py_neuromodulation/{nm_run_analysis.py → stream/data_processor.py}

@@ -1,15 +1,18 @@
 """This module contains the class to process a given batch of data."""
 
 from time import time
+from typing import TYPE_CHECKING
 import numpy as np
-import pandas as pd
 
-from py_neuromodulation import nm_IO, logger
-from py_neuromodulation.nm_types import _PathLike
-from py_neuromodulation.nm_features import FeatureProcessors
-from py_neuromodulation.nm_preprocessing import NMPreprocessors
-from py_neuromodulation.nm_projection import Projection
-from py_neuromodulation.nm_settings import NMSettings
+from py_neuromodulation import logger
+from py_neuromodulation.utils.types import _PathLike
+from py_neuromodulation.features import FeatureProcessors
+from py_neuromodulation.utils import io
+from py_neuromodulation.stream.settings import NMSettings
+
+if TYPE_CHECKING:
+    from py_neuromodulation.processing.projection import Projection
+    import pandas as pd
 
 
 class DataProcessor:
@@ -17,21 +20,23 @@ class DataProcessor:
         self,
         sfreq: float,
         settings: NMSettings | _PathLike,
-        nm_channels: pd.DataFrame | _PathLike,
+        channels: "pd.DataFrame | _PathLike",
         coord_names: list | None = None,
         coord_list: list | None = None,
         line_noise: float | None = None,
         path_grids: _PathLike | None = None,
         verbose: bool = True,
     ) -> None:
+        from py_neuromodulation.processing import DataPreprocessor
+
         """Initialize run class.
 
         Parameters
         ----------
-        settings : nm_settings.NMSettings object
-        nm_channels : pd.DataFrame | _PathLike
+        settings : settings.NMSettings object
+        channels : pd.DataFrame | _PathLike
             Initialized pd.DataFrame with channel specific information.
-            The path to a nm_channels.csv can be also passed.
+            The path to a channels.csv can be also passed.
         coord_names : list | None
             list of coordinate names
         coord_list : list | None
@@ -41,8 +46,9 @@ class DataProcessor:
         verbose : boolean
             if True, log signal processed and computation time
         """
+
         self.settings = NMSettings.load(settings)
-        self.nm_channels = self._load_nm_channels(nm_channels)
+        self.channels = io.load_channels(channels)
 
         self.sfreq_features: float = self.settings.sampling_rate_features_hz
         self._sfreq_raw_orig: float = sfreq
@@ -55,15 +61,15 @@ class DataProcessor:
 
         (self.ch_names_used, _, self.feature_idx, _) = self._get_ch_info()
 
-        self.preprocessors = NMPreprocessors(
+        self.preprocessors = DataPreprocessor(
             settings=self.settings,
-            nm_channels=self.nm_channels,
+            channels=self.channels,
             sfreq=self.sfreq_raw,
             line_noise=self.line_noise,
         )
 
         if self.settings.postprocessing.feature_normalization:
-            from py_neuromodulation.nm_normalization import FeatureNormalizer
+            from py_neuromodulation.processing.normalization import FeatureNormalizer
 
             self.feature_normalizer = FeatureNormalizer(self.settings)
 
@@ -78,7 +84,7 @@ class DataProcessor:
                 coord_names=coord_names, coord_list=coord_list
             )
 
-        self.projection = self._get_projection(self.settings, self.nm_channels)
+        self.projection = self._get_projection(self.settings, self.channels)
 
         self.cnt_samples = 0
 
@@ -134,16 +140,16 @@ class DataProcessor:
     def _get_ch_info(
         self,
     ) -> tuple[list[str], list[str], list[int], np.ndarray]:
-        """Get used feature and label info from nm_channels"""
-        nm_channels = self.nm_channels
-        ch_names_used = nm_channels[nm_channels["used"] == 1]["new_name"].tolist()
-        ch_types_used = nm_channels[nm_channels["used"] == 1]["type"].tolist()
+        """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()
 
         # used channels for feature estimation
-        feature_idx = np.where(nm_channels["used"] & ~nm_channels["target"])[0].tolist()
+        feature_idx = np.where(channels["used"] & ~channels["target"])[0].tolist()
 
         # If multiple targets exist, select only the first
-        label_idx = np.where(nm_channels["target"] == 1)[0]
+        label_idx = np.where(channels["target"] == 1)[0]
 
         return ch_names_used, ch_types_used, feature_idx, label_idx
 
@@ -151,12 +157,12 @@ class DataProcessor:
     def _get_grids(
         settings: "NMSettings",
         path_grids: _PathLike | None,
-    ) -> tuple[pd.DataFrame | None, pd.DataFrame | None]:
+    ) -> "tuple[pd.DataFrame | None, pd.DataFrame | None]":
         """Read settings specified grids
 
         Parameters
         ----------
-        settings : nm_settings.NMSettings object
+        settings : settings.NMSettings object
         path_grids : _PathLike | str
 
         Returns
@@ -166,18 +172,20 @@ class DataProcessor:
             might be None if not specified in settings
         """
         if settings.postprocessing.project_cortex:
-            grid_cortex = nm_IO.read_grid(path_grids, "cortex")
+            grid_cortex = io.read_grid(path_grids, "cortex")
         else:
             grid_cortex = None
         if settings.postprocessing.project_subcortex:
-            grid_subcortex = nm_IO.read_grid(path_grids, "subcortex")
+            grid_subcortex = io.read_grid(path_grids, "subcortex")
         else:
             grid_subcortex = None
         return grid_cortex, grid_subcortex
 
     def _get_projection(
-        self, settings: "NMSettings", nm_channels: pd.DataFrame
-    ) -> Projection | None:
+        self, settings: "NMSettings", channels: "pd.DataFrame"
+    ) -> "Projection | None":
+        from py_neuromodulation.processing.projection import Projection
+
         """Return projection of used coordinated and grids"""
 
         if not any(
@@ -194,19 +202,11 @@ class DataProcessor:
             grid_cortex=grid_cortex,
             grid_subcortex=grid_subcortex,
             coords=self.coords,
-            nm_channels=nm_channels,
+            channels=channels,
             plot_projection=False,
         )
         return projection
 
-    @staticmethod
-    def _load_nm_channels(
-        nm_channels: pd.DataFrame | _PathLike,
-    ) -> pd.DataFrame:
-        if not isinstance(nm_channels, pd.DataFrame):
-            return nm_IO.load_nm_channels(nm_channels)
-        return nm_channels
-
     def _set_coords(
         self, coord_names: list[str] | None, coord_list: list | None
     ) -> dict:
@@ -308,18 +308,18 @@ class DataProcessor:
         if additional_args is not None:
             sidecar = sidecar | additional_args
 
-        nm_IO.save_sidecar(sidecar, out_dir, prefix)
+        io.save_sidecar(sidecar, out_dir, prefix)
 
     def save_settings(self, out_dir: _PathLike, prefix: str = "") -> None:
         self.settings.save(out_dir, prefix)
 
-    def save_nm_channels(self, out_dir: _PathLike, prefix: str = "") -> None:
-        nm_IO.save_nm_channels(self.nm_channels, out_dir, prefix)
+    def save_channels(self, out_dir: _PathLike, prefix: str) -> None:
+        io.save_channels(self.channels, out_dir, prefix)
 
     def save_features(
         self,
-        feature_arr: pd.DataFrame,
+        feature_arr: "pd.DataFrame",
         out_dir: _PathLike = "",
         prefix: str = "",
     ) -> None:
-        nm_IO.save_features(feature_arr, out_dir, prefix)
+        io.save_features(feature_arr, out_dir, prefix)

py_neuromodulation/stream/generator.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+
+class RawDataGenerator:
+    """
+    This generator function mimics online data acquisition.
+    The data are iteratively sampled with settings.sampling_rate_features_hz
+    """
+
+    def __init__(
+        self,
+        data: np.ndarray,
+        sfreq: float,
+        sampling_rate_features_hz: float,
+        segment_length_features_ms: float,
+    ) -> None:
+        """
+        Arguments
+        ---------
+            data (np array): shape (channels, time)
+            settings (settings.NMSettings): settings object
+            sfreq (float): sampling frequency of the data
+
+        Returns
+        -------
+            np.array: 1D array of time stamps
+            np.array: new batch for run function of full segment length shape
+        """
+        self.batch_counter: int = 0  # counter for the batches
+
+        self.data = data
+        self.sfreq = sfreq
+        # Width, in data points, of the moving window used to calculate features
+        self.segment_length = segment_length_features_ms / 1000 * sfreq
+        # Ratio of the sampling frequency of the input data to the sampling frequency
+        self.stride = sfreq / sampling_rate_features_hz
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        start = self.stride * self.batch_counter
+        end = start + self.segment_length
+
+        self.batch_counter += 1
+
+        start_idx = int(start)
+        end_idx = int(end)
+
+        if end_idx > self.data.shape[1]:
+            raise StopIteration
+
+        return np.arange(start, end) / self.sfreq, self.data[:, start_idx:end_idx]

py_neuromodulation/{nm_mnelsl_generator.py → stream/mnelsl_player.py}

@@ -2,14 +2,16 @@ import numpy as np
 import mne
 from pathlib import Path
 
-from py_neuromodulation import logger, nm_types, nm_IO
+from py_neuromodulation.utils.types import _PathLike
+from py_neuromodulation.utils import io
+from py_neuromodulation import logger
 
-class LSLOfflinePlayer:
 
+class LSLOfflinePlayer:
     def __init__(
         self,
         stream_name: str | None = "lsl_offline_player",
-        f_name: str | nm_types.PathLike = None,
+        f_name: str | _PathLike = None,
         raw: mne.io.Raw | None = None,
         sfreq: int | float | None = None,
         data: np.ndarray | None = None,
@@ -49,10 +51,12 @@ class LSLOfflinePlayer:
             logger.critical(error_msg)
             raise ValueError(error_msg)
 
-        if got_fname: 
-            (self._path_raw, data, sfreq, line_noise, coord_list, coord_names) = nm_IO.read_BIDS_data(f_name)
+        if got_fname:
+            (self._path_raw, data, sfreq, line_noise, coord_list, coord_names) = (
+                io.read_BIDS_data(f_name)
+            )
 
-        elif got_raw: 
+        elif got_raw:
             self._path_raw = raw
 
         elif got_sfreq_data:

py_neuromodulation/{nm_mnelsl_stream.py → stream/mnelsl_stream.py}

@@ -8,7 +8,7 @@ import os
 
 if TYPE_CHECKING:
     from py_neuromodulation import NMSettings
-    
+
 
 class LSLStream:
     """
@@ -21,7 +21,7 @@ class LSLStream:
 
         Parameters:
         -----------
-        settings : nm_settings.NMSettings object
+        settings : settings.NMSettings object
         stream_name : str, optional
             Name of the stream to connect to. If not provided, the first available stream is used.
 
@@ -32,8 +32,10 @@ class LSLStream:
             under the same name.
         """
         from mne_lsl.stream import StreamLSL
+
         self.stream: StreamLSL
-        
+        self.keyboard_interrupt = False
+
         self.settings = settings
         self._n_seconds_wait_before_disconnect = 3
         try:
@@ -50,18 +52,16 @@ class LSLStream:
 
         if self.stream.sinfo is None:
             raise RuntimeError("Stream info is None. Check if the stream is running.")
-        
+
         self.winsize = settings.segment_length_features_ms / self.stream.sinfo.sfreq
         self.sampling_interval = 1 / self.settings.sampling_rate_features_hz
 
         # If not running the generator when the escape key is pressed.
         self.headless: bool = not os.environ.get("DISPLAY")
         if not self.headless:
-            from pynput import keyboard
+            from py_neuromodulation.utils.keyboard import KeyboardListener
 
-            self.listener = keyboard.Listener(
-                on_press=lambda key: key != keyboard.Key.esc  # type: ignore
-            )
+            self.listener = KeyboardListener(("esc", self.set_keyboard_interrupt))
             self.listener.start()
 
     def get_next_batch(self) -> Iterator[tuple[np.ndarray, np.ndarray]]:
@@ -111,6 +111,10 @@ class LSLStream:
 
                 logger.info(f"Stream time: {timestamp[-1] - stream_start_time}")
 
-                if not self.headless and not self.listener.running:
+                if not self.headless and self.keyboard_interrupt:
                     logger.info("Keyboard interrupt")
+                    self.listener.stop()
                     self.stream.disconnect()
+
+    def set_keyboard_interrupt(self):
+        self.keyboard_interrupt = True

py_neuromodulation/{nm_settings.py → stream/settings.py}

@@ -5,27 +5,30 @@ from typing import ClassVar
 from pydantic import Field, model_validator
 
 from py_neuromodulation import PYNM_DIR, logger, user_features
-from py_neuromodulation.nm_types import (
+
+from py_neuromodulation.utils.types import (
     BoolSelector,
     FrequencyRange,
     PreprocessorName,
     _PathLike,
+    NMBaseModel,
+    NormMethod,
 )
 
-from py_neuromodulation.nm_types import NMBaseModel
-from py_neuromodulation.nm_filter_preprocessing import FilterSettings
-from py_neuromodulation.nm_kalmanfilter import KalmanSettings
-from py_neuromodulation.nm_projection import ProjectionSettings
-from py_neuromodulation.nm_bispectra import BispectraSettings
-from py_neuromodulation.nm_nolds import NoldsSettings
-from py_neuromodulation.nm_mne_connectivity import MNEConnectivitySettings
-from py_neuromodulation.nm_fooof import FooofSettings
-from py_neuromodulation.nm_coherence import CoherenceSettings
-from py_neuromodulation.nm_sharpwaves import SharpwaveSettings
-from py_neuromodulation.nm_oscillatory import OscillatorySettings, BandpassSettings
-from py_neuromodulation.nm_bursts import BurstSettings
-from py_neuromodulation.nm_normalization import NormMethod, NormalizationSettings
-from py_neuromodulation.nm_resample import ResamplerSettings
+from py_neuromodulation.processing.filter_preprocessing import FilterSettings
+from py_neuromodulation.processing.normalization import NormalizationSettings
+from py_neuromodulation.processing.resample import ResamplerSettings
+from py_neuromodulation.processing.projection import ProjectionSettings
+
+from py_neuromodulation.filter import KalmanSettings
+from py_neuromodulation.features import BispectraSettings
+from py_neuromodulation.features import NoldsSettings
+from py_neuromodulation.features import MNEConnectivitySettings
+from py_neuromodulation.features import FooofSettings
+from py_neuromodulation.features import CoherenceSettings
+from py_neuromodulation.features import SharpwaveSettings
+from py_neuromodulation.features import OscillatorySettings, BandPowerSettings
+from py_neuromodulation.features import BurstsSettings
 
 
 class FeatureSelection(BoolSelector):
@@ -90,15 +93,15 @@ class NMSettings(NMBaseModel):
     fft_settings: OscillatorySettings = OscillatorySettings()
     welch_settings: OscillatorySettings = OscillatorySettings()
     stft_settings: OscillatorySettings = OscillatorySettings()
-    bandpass_filter_settings: BandpassSettings = BandpassSettings()
+    bandpass_filter_settings: BandPowerSettings = BandPowerSettings()
     kalman_filter_settings: KalmanSettings = KalmanSettings()
-    burst_settings: BurstSettings = BurstSettings()
+    burst_settings: BurstsSettings = BurstsSettings()
     sharpwave_analysis_settings: SharpwaveSettings = SharpwaveSettings()
-    mne_connectivity: MNEConnectivitySettings = MNEConnectivitySettings()
-    coherence: CoherenceSettings = CoherenceSettings()
-    fooof: FooofSettings = FooofSettings()
-    nolds_features: NoldsSettings = NoldsSettings()
-    bispectrum: BispectraSettings = BispectraSettings()
+    mne_connectivity_settings: MNEConnectivitySettings = MNEConnectivitySettings()
+    coherence_settings: CoherenceSettings = CoherenceSettings()
+    fooof_settings: FooofSettings = FooofSettings()
+    nolds_settings: NoldsSettings = NoldsSettings()
+    bispectrum_settings: BispectraSettings = BispectraSettings()
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
@@ -247,7 +250,7 @@ class NMSettings(NMBaseModel):
 
     @staticmethod
     def get_default() -> "NMSettings":
-        return NMSettings.from_file(PYNM_DIR / "nm_settings.yaml")
+        return NMSettings.from_file(PYNM_DIR / "default_settings.yaml")
 
     @staticmethod
     def list_normalization_methods() -> list[NormMethod]:
@@ -281,7 +284,7 @@ def reset_settings(settings: NMSettings) -> NMSettings:
     return settings.reset()
 
 
-def set_settings_fast_compute() -> NMSettings:
+def get_fast_compute() -> NMSettings:
     return NMSettings.get_fast_compute()