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

py_neuromodulation/nm_stream_abc.py

@@ -1,9 +1,15 @@
 """Module that contains PNStream ABC."""
+
 from abc import ABC, abstractmethod
 import os
 import pathlib
 import _pickle as cPickle
 
+from .utils import _logging  # logger initialization
+
+# Logger use in different modules: logger = logging.getLogger("PynmLogger")
+
+
 import pandas as pd
 from sklearn import base
 
@@ -12,7 +18,7 @@ from py_neuromodulation import (
     nm_IO,
     nm_plots,
     nm_run_analysis,
-    nm_settings
+    nm_settings,
 )
 
 _PathLike = str | os.PathLike
@@ -72,7 +78,9 @@ class PNStream(ABC):
         self.settings = self._load_settings(settings)
 
         if sampling_rate_features_hz is not None:
-            self.settings["sampling_rate_features_hz"] = sampling_rate_features_hz
+            self.settings["sampling_rate_features_hz"] = (
+                sampling_rate_features_hz
+            )
 
         self.nm_channels = self._load_nm_channels(nm_channels)
         if path_grids is None:
@@ -138,10 +146,12 @@ class PNStream(ABC):
         nm_channels: pd.DataFrame | _PathLike,
     ) -> pd.DataFrame:
         if not isinstance(nm_channels, pd.DataFrame):
-            nm_channels =  nm_IO.load_nm_channels(nm_channels)
-        
-        if nm_channels.query("used == 1 and target == 0").shape[0]  == 0:
-            raise ValueError("No channels selected for analysis that have column 'used' = 1 and 'target' = 0. Please check your nm_channels")
+            nm_channels = nm_IO.load_nm_channels(nm_channels)
+
+        if nm_channels.query("used == 1 and target == 0").shape[0] == 0:
+            raise ValueError(
+                "No channels selected for analysis that have column 'used' = 1 and 'target' = 0. Please check your nm_channels"
+            )
 
         return nm_channels
 
@@ -149,7 +159,7 @@ class PNStream(ABC):
     def _load_settings(settings: dict | _PathLike | None) -> dict:
         if isinstance(settings, dict):
             return settings
-        if settings is None: 
+        if settings is None:
             return nm_settings.get_default_settings()
         return nm_IO.read_settings(str(settings))
 
@@ -196,9 +206,7 @@ class PNStream(ABC):
     ) -> None:
         self.run_analysis.save_nm_channels(out_path_root, folder_name)
 
-    def save_settings(
-        self, out_path_root: _PathLike, folder_name: str
-    ) -> None:
+    def save_settings(self, out_path_root: _PathLike, folder_name: str) -> None:
         self.run_analysis.save_settings(out_path_root, folder_name)
 
     def save_sidecar(self, out_path_root: _PathLike, folder_name: str) -> None:

py_neuromodulation/nm_stream_offline.py

@@ -1,17 +1,28 @@
 """Module for offline data streams."""
-import math
-import os
 
+import os
+from joblib import Parallel, delayed
 import numpy as np
 import pandas as pd
+from itertools import count
+import logging
+
+logger = logging.getLogger("PynmLogger")
+
+import mne
 
-from py_neuromodulation import nm_generator, nm_IO, nm_stream_abc, nm_define_nmchannels
+from py_neuromodulation import (
+    nm_generator,
+    nm_IO,
+    nm_stream_abc,
+    nm_define_nmchannels,
+)
 
 _PathLike = str | os.PathLike
 
 
 class _OfflineStream(nm_stream_abc.PNStream):
-    """Offline stream base class. 
+    """Offline stream base class.
     This class can be inhereted for different types of offline streams, e.g. epoch-based or continuous.
 
     Parameters
