PyPI - py-neuromodulation - Versions diffs - 0.0.7__py3-none-any.whl → 0.1.0__py3-none-any.whl - Mend

py-neuromodulation 0.0.7py3-none-any.whl → 0.1.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

py_neuromodulation/ConnectivityDecoding/_get_grid_whole_brain.py +0 -1
py_neuromodulation/ConnectivityDecoding/_helper_write_connectome.py +0 -2
py_neuromodulation/__init__.py +12 -4
py_neuromodulation/analysis/RMAP.py +3 -3
py_neuromodulation/analysis/decode.py +55 -2
py_neuromodulation/analysis/feature_reader.py +1 -0
py_neuromodulation/analysis/stats.py +3 -3
py_neuromodulation/default_settings.yaml +24 -17
py_neuromodulation/features/bandpower.py +65 -23
py_neuromodulation/features/bursts.py +9 -8
py_neuromodulation/features/coherence.py +7 -4
py_neuromodulation/features/feature_processor.py +4 -4
py_neuromodulation/features/fooof.py +7 -6
py_neuromodulation/features/mne_connectivity.py +25 -3
py_neuromodulation/features/oscillatory.py +5 -4
py_neuromodulation/features/sharpwaves.py +21 -0
py_neuromodulation/filter/kalman_filter.py +17 -6
py_neuromodulation/gui/__init__.py +3 -0
py_neuromodulation/gui/backend/app_backend.py +419 -0
py_neuromodulation/gui/backend/app_manager.py +345 -0
py_neuromodulation/gui/backend/app_pynm.py +244 -0
py_neuromodulation/gui/backend/app_socket.py +95 -0
py_neuromodulation/gui/backend/app_utils.py +306 -0
py_neuromodulation/gui/backend/app_window.py +202 -0
py_neuromodulation/gui/frontend/assets/Figtree-VariableFont_wght-CkXbWBDP.ttf +0 -0
py_neuromodulation/gui/frontend/assets/index-NbJiOU5a.js +300133 -0
py_neuromodulation/gui/frontend/assets/plotly-DTCwMlpS.js +23594 -0
py_neuromodulation/gui/frontend/charite.svg +16 -0
py_neuromodulation/gui/frontend/index.html +14 -0
py_neuromodulation/gui/window_api.py +115 -0
py_neuromodulation/lsl_api.cfg +3 -0
py_neuromodulation/processing/data_preprocessor.py +9 -2
py_neuromodulation/processing/filter_preprocessing.py +43 -27
py_neuromodulation/processing/normalization.py +32 -17
py_neuromodulation/processing/projection.py +2 -2
py_neuromodulation/processing/resample.py +6 -2
py_neuromodulation/run_gui.py +36 -0
py_neuromodulation/stream/__init__.py +7 -1
py_neuromodulation/stream/backend_interface.py +47 -0
py_neuromodulation/stream/data_processor.py +24 -3
py_neuromodulation/stream/mnelsl_player.py +121 -21
py_neuromodulation/stream/mnelsl_stream.py +9 -17
py_neuromodulation/stream/settings.py +80 -34
py_neuromodulation/stream/stream.py +82 -62
py_neuromodulation/utils/channels.py +1 -1
py_neuromodulation/utils/file_writer.py +110 -0
py_neuromodulation/utils/io.py +46 -5
py_neuromodulation/utils/perf.py +156 -0
py_neuromodulation/utils/pydantic_extensions.py +322 -0
py_neuromodulation/utils/types.py +33 -107
{py_neuromodulation-0.0.7.dist-info → py_neuromodulation-0.1.0.dist-info}/METADATA +18 -4
{py_neuromodulation-0.0.7.dist-info → py_neuromodulation-0.1.0.dist-info}/RECORD +55 -35
{py_neuromodulation-0.0.7.dist-info → py_neuromodulation-0.1.0.dist-info}/WHEEL +1 -1
py_neuromodulation-0.1.0.dist-info/entry_points.txt +2 -0
{py_neuromodulation-0.0.7.dist-info → py_neuromodulation-0.1.0.dist-info}/licenses/LICENSE +0 -0

