py-neuromodulation 0.1.0__tar.gz → 0.1.2__tar.gz

py_neuromodulation-0.1.2/.gitattributes

@@ -0,0 +1 @@
+py_neuromodulation/gui/frontend/assets/* linguist-vendored

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/.github/workflows/python-publish.yml

@@ -21,13 +21,15 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install build
+          python -m pip install build
+          python -m pip install pkginfo
+          python -m pip install twine
 
       - name: Build package
         run: python -m build
 
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@v1.10.0
+        uses: pypa/gh-action-pypi-publish@v1.12.4
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
 

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py_neuromodulation
-Version: 0.1.0
+Version: 0.1.2
 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/
@@ -175,6 +175,11 @@ Contact information
 For any question or suggestion please find my contact
 information at `my GitHub profile <https://github.com/timonmerk>`_.
 
+Contributing guide
+------------------
+https://neuromodulation.github.io/py_neuromodulation/contributing.html
+
+
 References
 ----------
 

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/README.rst

@@ -83,6 +83,11 @@ Contact information
 For any question or suggestion please find my contact
 information at `my GitHub profile <https://github.com/timonmerk>`_.
 
+Contributing guide
+------------------
+https://neuromodulation.github.io/py_neuromodulation/contributing.html
+
+
 References
 ----------
 

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/docs/source/contributing.rst

@@ -17,17 +17,13 @@ To setup the python environment, type
     uv venv
 
 
-Depending on your operating system, activate the rye virtual environment: 
+Depending on your operating system, activate the python virtual environment: 
 
 ::
 
     . .venv/bin/activate
 
-And install the pyproject.toml dependencies:
-
-:: 
-
-    then sync the environment with
+And install the pyproject.toml dependencies and sync the environment with
 
 ::
 
@@ -85,3 +81,6 @@ Additionally, the script ``run_gui.py`` can be modified to be in `dev` mode:
 
     App(dev=True).launch()
 
+
+.. note:: 
+    Antonio Brotons wrote an amazing introduction and motivation behind the GUI development this `GitHub discussion <https://github.com/neuromodulation/py_neuromodulation/issues/351#issuecomment-2199932210>`_.

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/docs/source/gui.rst

@@ -2,13 +2,9 @@ GUI
 ===
 
 In this section we will explain the setup and use of the *py_neuromodulation* GUI.
-First, the GUI dependencies can be installed with `uv`:
+First, the GUI dependencies are directly included in the default dependencies.
 
-.. code-block:: bash
-
-    uv pip install -e .[gui]
-
-The GUI can be started by running the following command:
+The GUI can be started after installing *py_neuromodulation* by running the following command:
 
 .. code-block:: bash
 
@@ -30,20 +26,20 @@ The GUI is divided into three main sections:
 
 The source selection is shown in the following image:
 
-.. image:: ../_static/sourceselection.png
+.. image:: _static/sourceselection.png
    :alt: GUI
    :align: center
 
 When clicking on the `SELECT FILE` button, a file dialog will open, where the user can select the file to be loaded:
 
-.. image:: ../_static/fileselection.png
+.. image:: _static/fileselection.png
    :alt: GUI
    :align: center
 
 Internally, available meta data such as sampling rate, line noise, available channel names will be read and a stream initialized.
 Alternatively, the user can select a LabStreamingLayer stream by clicking on the upper `LSL STREAM` button. The available streams will be shown in a menu:
 
-.. image:: ../_static/lslselection.png
+.. image:: _static/lslselection.png
    :alt: GUI
    :align: center
 
@@ -52,14 +48,14 @@ A `.skops` decoding model, such as an openly-published `movement decoding model
 
 Next, by selecting `SELECT CHANNELS`, the user is directed to the channel selection section:
 
-.. image:: ../_static/channelselection.png
+.. image:: _static/channelselection.png
    :alt: GUI
    :align: center
 
 Here the channel names, re-referencing, `mne supported types <https://mne.tools/stable/generated/mne.pick_types.html>`_ and target selection can be defined.
 Next, by clicking on `SETTINGS`, the user is directed to the feature selection:
 
-.. image:: ../_static/settings.png
+.. image:: _static/settings.png
    :alt: GUI
    :align: center
 
@@ -73,7 +69,7 @@ are defined the upper left section.
 Additionally, frequency bands can be modified, added or deleted.
 Once the settings are modified, they are internally validated for potential errors which would then be displayed:
 
-.. image:: ../_static/pydantic.png
+.. image:: _static/pydantic.png
    :alt: GUI
    :align: center
 
@@ -89,13 +85,13 @@ Here, different graphs can be selected by clicking on the corresponding graph li
 When clicking on `RUN STREAM`, the stream will start and the selected features will be computed in real-time.
 In the terminal the feature computation is logged, and features and raw signals are displayed in the GUI:
 
-.. image:: ../_static/graphs.png
+.. image:: _static/graphs.png
    :alt: GUI
    :align: center
 
 Additionally, a heatmap with selected features can be displayed with the decoded model output:
 
-.. image:: ../_static/decoding.png
+.. image:: _static/decoding.png
    :alt: GUI
    :align: center
 
@@ -103,7 +99,7 @@ Additionally, a heatmap with selected features can be displayed with the decoded
 
    <br>
 
-In the :doc:`contributing </contributing>`  section we explain in further detail the GUI setup. 
+In the :doc:`contributing </contributing>`  section we explain in further detail the GUI setup.
 
 Known issues
 ~~~~~~~~~~~~

py_neuromodulation-0.1.2/docs/source/installation.rst

@@ -0,0 +1,58 @@
+Installation
+============
+
+py_neuromodulation requires at least python 3.11. For installation you can use pip:
+
+.. code-block::
+
+    pip install py-neuromodulation
+
+We recommend, however, using the package manager `uv <https://docs.astral.sh/uv/getting-started/installation/>`_, and setting up a clean virtual environment:
+
+.. code-block::
+
+    git clone https://github.com/neuromodulation/py_neuromodulation.git
+    uv python install 3.11
+    uv venv
+
+And then activating the virtual environment e.g. in Windows using:
+
+.. code-block::
+
+    .\.venv\Scripts\activate
+
+or in unix-based systems:
+
+.. code-block::
+
+    source .venv/bin/activate
+
+Then install the packages listed in the `pyproject.toml`:
+
+.. code-block::
+
+    uv sync
+
+The GUI can then simply be started by running:
+
+.. code-block::
+
+    run_gui
+
+If needed, install the documentation dependencies:
+
+.. code-block::
+
+    uv pip install -e .[docs]
+
+
+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`:
+
+.. code-block::
+
+    pip install .

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/gui_dev/src/pages/Settings/Settings.jsx

@@ -310,20 +310,8 @@ export const Settings = () => {
           ))}
         </TitledBox>
 
-        <TitledBox title="Postprocessing Settings" sx={{ borderRadius: 3 }}>
-          {postprocessingSettingsKeys.map((key) => (
-            <SettingsSection
-              key={`${key}_settingsSection`}
-              settings={settings[key]}
-              path={[key]}
-              onChange={handleChangeSettings}
-              errors={validationErrors}
-            />
-          ))}
-        </TitledBox>
-
         {/* FEATURE SETTINGS */}