@@ -19,19 +30,38 @@ class _OfflineStream(nm_stream_abc.PNStream):
     nm_stream_abc : nm_stream_abc.PNStream
     """
 
-    def _add_labels(
-        self, features: pd.DataFrame, data: np.ndarray
-    ) -> pd.DataFrame:
-        """Add resampled labels to features if there are target channels."""
+    def _add_target(
+        self, feature_series: pd.Series, data: np.ndarray
+    ) -> pd.Series:
+        """Add target channels to feature series.
+
+        Parameters
+        ----------
+        feature_series : pd.Series
+        data : np.ndarray
+            Raw data with shape (n_channels, n_samples). Channels not for feature computation are also included
+
+        Returns
+        -------
+        pd.Series
+            feature series with target channels added
+        """
+
         if self.nm_channels["target"].sum() > 0:
-            features = nm_IO.add_labels(
-                features=features,
-                settings=self.settings,
-                nm_channels=self.nm_channels,
-                raw_arr_data=data,
-                fs=self.sfreq,
-            )
-        return features
+            if not self.target_idx_initialized:
+                self.target_indexes = self.nm_channels[
+                    self.nm_channels["target"] == 1
+                ].index
+                self.target_names = self.nm_channels.loc[
+                    self.target_indexes, "name"
+                ].to_list()
+                self.target_idx_initialized = True
+
+            for target_idx, target_name in zip(
+                self.target_indexes, self.target_names
+            ):
+                feature_series[target_name] = data[target_idx, -1]
+        return feature_series
 
     def _add_timestamp(
         self, feature_series: pd.Series, cnt_samples: int
@@ -41,11 +71,10 @@ class _OfflineStream(nm_stream_abc.PNStream):
         Due to normalization run_analysis needs to keep track of the counted
         samples. These are accessed here for time conversion.
         """
-        timestamp = cnt_samples * 1000 / self.sfreq
         feature_series["time"] = cnt_samples * 1000 / self.sfreq
 
         if self.verbose:
-            print(
+            logging.info(
                 str(np.round(feature_series["time"] / 1000, 2))
                 + " seconds of data processed"
             )
@@ -59,9 +88,9 @@ class _OfflineStream(nm_stream_abc.PNStream):
             if not len(names_expected) == data.shape[0]:
                 raise ValueError(
                     "If data is passed as an array, the first dimension must"
-                    " match the number of channel names in `nm_channels`. Got:"
-                    f" Data columns: {data.shape[0]}, nm_channels.name:"
-                    f" {len(names_expected)}."
+                    " match the number of channel names in `nm_channels`.\n"
+                    f" Number of data channels (data.shape[0]): {data.shape[0]}\n"
+                    f" Length of nm_channels[\"name\"]: {len(names_expected)}."
                 )
             return data
         names_data = data.columns.to_list()
@@ -71,51 +100,155 @@ class _OfflineStream(nm_stream_abc.PNStream):
         ):
             raise ValueError(
                 "If data is passed as a DataFrame, the"
-                "columns must match the channel names in `nm_channels`. Got:"
-                f"Data columns: {names_data}, nm_channels.name: {names_data}."
+                "column names must match the channel names in `nm_channels`.\n"
+                f"Input dataframe column names: {names_data}\n"
+                f"Expected (from nm_channels[\"name\"]): : {names_expected}."
+            )
+        return data.to_numpy().transpose()
+
+    def _check_settings_for_parallel(self):
+        """Check specified settings and raise error if parallel processing is not possible.
+
+        Raises:
+            ValueError: depending on the settings, parallel processing is not possible
+        """
+
+        if "raw_normalization" in self.settings["preprocessing"]:
+            raise ValueError(
+                "Parallel processing is not possible with raw_normalization normalization."
+            )
+        if self.settings["postprocessing"]["feature_normalization"] is True:
+            raise ValueError(
+                "Parallel processing is not possible with feature normalization."
+            )
+        if self.settings["features"]["bursts"] is True:
+            raise ValueError(
+                "Parallel processing is not possible with burst estimation."
             )
-        return data.to_numpy()
+
+    def _process_batch(self, data_batch, cnt_samples):
+        feature_series = self.run_analysis.process(
+            data_batch.astype(np.float64)
+        )
+        feature_series = self._add_timestamp(feature_series, cnt_samples)
+        feature_series = self._add_target(
+            feature_series=feature_series, data=data_batch
+        )
+        return feature_series
 
     def _run_offline(
         self,
         data: np.ndarray,
         out_path_root: _PathLike | None = None,
         folder_name: str = "sub",
+        parallel: bool = False,
+        n_jobs: int = -2,
     ) -> pd.DataFrame:
         generator = nm_generator.raw_data_generator(
             data=data,
             settings=self.settings,
             sfreq=self.sfreq,
         )