py_neuromodulation/gui/frontend/charite.svg ADDED Viewed

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 26.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="svg3265" xmlns:svg="http://www.w3.org/2000/svg"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 295 295.5"
+	 style="enable-background:new 0 0 295 295.5;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill-rule:evenodd;clip-rule:evenodd;}
+	.st1{fill-rule:evenodd;clip-rule:evenodd;fill:#878787;}
+</style>
+<path id="polygon10" class="st0" d="M158,94.4c-33.3,0-54.1,24.9-54.1,53.7c0,28.8,21,52.9,54.1,52.9c10.8,0,21.5-3.6,30.2-9.9
+	v-13.7c-8.1,8.1-19.1,13.3-30.6,13.3c-24.9,0-41.3-20.5-41.3-43c0-22.4,16.1-43,41.1-43c11.8,0,22.8,5,30.9,13.3v-13.7
+	C179.2,97.7,169.3,94.4,158,94.4z"/>
+<path id="path26" class="st1" d="M0,147.7C0,66.1,65.7,0,149,0c36.5,0,69.8,13.2,95.6,35.1v22.7c-23.8-25.2-57.5-41-94.9-41
+	c-73,0-130,58.4-130,130.4c0,72,57.1,130.4,130,130.4c37.4,0,71.1-15.7,94.9-41v23.7c-25.8,21.9-59.1,35.1-95.6,35.1
+	C65.8,295.5,0,229.3,0,147.7L0,147.7L0,147.7z"/>
+</svg>

py_neuromodulation/gui/frontend/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/charite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>PyNeuromodulation</title>
+    <script type="module" crossorigin src="/assets/index-NbJiOU5a.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/plotly-DTCwMlpS.js">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

py_neuromodulation/gui/window_api.py ADDED Viewed

@@ -0,0 +1,115 @@
+import webview
+import threading
+import time
+# API class implementing all the methods available in the PyWebView Window object
+# API Reference: https://pywebview.flowrl.com/guide/api.html#webview-window
+class WindowAPI:
+    def __init__(self):
+        self.window = None
+        self.is_resizing = False
+        self.start_x = 0
+        self.start_y = 0
+        self.start_width = 0
+        self.start_height = 0
+    # Function to store the reference to the PyWevView window
+    def register_window(self, window: webview.Window):
+        self._window = window
+    # Functions to handle window resizing
+    def start_resize(self, start_x, start_y):
+        self.is_resizing = True
+        self.start_x = start_x
+        self.start_y = start_y
+        self.start_width, self.start_height = self.get_size()
+        threading.Thread(target=self._resize_loop).start()
+    def stop_resize(self):
+        self.is_resizing = False
+    def update_resize(self, current_x, current_y):
+        if self.is_resizing:
+            dx = current_x - self.start_x
+            dy = current_y - self.start_y
+            new_width = max(self.start_width + dx, 200)  # Minimum width
+            new_height = max(self.start_height + dy, 200)  # Minimum height
+            self.set_size(int(new_width), int(new_height))
+    def _resize_loop(self):
+        while self.is_resizing:
+            time.sleep(0.01)  # Small delay to prevent excessive CPU usage
+    # All API methods from the PyWebView docs
+    def close_window(self):
+        self._window.destroy()
+    def maximize_window(self):
+        self._window.maximize()
+    def minimize_window(self):
+        self._window.minimize()
+    def restore_window(self):
+        self._window.restore()
+    def toggle_fullscreen(self):
+        self._window.toggle_fullscreen()
+    def set_title(self, title: str):
+        self._window.title = title
+    def get_position(self):
+        return (self._window.x, self._window.y)
+    def set_position(self, x: int, y: int):
+        self._window.move(x, y)
+    def get_size(self):
+        return (self._window.width, self._window.height)
+    def set_size(self, width: int, height: int):
+        self._window.resize(width, height)
+    def set_on_top(self, on_top: bool):
+        self._window.on_top = on_top
+    def show(self):
+        self._window.show()
+    def hide(self):
+        self._window.hide()
+    def create_file_dialog(
+        self,
+        dialog_type=webview.OPEN_DIALOG,
+        directory="",
+        allow_multiple=False,
+        save_filename="",
+        file_types=(),
+    ):
+        return self._window.create_file_dialog(
+            dialog_type, directory, allow_multiple, save_filename, file_types
+        )
+    def create_confirmation_dialog(self, title, message):
+        return self._window.create_confirmation_dialog(title, message)
+    def load_url(self, url):
+        self._window.load_url(url)
+    def load_html(self, content, base_uri: str):
+        self._window.load_html(content, base_uri)
+    def load_css(self, css):
+        self._window.load_css(css)
+    def evaluate_js(self, script, callback=None):
+        return self._window.evaluate_js(script, callback)
+    def get_current_url(self):
+        return self._window.get_current_url()
+    def get_elements(self, selector):
+        return self._window.get_elements(selector)

py_neuromodulation/lsl_api.cfg ADDED Viewed

@@ -0,0 +1,3 @@
+[log]
+level = 0
+file = ./lsllog.txt

py_neuromodulation/processing/data_preprocessor.py CHANGED Viewed

@@ -1,12 +1,12 @@
 from typing import TYPE_CHECKING, Type
-from py_neuromodulation.utils.types import PreprocessorName, NMPreprocessor
+from py_neuromodulation.utils.types import PREPROCESSOR_NAME, NMPreprocessor
 if TYPE_CHECKING:
     import numpy as np
     import pandas as pd
     from py_neuromodulation.stream.settings import NMSettings
-PREPROCESSOR_DICT: dict[PreprocessorName, str] = {
+PREPROCESSOR_DICT: dict[PREPROCESSOR_NAME, str] = {
     "preprocessing_filter": "PreprocessingFilter",
     "notch_filter": "NotchFilter",
     "raw_resampling": "Resampler",
@@ -72,6 +72,13 @@ class DataPreprocessor:
         ]
     def process_data(self, data: "np.ndarray") -> "np.ndarray":
+        """
+        Args:
+            data (np.ndarray): shape: (n_channels, n_samples)
+        Returns:
+            np.ndarray: shape: (n_channels, n_samples)
+        """
         for preprocessor in self.preprocessors:
             data = preprocessor.process(data)
         return data

py_neuromodulation/processing/filter_preprocessing.py CHANGED Viewed

@@ -1,22 +1,14 @@
 import numpy as np
-from pydantic import Field
 from typing import TYPE_CHECKING
 from py_neuromodulation.utils.types import BoolSelector, FrequencyRange, NMPreprocessor
+from py_neuromodulation.utils.pydantic_extensions import NMField
 if TYPE_CHECKING:
     from py_neuromodulation import NMSettings
-FILTER_SETTINGS_MAP = {
-    "bandstop_filter": "bandstop_filter_settings",
-    "bandpass_filter": "bandpass_filter_settings",
-    "lowpass_filter": "lowpass_filter_cutoff_hz",
-    "highpass_filter": "highpass_filter_cutoff_hz",
-}
 class FilterSettings(BoolSelector):
     bandstop_filter: bool = True
     bandpass_filter: bool = True
@@ -25,21 +17,23 @@ class FilterSettings(BoolSelector):
     bandstop_filter_settings: FrequencyRange = FrequencyRange(100, 160)
     bandpass_filter_settings: FrequencyRange = FrequencyRange(2, 200)
-    lowpass_filter_cutoff_hz: float = Field(default=200)
-    highpass_filter_cutoff_hz: float = Field(default=3)
-    def get_filter_tuple(self, filter_name) -> tuple[float | None, float | None]:
-        filter_value = self[FILTER_SETTINGS_MAP[filter_name]]
+    lowpass_filter_cutoff_hz: float = NMField(
+        default=200, gt=0, custom_metadata={"unit": "Hz"}
+    )
+    highpass_filter_cutoff_hz: float = NMField(
+        default=3, gt=0, custom_metadata={"unit": "Hz"}
+    )
+    def get_filter_tuple(self, filter_name) -> FrequencyRange:
         match filter_name:
             case "bandstop_filter":
-                return (filter_value.frequency_high_hz, filter_value.frequency_low_hz)
+                return self.bandstop_filter_settings
             case "bandpass_filter":
-                return (filter_value.frequency_low_hz, filter_value.frequency_high_hz)
+                return self.bandpass_filter_settings
             case "lowpass_filter":
-                return (None, filter_value)
+                return FrequencyRange(None, self.lowpass_filter_cutoff_hz)
             case "highpass_filter":
-                return (filter_value, None)
+                return FrequencyRange(self.highpass_filter_cutoff_hz, None)
             case _:
                 raise ValueError(
                     "Filter name must be one of 'bandstop_filter', 'lowpass_filter', "
@@ -51,15 +45,37 @@ class PreprocessingFilter(NMPreprocessor):
     def __init__(self, settings: "NMSettings", sfreq: float) -> None:
         from py_neuromodulation.filter import MNEFilter
-        self.filters: list[MNEFilter] = [
-            MNEFilter(
-                f_ranges=[settings.preprocessing_filter.get_filter_tuple(filter_name)],  # type: ignore
-                sfreq=sfreq,
-                filter_length=sfreq - 1,
-                verbose=False,
+        self.filters: list[MNEFilter] = []
+        for filter_name in settings.preprocessing_filter.get_enabled():
+            if filter_name != "lowpass_filter" and filter_name != "highpass_filter":
+                self.filters += [
+                    MNEFilter(
+                        f_ranges=[settings.preprocessing_filter.get_filter_tuple(filter_name)],  # type: ignore
+                        sfreq=sfreq,
+                        filter_length=sfreq - 1,
+                        verbose=False,
+                    )
+                ]
+        if "lowpass_filter" in settings.preprocessing_filter.get_enabled():
+            self.filters.append(
+                MNEFilter(
+                    f_ranges=[[None, settings.preprocessing_filter.lowpass_filter_cutoff_hz]],  # type: ignore
+                    sfreq=sfreq,
+                    filter_length=sfreq - 1,
+                    verbose=False,
+                )
+            )
+        if "highpass_filter" in settings.preprocessing_filter.get_enabled():
+            self.filters.append(
+                MNEFilter(
+                    f_ranges=[[settings.preprocessing_filter.highpass_filter_cutoff_hz, None]],  # type: ignore
+                    sfreq=sfreq,
+                    filter_length=sfreq - 1,
+                    verbose=False,
+                )
             )
-            for filter_name in settings.preprocessing_filter.get_enabled()
-        ]
     def process(self, data: np.ndarray) -> np.ndarray:
         """Preprocess data according to the initialized list of PreprocessingFilter objects

py_neuromodulation/processing/normalization.py CHANGED Viewed

@@ -3,10 +3,10 @@
 import numpy as np
 from typing import TYPE_CHECKING, Callable, Literal, get_args
+from py_neuromodulation.utils.pydantic_extensions import NMField
 from py_neuromodulation.utils.types import (
     NMBaseModel,
-    Field,
-    NormMethod,
+    NORM_METHOD,
     NMPreprocessor,
 )
@@ -17,14 +17,15 @@ NormalizerType = Literal["raw", "feature"]
 class NormalizationSettings(NMBaseModel):
-    normalization_time_s: float = 30
-    normalization_method: NormMethod = "zscore"
-    clip: float = Field(default=3, ge=0)
+    normalization_time_s: float = NMField(30, gt=0, custom_metadata={"unit": "s"})
+    normalization_method: NORM_METHOD = NMField(default="zscore")
+    clip: float = NMField(default=3, ge=0, custom_metadata={"unit": "a.u."})
     @staticmethod
-    def list_normalization_methods() -> list[NormMethod]:
-        return list(get_args(NormMethod))
+    def list_normalization_methods() -> list[NORM_METHOD]:
+        return list(get_args(NORM_METHOD))
+class FeatureNormalizationSettings(NormalizationSettings):    normalize_psd: bool = False
 class Normalizer(NMPreprocessor):
     def __init__(
@@ -32,9 +33,13 @@ class Normalizer(NMPreprocessor):
         sfreq: float,
         settings: "NMSettings",
         type: NormalizerType,
+        **kwargs,
     ) -> None:
         self.type = type
-        self.settings: NormalizationSettings
+        if self.type == "raw":
+            self.settings: NormalizationSettings
+        else:
+            self.settings: FeatureNormalizationSettings
         match self.type:
             case "raw":
@@ -55,7 +60,7 @@ class Normalizer(NMPreprocessor):
         if self.using_sklearn:
             import sklearn.preprocessing as skpp
-            NORM_METHODS_SKLEARN: dict[NormMethod, Callable] = {
+            NORM_METHODS_SKLEARN: dict[NORM_METHOD, Callable] = {
                 "quantile": lambda: skpp.QuantileTransformer(n_quantiles=300),
                 "robust": skpp.RobustScaler,
                 "minmax": skpp.MinMaxScaler,
@@ -74,14 +79,24 @@ class Normalizer(NMPreprocessor):
             self.normalizer = NORM_FUNCTIONS[self.method]
     def process(self, data: np.ndarray) -> np.ndarray:
-        # TODO: does feature normalization need to be transposed too?
-        if self.type == "raw":
-            data = data.T
+        """Process normalization.
+        Note: raw data has to be internally transposed, s.t. raw and features
+        are normalized in the same way.
+        Args:
+            data (np.ndarray): shape (channels, n_samples)
+        Returns:
+            np.ndarray: (channels, n_samples)
+        """
         if self.previous.size == 0:  # Check if empty
             self.previous = data
-            return data if self.type == "raw" else data.T
+            if self.type == "raw":
+                self.previous = self.previous.T
+            return data
+        if self.type == "raw":
+            data = data.T
         self.previous = np.vstack((self.previous, data[-self.add_samples :]))
         data = self.normalizer(data, self.previous)
@@ -93,12 +108,12 @@ class Normalizer(NMPreprocessor):
         data = np.nan_to_num(data)
-        return data if self.type == "raw" else data.T
+        return data if self.type != "raw" else data.T
 class RawNormalizer(Normalizer):
-    def __init__(self, sfreq: float, settings: "NMSettings") -> None:
-        super().__init__(sfreq, settings, "raw")
+    def __init__(self, sfreq: float, settings: "NMSettings", **kwargs,) -> None:
+        super().__init__(sfreq, settings, "raw", **kwargs)
 class FeatureNormalizer(Normalizer):

py_neuromodulation/processing/projection.py CHANGED Viewed

@@ -1,6 +1,6 @@
 import numpy as np
-from pydantic import Field
 from py_neuromodulation.utils.types import NMBaseModel
+from py_neuromodulation.utils.pydantic_extensions import NMField
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 class ProjectionSettings(NMBaseModel):
-    max_dist_mm: float = Field(default=20.0, gt=0.0)
+    max_dist_mm: float = NMField(default=20.0, gt=0.0, custom_metadata={"unit": "mm"})
 class Projection:

py_neuromodulation/processing/resample.py CHANGED Viewed

@@ -1,11 +1,14 @@
 """Module for resampling."""
 import numpy as np
-from py_neuromodulation.utils.types import NMBaseModel, Field, NMPreprocessor
+from py_neuromodulation.utils.types import NMBaseModel, NMPreprocessor
+from py_neuromodulation.utils.pydantic_extensions import NMField
 class ResamplerSettings(NMBaseModel):
-    resample_freq_hz: float = Field(default=1000, gt=0)
+    resample_freq_hz: float = NMField(
+        default=1000, gt=0, custom_metadata={"unit": "Hz"}
+    )
 class Resampler(NMPreprocessor):
@@ -26,6 +29,7 @@ class Resampler(NMPreprocessor):
         self,
         sfreq: float,
         resample_freq_hz: float,
+        **kwargs,
     ) -> None:
         self.settings = ResamplerSettings(resample_freq_hz=resample_freq_hz)

py_neuromodulation/run_gui.py ADDED Viewed

@@ -0,0 +1,36 @@
+import webbrowser
+from py_neuromodulation.stream import (
+    LSLStream,
+    LSLOfflinePlayer,
+)
+from py_neuromodulation import io
+from py_neuromodulation import App
+def main():
+    (
+        RUN_NAME,
+        PATH_RUN,
+        PATH_BIDS,
+        PATH_OUT,
+        datatype,
+    ) = io.get_paths_example_data()
+    (
+        raw,
+        data,
+        sfreq,
+        line_noise,
+        coord_list,
+        coord_names,
+    ) = io.read_BIDS_data(PATH_RUN=PATH_RUN)
+    player = LSLOfflinePlayer(raw=raw, stream_name="example_stream")
+    player.start_player(chunk_size=30, n_repeat=5999999)
+    App(run_in_webview=False, dev=False).launch()
+if __name__ == "__main__":
+    main()

py_neuromodulation/stream/__init__.py CHANGED Viewed

@@ -1,3 +1,9 @@
 from .generator import RawDataGenerator
 from .mnelsl_player import LSLOfflinePlayer
-from .mnelsl_stream import LSLStream
+from .stream import Stream
+from .settings import NMSettings
+try:
+    from .mnelsl_stream import LSLStream
+except Exception as e:
+    print(f"A RuntimeError occurred: {e}")

py_neuromodulation/stream/backend_interface.py ADDED Viewed

@@ -0,0 +1,47 @@
+from typing import Any
+import logging
+import multiprocessing as mp
+class StreamBackendInterface:
+    """Handles stream data output via queues"""
+    def __init__(
+        self, feature_queue: mp.Queue, raw_data_queue: mp.Queue, control_queue: mp.Queue
+    ):
+        self.feature_queue = feature_queue
+        self.rawdata_queue = raw_data_queue
+        self.control_queue = control_queue
+        self.logger = logging.getLogger("PyNM")
+    def send_command(self, command: str) -> None:
+        """Send a command through the control queue"""
+        try:
+            self.control_queue.put(command)
+        except Exception as e:
+            self.logger.error(f"Error sending command: {e}")
+    def send_features(self, features: dict[str, Any]) -> None:
+        """Send feature data through the feature queue"""
+        try:
+            self.feature_queue.put(features)
+        except Exception as e:
+            self.logger.error(f"Error sending features: {e}")
+    def send_raw_data(self, data: dict[str, Any]) -> None:
+        """Send raw data through the rawdata queue"""
+        try:
+            self.rawdata_queue.put(data)
+        except Exception as e:
+            self.logger.error(f"Error sending raw data: {e}")
+    def check_control_signals(self) -> str | None:
+        """Check for control signals (non-blocking)"""
+        try:
+            if not self.control_queue.empty():
+                return self.control_queue.get_nowait()
+            return None
+        except Exception as e:
+            self.logger.error(f"Error checking control signals: {e}")
+            return None

py_neuromodulation/stream/data_processor.py CHANGED Viewed

@@ -55,6 +55,7 @@ class DataProcessor:
         self.sfreq_raw: float = sfreq // 1
         self.line_noise: float | None = line_noise
         self.path_grids: _PathLike | None = path_grids
+        self.non_psd_indices: np.ndarray | None = None
         self.verbose: bool = verbose
         self.features_previous = None
@@ -255,9 +256,29 @@ class DataProcessor:
         # normalize features
         if self.settings.postprocessing.feature_normalization:
-            normed_features = self.feature_normalizer.process(
-                np.fromiter(features_dict.values(), dtype=np.float64)
-            )
+            if not self.settings.feature_normalization_settings.normalize_psd:
+                if self.non_psd_indices is None:
+                    self.non_psd_indices = [
+                        idx
+                        for idx, key in enumerate(features_dict.keys())
+                        if "psd" not in key
+                    ]
+                    self.psd_indices = list(set(range(len(features_dict))) - set(
+                        self.non_psd_indices
+                    ))
+                feature_values = np.fromiter(features_dict.values(), dtype=np.float64)
+                normed_features_non_psd = self.feature_normalizer.process(
+                    feature_values[self.non_psd_indices]
+                )
+                # combine values in new array
+                normed_features = np.empty((feature_values.shape[0]))
+                normed_features[self.non_psd_indices] = normed_features_non_psd
+                normed_features[self.psd_indices] = feature_values[self.psd_indices]
+            else:
+                normed_features = self.feature_normalizer.process(
+                    np.fromiter(features_dict.values(), dtype=np.float64)
+                )
             features_dict = {
                 key: normed_features[idx]
                 for idx, key in enumerate(features_dict.keys())

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

py-neuromodulation 0.0.7py3-none-any.whl → 0.1.0py3-none-any.whl