-        <TitledBox title="Feature Settings">
+        <TitledBox title="Feature Settings" >
           <Stack direction="row" gap={2}>
             <Box alignSelf={"flex-start"}>
               <SettingsSection
@@ -334,7 +322,7 @@ export const Settings = () => {
                 errors={validationErrors}
               />
             </Box>
-            <Stack alignSelf={"flex-start"}>
+            <Stack alignSelf={"flex-start"} >
               {Object.entries(enabledFeatures).map(
                 ([feature, featureSettings]) => (
                   <CollapsibleBox
@@ -355,6 +343,19 @@ export const Settings = () => {
             </Stack>
           </Stack>
         </TitledBox>
+
+        <TitledBox title="Postprocessing Settings" sx={{ borderRadius: 3 }}>
+          {postprocessingSettingsKeys.map((key) => (
+            <SettingsSection
+              key={`${key}_settingsSection`}
+              settings={settings[key]}
+              path={[key]}
+              onChange={handleChangeSettings}
+              errors={validationErrors}
+            />
+          ))}
+        </TitledBox>
+
         {/* END SETTINGS LAYOUT */}
       </Stack>
 

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/gui_dev/src/pages/SourceSelection/StreamSelector.jsx

@@ -118,7 +118,7 @@ export const StreamSelector = () => {
 
   const handleConnectStream = async () => {
     if (isStreamNameValid) {
-      await initializeLSLStream(); // selectedStreamName
+      await initializeLSLStream(selectedStreamName); // selectedStreamName
     }
   };
 

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/gui_dev/src/stores/sessionStore.js

@@ -157,7 +157,7 @@ export const useSessionStore = createStore("session", (set, get) => ({
     }
   },
 
-  initializeLSLStream: async () => {
+  initializeLSLStream: async (lslStreamName) => {
     const lslSource = get().lslSource;
     const streamParameters = get().streamParameters;
 
@@ -169,7 +169,7 @@ export const useSessionStore = createStore("session", (set, get) => ({
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          stream_name: lslSource.availableStreams[0].name,
+          stream_name: lslStreamName, //lslSource.availableStreams[0].name,
           line_noise: streamParameters.lineNoise,
         }),
       });

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/py_neuromodulation/default_settings.yaml

@@ -1,14 +1,10 @@
-# We
-# should
-# have
-# a
-# brief
-# explanation
-# of
-# the
-# settings
-# format
-# here
+# Settings should be modified either directly through
+# the default_settings.yaml file or by creating a new
+# settings.yaml file than can be loaded with
+# settings.NMSettings.load(FILE_PATH)
+#
+# Alternatively, the settings can also be modified through the
+# settings object directly, e.g. settings.features.raw_hjorth = False
 
 ########################
 ### General settings ###
@@ -21,9 +17,9 @@ frequency_ranges_hz: # frequency band ranges can be added, removed and altered
   alpha: [8, 12]
   low_beta: [13, 20]
   high_beta: [20, 35]
-  low_gamma: [60, 80]
-  high_gamma: [90, 200]
-  HFA: [200, 400]
+  #low_gamma: [60, 80]
+  #high_gamma: [90, 200]
+  #HFA: [200, 400]
 
 # Enabled features
 features:
@@ -99,7 +95,7 @@ fft_settings:
     median: false
     std: false
     max: false
-  return_spectrum: true
+  return_spectrum: false
 
 welch_settings:
   windowlength_ms: 1000
@@ -109,7 +105,7 @@ welch_settings:
     median: false
     std: false
     max: false
-  return_spectrum: true
+  return_spectrum: false
 
 stft_settings:
   windowlength_ms: 500
@@ -147,7 +143,7 @@ kalman_filter_settings:
 bursts_settings:
   threshold: 75
   time_duration_s: 30
-  frequency_bands: [low_beta, high_beta, low_gamma]
+  frequency_bands: [low_beta, high_beta] # low_gamma
   burst_features:
     duration: true
     amplitude: true
@@ -190,7 +186,7 @@ sharpwave_analysis_settings:
   apply_estimator_between_peaks_and_troughs: true
 
 coherence_settings:
-  channels: [] # List of channel pairs, empty by default. Each pair is a list of two channels.
+  channels: [] # List of channel pairs, empty by default. Each pair is a list of two channels, where the first channel is the seed and the second channel is the target.
   # Example channels: [[STN_RIGHT_0, ECOG_RIGHT_0], [STN_RIGHT_1, ECOG_RIGHT_1]]
   frequency_bands: [high_beta]
   features:
@@ -230,6 +226,8 @@ nolds_settings:
     frequency_bands: [low_beta]
 
 mne_connectiviy_settings:
+  channels: [] # List of channel pairs, empty by default. Each pair is a list of two channels, where the first channel is the seed and the second channel is the target.
+  # Example channels: [[STN_RIGHT_0, ECOG_RIGHT_0], [STN_RIGHT_1, ECOG_RIGHT_1]]
   method: plv # One of ['coh', 'cohy', 'imcoh', 'cacoh', 'mic', 'mim', 'plv', 'ciplv', 'ppc', 'pli', 'dpli','wpli', 'wpli2_debiased', 'gc', 'gc_tr']
   mode: multitaper # One of ['multitaper', 'fourier', 'cwt_morlet']
 

py_neuromodulation-0.1.2/py_neuromodulation/features/mne_connectivity.py

@@ -0,0 +1,121 @@
+from collections.abc import Iterable
+import numpy as np
+
+from typing import TYPE_CHECKING, Annotated, Literal
+from pydantic import Field
+
+from py_neuromodulation.utils.types import NMFeature, NMBaseModel
+from py_neuromodulation.utils.pydantic_extensions import NMField
+
+if TYPE_CHECKING:
+    from py_neuromodulation import NMSettings
+
+
+ListOfTwoStr = Annotated[list[str], Field(min_length=2, max_length=2)]
+
+
+MNE_CONNECTIVITY_METHOD = Literal[
+    "coh",
+    "cohy",
+    "imcoh",
+    "cacoh",
+    "mic",
+    "mim",
+    "plv",
+    "ciplv",
+    "ppc",
+    "pli",
+    "dpli",
+    "wpli",
+    "wpli2_debiased",
+    "gc",
+    "gc_tr",
+]
+
+MNE_CONNECTIVITY_MODE = Literal["multitaper", "fourier", "cwt_morlet"]
+
+
+class MNEConnectivitySettings(NMBaseModel):
+    method: MNE_CONNECTIVITY_METHOD = NMField(default="plv")
+    mode: MNE_CONNECTIVITY_MODE = NMField(default="multitaper")
+    channels: list[ListOfTwoStr] = []
+
+
+class MNEConnectivity(NMFeature):
+    def __init__(
+        self,
+        settings: "NMSettings",
+        ch_names: Iterable[str],
+        sfreq: float,
+    ) -> None:
+        self.settings = settings
+
+        self.ch_names = ch_names
+        self.sfreq = sfreq
+
+        self.channels = settings.mne_connectivity_settings.channels
+
+        # Params used by spectral_connectivity_epochs
+        self.mode = settings.mne_connectivity_settings.mode
+        self.method = settings.mne_connectivity_settings.method
+        self.indices = ([], [])  # convert channel names to channel indices in data
+        for con_idx in range(len(self.channels)):
+            seed_name = self.channels[con_idx][0]
+            target_name = self.channels[con_idx][1]
+            seed_name_reref = [ch for ch in self.ch_names if ch.startswith(seed_name)][0]
+            target_name_reref = [ch for ch in self.ch_names if ch.startswith(target_name)][0]
+            self.indices[0].append(self.ch_names.index(seed_name_reref))
+            self.indices[1].append(self.ch_names.index(target_name_reref))
+
+        self.fbands = settings.frequency_ranges_hz
+        self.fband_ranges: list = []
+        self.result_keys = []
+
+        self.prev_batch_shape: tuple = (-1, -1)  # sentinel value
+
+    def calc_feature(self, data: np.ndarray) -> dict:
+        from mne_connectivity import spectral_connectivity_epochs
+
+        # n_jobs is here kept to 1, since setup of the multiprocessing Pool
+        # takes longer than most batch computing sizes
+        spec_out = spectral_connectivity_epochs(
+            data=np.expand_dims(data, axis=0),  # add singleton epoch dimension
+            sfreq=self.sfreq,
+            method=self.method,
+            mode=self.mode,
+            indices=self.indices,
+            verbose=False,
+        )
+        dat_conn: np.ndarray = spec_out.get_data()
+
+        # Get frequency band ranges only for the first batch, it's already the same
+        if len(self.fband_ranges) == 0:
+            for fband_range in self.fbands.values():
+                self.fband_ranges.append(
+                    np.where(
+                        (np.array(spec_out.freqs) >= fband_range[0])
+                        & (np.array(spec_out.freqs) <= fband_range[1])
+                    )[0]
+                )
+
+        feature_results = {}
+        for con_idx in np.arange(dat_conn.shape[0]):
+            for fband_idx, fband_name in enumerate(self.fbands):
+                # TODO: Add support for max_fband and max_allfbands
+                feature_results[
+                    "_".join(
+                        [
+                            self.method,
+                            self.channels[con_idx][0],  # seed channel name
+                            "to",
+                            self.channels[con_idx][1],  # target channel name
+                            "mean_fband",
+                            fband_name,
+                        ]
+                    )
+                ] = np.mean(dat_conn[con_idx, self.fband_ranges[fband_idx]])
+
+        # Store current experiment parameters to check if re-initialization is needed
+        self.prev_batch_shape = data.shape
+
+        return feature_results

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/py_neuromodulation/gui/backend/app_pynm.py

@@ -49,7 +49,8 @@ class PyNMState:
         self,
         websocket_manager: WebsocketManager | None = None,
     ) -> None:
-
+        # Clear stop event to enable _process_queue
+        self.stop_event.clear()
         self.websocket_manager = websocket_manager
 
         # Create decoder
@@ -113,6 +114,7 @@ class PyNMState:
         from mne_lsl.lsl import resolve_streams
 
         logger.info("resolving streams")
+        logger.info(f"passed lsl_stream_name: {lsl_stream_name}")
         lsl_streams = resolve_streams()
 
         for stream in lsl_streams:
@@ -142,14 +144,21 @@ class PyNMState:
                 # set all used column to 0
                 #channels.loc[:, "used"] = 0
 
-                logger.info(channels)
+                logger.info(f"channels: {channels}")
                 sfreq = stream.sfreq
+                logger.info(f"sfreq: {sfreq}")
 
-                self.stream: Stream = Stream(
-                    sfreq=sfreq,
-                    line_noise=line_noise,
-                    channels=channels,
-                )
+                logger.info("Starting setup LSL stream...")
+                try:
+                    self.stream: Stream = Stream(
+                        sfreq=sfreq,
+                        line_noise=line_noise,
+                        channels=channels,
+                    )
+                except Exception as e:
+                    logger.error(f"Error setting up LSL stream: {e}")
+
+                logger.info("Finish setup LSL stream...")
                 logger.info("stream setup")
                 logger.info("settings setup")
 

{py_neuromodulation-0.1.0 → py_neuromodulation-0.1.2}/py_neuromodulation/gui/backend/app_socket.py

@@ -39,6 +39,7 @@ class WebsocketManager:
 
     # Combine IP and port to create a unique client ID
     async def send_cbor(self, object: dict):
+        self.logger.debug(f"app_socket.send_cbor")
         if not self.active_connections:
             self.logger.warning("No active connection to send message.")
             return
@@ -54,6 +55,7 @@ class WebsocketManager:
         for connection in self.active_connections:
             try:
                 await connection.send_bytes(cbor_data)
+                self.logger.debug(f"CBOR message sent to {connection.client}")
             except RuntimeError as e:
                 self.logger.error(f"Error sending CBOR message: {e}")
                 self.disconnected.append(connection)