-        features = []
+
         sample_add = self.sfreq / self.run_analysis.sfreq_features
 
         offset_time = self.settings["segment_length_features_ms"]
-        #offset_start = np.ceil(offset_time / 1000 * self.sfreq).astype(int)
+        # offset_start = np.ceil(offset_time / 1000 * self.sfreq).astype(int)
         offset_start = offset_time / 1000 * self.sfreq
 
-        cnt_samples = offset_start
+        if parallel:
+            l_features = Parallel(n_jobs=n_jobs, verbose=10)(
+                delayed(self._process_batch)(data_batch, cnt_samples)
+                for data_batch, cnt_samples in zip(
+                    generator, count(offset_start, sample_add)
+                )
+            )
 
-        while True:
-            data_batch = next(generator, None)
-            if data_batch is None:
-                break
-            feature_series = self.run_analysis.process(data_batch.astype(np.float64))
-            feature_series = self._add_timestamp(feature_series, cnt_samples)
-            features.append(feature_series)
+        else:
+            l_features = []
+            cnt_samples = offset_start
+            while True:
+                data_batch = next(generator, None)
+                if data_batch is None:
+                    break
+                feature_series = self.run_analysis.process(
+                    data_batch.astype(np.float64)
+                )
+                feature_series = self._add_timestamp(
+                    feature_series, cnt_samples
+                )
 
-            if self.model is not None:
-                prediction = self.model.predict(feature_series)
+                feature_series = self._add_target(
+                    feature_series=feature_series, data=data_batch
+                )
 
-            cnt_samples += sample_add
+                l_features.append(feature_series)
 
-        feature_df = pd.DataFrame(features)
-        feature_df = self._add_labels(features=feature_df, data=data)
+                cnt_samples += sample_add
+        feature_df = pd.DataFrame(l_features)
 
         self.save_after_stream(out_path_root, folder_name, feature_df)
 
         return feature_df
 
+    def plot_raw_signal(
+        self,
+        sfreq: float = None,
+        data: np.array = None,
+        lowpass: float = None,
+        highpass: float = None,
+        picks: list = None,
+        plot_time: bool = True,
+        plot_psd: bool = False,
+    ) -> None:
+        """Use MNE-RawArray Plot to investigate PSD or raw_signal plot.
+
+        Parameters
+        ----------
+        sfreq : float
+            sampling frequency [Hz]
+        data : np.array, optional
+            data (n_channels, n_times), by default None
+        plot_time : bool, optional
+            mne.io.RawArray.plot(), by default True
+        plot_psd : bool, optional
+            mne.io.RawArray.plot(), by default True
+
+        Raises
+        ------
+        ValueError
+            raise Exception when no data is passed
+        """
+        if self.data is None and data is None:
+            raise ValueError("No data passed to plot_raw_signal function.")
+
+        if data is None and self.data is not None:
+            data = self.data
+
+        if sfreq is None:
+            sfreq = self.sfreq
+
+        if self.nm_channels is not None:
+            ch_names = self.nm_channels["name"].to_list()
+            ch_types = self.nm_channels["type"].to_list()
+        else:
+            ch_names = [f"ch_{i}" for i in range(data.shape[0])]
+            ch_types = ["ecog" for i in range(data.shape[0])]
+
+        # create mne.RawArray
+        info = mne.create_info(
+            ch_names=ch_names, sfreq=sfreq, ch_types=ch_types
+        )
+        raw = mne.io.RawArray(data, info)
+
+        if picks is not None:
+            raw = raw.pick(picks)
+        self.raw = raw
+        if plot_time:
+            raw.plot(highpass=highpass, lowpass=lowpass)
+        if plot_psd:
+            raw.compute_psd().plot()
+
 
 class Stream(_OfflineStream):
     def __init__(
@@ -129,7 +262,7 @@ class Stream(_OfflineStream):
         path_grids: _PathLike | None = None,
         coord_names: list | None = None,
         coord_list: list | None = None,
-        verbose: bool = True,     
+        verbose: bool = True,
     ) -> None:
         """Stream initialization
 
@@ -154,11 +287,13 @@ class Stream(_OfflineStream):
         coord_list : list | None, optional
             coordinates in the form [[coord_1_x, coord_1_y, coord_1_z], [coord_2_x, coord_2_y, coord_2_z],], by default None
         verbose : bool, optional
-            print out stream computation time information, by default True
+            log stream computation time information, by default True
         """
 
         if nm_channels is None and data is not None:
-            nm_channels = nm_define_nmchannels.get_default_channels_from_data(data)
+            nm_channels = nm_define_nmchannels.get_default_channels_from_data(
+                data
+            )
 
         if nm_channels is None and data is None:
             raise ValueError(
@@ -179,11 +314,15 @@ class Stream(_OfflineStream):
 
         self.data = data
 
+        self.target_idx_initialized = False
+
     def run(
         self,
         data: np.ndarray | pd.DataFrame = None,
         out_path_root: _PathLike | None = None,
         folder_name: str = "sub",
+        parallel: bool = False,
+        n_jobs: int = -2,
     ) -> pd.DataFrame:
         """Call run function for offline stream.
 
@@ -210,8 +349,11 @@ class Stream(_OfflineStream):
         elif self.data is not None:
             data = self._handle_data(self.data)
         elif self.data is None and data is None:
-            raise ValueError(
-                "No data passed to run function."
-            )
+            raise ValueError("No data passed to run function.")
+
+        if parallel is True:
+            self._check_settings_for_parallel()
 
-        return self._run_offline(data, out_path_root, folder_name)
+        return self._run_offline(
+            data, out_path_root, folder_name, parallel=parallel, n_jobs=n_jobs
+        )

py_neuromodulation/utils/_logging.py

@@ -0,0 +1,24 @@
+import logging
+
+# include the filename in the log output
+# Configure the logger
+logger = logging.getLogger("PynmLogger")
+logger.setLevel(logging.INFO)
+
+# Create a file handler and set its level to DEBUG
+file_handler = logging.FileHandler("logfile_pynm.log")
+file_handler.setLevel(logging.INFO)
+
+# console_handler = logging.StreamHandler()
+# console_handler.setLevel(logging.DEBUG)
+
+# Create a formatter and add it to the handler
+formatter = logging.Formatter(
+    "%(asctime)s:%(levelname)s:%(name)s:%(filename)s:%(message)s"
+)
+file_handler.setFormatter(formatter)
+# console_handler.setFormatter(formatter)
+
+# Add the file handler to the logger
+logger.addHandler(file_handler)
+# logger.addHandler(console_handler)

{py_neuromodulation-0.0.2.dist-info → py_neuromodulation-0.0.4.dist-info}/METADATA

@@ -1,44 +1,73 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: py_neuromodulation
-Version: 0.0.2
+Version: 0.0.4
 Summary: Real-time analysis of intracranial neurophysiology recordings.
-Keywords: real-time,eeg,ieeg,dbs,ecog,electrocorticography,deep-brain-stimulation,machine-learning
+Project-URL: bugtracker, https://github.com/neuromodulation/py_neuromodulation/issues
+Project-URL: repository, https://github.com/neuromodulation/py_neuromodulation
 Author-email: Timon Merk <timon.merk@charite.de>
 Maintainer: Timon Merk
-Requires-Python: >=3.10
-Description-Content-Type: text/x-rst
+License: MIT License
+        
+        Copyright (c) 2021 Interventional Cognitive Neuromodulation - Neumann Lab Berlin
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: dbs,deep-brain-stimulation,ecog,eeg,electrocorticography,ieeg,machine-learning,real-time
 Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: License :: OSI Approved :: MIT License 
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: mne
-Requires-Dist: filterpy >= 1.4.5
+Requires-Python: >=3.10
+Requires-Dist: black>=24.2.0
+Requires-Dist: filterpy>=1.4.5
 Requires-Dist: fooof
+Requires-Dist: hatch>=1.9.4
 Requires-Dist: imbalanced-learn
-Requires-Dist: matplotlib >= 3.3.4
-Requires-Dist: mne-bids >= 0.8
+Requires-Dist: ipython
+Requires-Dist: joblib>=1.3.2
+Requires-Dist: matplotlib>=3.3.4
+Requires-Dist: mne
+Requires-Dist: mne-bids>=0.8
 Requires-Dist: mne-connectivity
 Requires-Dist: mrmr-selection
 Requires-Dist: nolds
-Requires-Dist: numpy >= 1.21.2
-Requires-Dist: pandas >= 1.2.2
+Requires-Dist: notebook
+Requires-Dist: numpy>=1.21.2
+Requires-Dist: pandas>=1.2.2
 Requires-Dist: pip
-Requires-Dist: pynput
+Requires-Dist: pyarrow>=14.0.2
 Requires-Dist: pybids
+Requires-Dist: pybispectra>=1.0.0
+Requires-Dist: pynput
+Requires-Dist: pyparrm
+Requires-Dist: pytest>=8.0.2
 Requires-Dist: scikit-image
-Requires-Dist: scikit-learn >= 0.24.2
+Requires-Dist: scikit-learn>=0.24.2
 Requires-Dist: scikit-optimize
-Requires-Dist: scipy >= 1.7.1
-Requires-Dist: seaborn >= 0.11
-Requires-Dist: notebook
-Requires-Dist: ipython
-Requires-Dist: pybispectra
-Requires-Dist: black ; extra == "dev"
-Requires-Dist: pytest ; extra == "dev"
-Requires-Dist: pytest-cov ; extra == "dev"
-Project-URL: bugtracker, https://github.com/neuromodulation/py_neuromodulation/issues
-Project-URL: repository, https://github.com/neuromodulation/py_neuromodulation
+Requires-Dist: scipy>=1.7.1
+Requires-Dist: seaborn>=0.11
+Requires-Dist: wget
 Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Description-Content-Type: text/x-rst
 
 py_neuromodulation
 ==================
@@ -82,12 +111,24 @@ py_neuromodulation requires at least python 3.10. For installation you can use p
 
     pip install py-neuromodulation
 
-We recommend however installing the package in a new new conda environment:
+
+We recommend however installing the package using `rye <https://rye-up.com/guide/installation/>`_:
 
 .. code-block::
 
     git clone https://github.com/neuromodulation/py_neuromodulation.git
-    conda create -n pynm-test python=3.10
+    rye pin 3.11
+    rye sync
+
+And then activating the virtual environment e.g. in Windows using:
+
+.. code-block::
+
+    .\.venv\Scripts\activate
+
+Alternatively you can also install the package in a conda environment:
+
+    conda create -n pynm-test python=3.11
     conda activate pynm-test
 
 Then install the packages listed in the `pyproject.toml`:
@@ -107,27 +148,27 @@ Then *py_neuromodulation* can be imported via:
 
 .. code-block::
 
-    import py_neuromodulation as py_nm
+    import py_neuromodulation as nm
 
 Basic Usage
 ===========
 
 .. code-block:: python
     
-    import py_neuromodulation as pn
+    import py_neuromodulation as nm
     import numpy as np
     
     NUM_CHANNELS = 5
     NUM_DATA = 10000
     sfreq = 1000  # Hz
-    feature_freq = 3  # 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.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=sampling_rate_features_hz)
     features = stream.run()
 
-Check the `Usage <https://py-neuromodulation.readthedocs.io/en/latest/usage.html>`_ and `First examples <https://py-neuromodulation.readthedocs.io/en/latest/auto_examples/plot_first_demo.html>`_ for further introduction.
+Check the `Usage <https://py-neuromodulation.readthedocs.io/en/latest/usage.html>`_ and `First examples <https://py-neuromodulation.readthedocs.io/en/latest/auto_examples/plot_0_first_demo.html>`_ for further introduction.
 
 Contact information
 -------------------
@@ -139,4 +180,3 @@ References
 
 .. [1] Merk, T. et al. *Invasive neurophysiology and whole brain connectomics for neural decoding in patients with brain implants*, `https://doi.org/10.21203/rs.3.rs-3212709/v1` (2023).
 .. [2] Merk, T. et al. *Electrocorticography is superior to subthalamic local field potentials for movement decoding in Parkinson’s disease*. Elife 11, e75126, `https://doi.org/10.7554/eLife.75126` (2022).
-

py_neuromodulation-0.0.4.dist-info/RECORD

@@ -0,0 +1,72 @@
+py_neuromodulation/FieldTrip.py,sha256=cq4BIibMvcpyAHd7U8eEK4AhVSOTrRKXcywtgtc-Mg4,18597
+py_neuromodulation/__init__.py,sha256=3aujkEqF4dzt8WKtK7gaolh782UsR5FFkqcg7fOtze4,296
+py_neuromodulation/_write_example_dataset_helper.py,sha256=b-kG1JiuIhebVSNCrumTOgdXPTmxXkkduCpUFlmMlOg,2530
+py_neuromodulation/grid_cortex.tsv,sha256=DRnJEBwLBqyzCp3UwBL-Us_9h9GyokCorYl0HLsHSLk,683
+py_neuromodulation/grid_subcortex.tsv,sha256=oCQDYLDdYSa1DAI9ybwECfuzWulFzXqKHyf7oZ1oDBM,25842
+py_neuromodulation/nm_EpochStream.py,sha256=fqLNIQRVtcQOMtOyw-omu3KegEs6tWxZI-GQWqdAeG0,2595
+py_neuromodulation/nm_IO.py,sha256=SFOsCMwu2XOYUjFaDauciVkZsq0YG-Vx4rrevqNDd4g,11688
+py_neuromodulation/nm_RMAP.py,sha256=2wHHD9gwW6Y3XZnGUwmDrWHcz7HjwwLqcwwSjADA0-Q,15791
+py_neuromodulation/nm_across_patient_decoding.py,sha256=9Mwu5o5cUAbtSP8BTx4c-BJfJZtk8wsMx_WH0VIegdI,38690
+py_neuromodulation/nm_analysis.py,sha256=ZIuc1cqG5_2DvoTwvSDL88nyYa_XglANq90xUqeSEXM,38528
+py_neuromodulation/nm_artifacts.py,sha256=KZZ68Q13P64vp05vRiLZ9CPmyWurhcB6K0ldY91axCI,692
+py_neuromodulation/nm_bispectra.py,sha256=7XduXwvryckEMlNeRqKLioNK90rW8AZpvA_Z2I7gThI,6322
+py_neuromodulation/nm_bursts.py,sha256=2xMJjluXttjeijm9e7EaaJJ2fcnnX1kLb600TiJvCzY,7710
+py_neuromodulation/nm_coherence.py,sha256=Iy8FtYBb7qaRFGpzHwOK_IA6O4bvtrumcIyS_Umh0aY,7435
+py_neuromodulation/nm_cohortwrapper.py,sha256=eJVCBW745DB5MX7OBVJh2ZAT1vy-3-_2MCHnjrsO9qI,16643
+py_neuromodulation/nm_decode.py,sha256=d15D-l0RUAcW8FfXyDcPaNwRpS9wuq1XK-pWmImPHDg,35645
+py_neuromodulation/nm_define_nmchannels.py,sha256=8rjZoDIwhsIgdqfSxScaJvY9tNGWNLecTLxEmvhHMuE,11074
+py_neuromodulation/nm_eval_timing.py,sha256=JcnLYyxjH8hvNX7rbJ4PEj-NZzqs2NMGOhyuQQuGiYc,8800
+py_neuromodulation/nm_features.py,sha256=IsfN6nFE_f0OPFaHPjFhjPxMO7pKc6pxkylt6V09LEk,3527
+py_neuromodulation/nm_features_abc.py,sha256=6CX8NHbtpGDY-l9K4CUomlRJVZHPmo6KHJX4RJ1YolM,917
+py_neuromodulation/nm_filter.py,sha256=dusgRby4xDxrj62uINuucm0juCwpGb7Lr3iN4IOs8R4,7542
+py_neuromodulation/nm_filter_preprocessing.py,sha256=rR1QKaf9q_7sWB5J129rBTz5H2PO6rvGxMmU86-npi4,3366
+py_neuromodulation/nm_fooof.py,sha256=rOpKyKzTTnMWBplujsw5kzHAvILBGuCjP0q0UozTIiM,6147
+py_neuromodulation/nm_generator.py,sha256=YPa-1X5gCUVSpxTT9upbbY4kjqoVlRd5njQHBjgpAgk,1088
+py_neuromodulation/nm_hjorth_raw.py,sha256=EvXOBr3k9Q5xypv1Gj8GFqa5EJ_wRYNDGgGnXCUekiM,2180
+py_neuromodulation/nm_kalmanfilter.py,sha256=dgs7_XMBpLEE49l6aAVNA4d6ovTS63CZsAI472eG3JA,2006
+py_neuromodulation/nm_linelength.py,sha256=0iZO7j6g7IeprvlEvWG6a_CaUL2p0sQKGiFgDrzYtxk,954
+py_neuromodulation/nm_mne_connectivity.py,sha256=UCgLRQSrzl0OpOhHdUc1iqWr6fPiHZeU0zNeZfaplJE,3907
+py_neuromodulation/nm_nolds.py,sha256=KZr3ZKqvKJkYKh2BMYuuUMkP8hhmJTUgtLZrE8l-DqQ,3660
+py_neuromodulation/nm_normalization.py,sha256=9v3fiNT0HexD9ycp2gB6BPp_ch86kYez_YNI9yB3zGw,7574
+py_neuromodulation/nm_oscillatory.py,sha256=dvxiytWXwd9_gsvroUhDQkQZBTIZzQEhl2XS2QzmOIQ,16476
+py_neuromodulation/nm_plots.py,sha256=B5A91ejZwoxx2YRa3fB6G_fNamdCm27JSOInqF1OfWc,17869
+py_neuromodulation/nm_projection.py,sha256=g8VersyOGiWj3PjR_U6dvLttsp6CHi_GCyYnu_ha8uc,15309
+py_neuromodulation/nm_rereference.py,sha256=SApVkeWdMmMfD1sr77HSs7MW3eQwVHKEhfm-0zyBu9M,3381
+py_neuromodulation/nm_resample.py,sha256=MSMu8gvmrYZ194fAVJdlB_4yEkuGKHgHrLd11zBDRY0,1122
+py_neuromodulation/nm_run_analysis.py,sha256=kZKcVkAbeAhKzoXyFaNK4Vo_aJTTSAVZxxr8y3GMyCc,15046
+py_neuromodulation/nm_settings.json,sha256=KxvvCTJBaY0PmrxpbNJaY-NQc-eI99YX3lJAwQwDVq4,8287
+py_neuromodulation/nm_settings.py,sha256=7d17vwSGrABxQJ7C6x3FqP8kdboUFpm5LrN4djoVlFA,1775
+py_neuromodulation/nm_sharpwaves.py,sha256=mk6DYjO-834aCEk9-x24DP6b1rSA9gC1Jf6in8GPAgA,16891
+py_neuromodulation/nm_stats.py,sha256=wgYk3jzrfSNEZEWdPSpxQcGcsdNs-vhfKvRhMptSbXM,16029
+py_neuromodulation/nm_stream_abc.py,sha256=hQHFVOnCdZiVfq9NyS5npFQ4DFqJUsY4jbaegEhMvgk,7755
+py_neuromodulation/nm_stream_offline.py,sha256=U7CQlaEMNe3uZJq4vqNROuFjOY_sWWN5GjLq-8_W6C4,12484
+py_neuromodulation/ConnectivityDecoding/Automated Anatomical Labeling 3 (Rolls 2020).nii,sha256=Sp-cjF_AuT0Tlilb5s8lB14hVgkXJiR2uKMS9nOQOeg,902981
+py_neuromodulation/ConnectivityDecoding/_get_grid_hull.m,sha256=pI8MWNBSv4um6VsPlQQqOvqqfk5gXj421KWWPUYMNgQ,748
+py_neuromodulation/ConnectivityDecoding/_get_grid_whole_brain.py,sha256=f4nNTStuZuGOGOz4QZMZAdURpWRK0Ljb4eKP1db-kJc,3207
+py_neuromodulation/ConnectivityDecoding/_helper_write_connectome.py,sha256=uOlV_IGoxtoGH6cseSACyDF94HERNH1dUsIMKFvFIkg,3688
+py_neuromodulation/ConnectivityDecoding/mni_coords_cortical_surface.mat,sha256=AZc0mgiAiqXVAxAnfxwICeh-dQX62RfTeRN_knS-i60,11622
+py_neuromodulation/ConnectivityDecoding/mni_coords_whole_brain.mat,sha256=YxT9nrXZ2IECheEhN1SgSsqNyihHUTLuZQ7o5yP4Q-c,29864
+py_neuromodulation/ConnectivityDecoding/rmap_func_all.nii,sha256=WjVA02B2cGNi670_45fdNssspf8GKbkKgRStZ2d4_FU,7221384
+py_neuromodulation/ConnectivityDecoding/rmap_struc.nii,sha256=XsEMjsCxjAsMFvw1_jpQ-wIU2BUuZ_lISPwMa7zDmDk,7221384
+py_neuromodulation/data/README,sha256=Xw-QRZXGq2YefZ3ZDvrK736DruAkFVeaqOn70BzFnPs,714
+py_neuromodulation/data/dataset_description.json,sha256=4LRbbS8x0ifRZhqTNOrtPmm306AmipYnl9duL3OXHrA,130
+py_neuromodulation/data/participants.json,sha256=o24uxJ95GE_b3SAA6nQg6G8Ene6zPL_u02wYT38A8OY,788
+py_neuromodulation/data/participants.tsv,sha256=rPmG1JoJ2O0xbhlLHDJszAK-QSR_7gkSiaykn-HaXvo,79
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/sub-testsub_ses-EphysMedOff_scans.tsv,sha256=zu2Ym07qo164jbClxfT3L960-nHQeRo6WG3QmbpNgl0,91
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_space-mni_coordsystem.json,sha256=NzLVNODlEAIDwTk49_YcbOUjWiRMdZ8toZYBpmAWS1A,123
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_space-mni_electrodes.tsv,sha256=eHBvuZa9WJGI5LSid2TBRxzgyacK7AwrFGKEByl3i4w,733
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_task-gripforce_run-0_channels.tsv,sha256=cZSFnJqjRK8mrtTN271U9L6H_Lo2kuUHimhcKcv9xdY,790
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_task-gripforce_run-0_ieeg.eeg,sha256=NnQeMDrKpeK3lctIZ5Bzh85UMTs5OCUCaivn_NU5rc4,760040
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_task-gripforce_run-0_ieeg.json,sha256=A0zHnbKXKLBmPly9NshT2B6lsrogFZeIAMXeTzwEYyk,492
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_task-gripforce_run-0_ieeg.vhdr,sha256=hUwxHtbCZMo16-e06xJ1rVqgs1Ac8LtP8_5AmhjeDw8,1023
+py_neuromodulation/data/sub-testsub/ses-EphysMedOff/ieeg/sub-testsub_ses-EphysMedOff_task-gripforce_run-0_ieeg.vmrk,sha256=WV1mN_QGC1WlFh5qcKzXpedyMhtXVHVwgV5v8n1-_Zw,553
+py_neuromodulation/plots/STN_surf.mat,sha256=Hh2nfQRmP0TYIt8SWV-ajKnC8yk7EmBoAj1c6RMoi9g,124526
+py_neuromodulation/plots/Vertices.mat,sha256=k72WB8-0Datt-bRScxcfpp38LBPHV34zzodS49kQAgs,3709780
+py_neuromodulation/plots/faces.mat,sha256=gWSr-9qNxsAPoG8q-muNnaFZHVHGKqnKN0j3Q1JfMk4,2859245
+py_neuromodulation/plots/grid.mat,sha256=G3MYIVcvk8lbf_kKWIe3lZZ4d0QV6HkoLsOFN1A2vhE,775
+py_neuromodulation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_neuromodulation/utils/_logging.py,sha256=vADt0XAWSzDAvhuOfaOjyZRSZCA11Pym2wi0uvPIoTo,738
+py_neuromodulation-0.0.4.dist-info/METADATA,sha256=uVW2tGNLA5o_MD5blFmYgAC_ILaM9w9EkIvphS3oOPQ,7049
+py_neuromodulation-0.0.4.dist-info/WHEEL,sha256=osohxoshIHTFJFVPhsi1UkZuLRGMHRXZzwEBW2ezjrc,87
+py_neuromodulation-0.0.4.dist-info/licenses/LICENSE,sha256=V6yfss2JKJxeY-TsaEVqVomfd8ttziMyB9ik5L-BI7o,1139
+py_neuromodulation-0.0.4.dist-info/RECORD,,