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

py_neuromodulation/{nm_sharpwaves.py → features/sharpwaves.py}

@@ -2,7 +2,6 @@ from collections.abc import Sequence
 from collections import defaultdict
 from itertools import product
 
-from py_neuromodulation.nm_types import NMBaseModel
 from pydantic import model_validator
 from typing import TYPE_CHECKING, Any, Callable
 
@@ -13,11 +12,15 @@ if np.__version__ >= "2.0.0":
 else:
     from numpy.core._methods import _mean as np_mean
 
-from py_neuromodulation.nm_features import NMFeature
-from py_neuromodulation.nm_types import BoolSelector, FrequencyRange
+from py_neuromodulation.utils.types import (
+    NMFeature,
+    NMBaseModel,
+    BoolSelector,
+    FrequencyRange,
+)
 
 if TYPE_CHECKING:
-    from py_neuromodulation.nm_settings import NMSettings
+    from py_neuromodulation import NMSettings
 
 # Using low-level numpy mean function for performance, could do the same for the other estimators
 ESTIMATOR_DICT = {
@@ -38,6 +41,7 @@ class PeakDetectionSettings(NMBaseModel):
 class SharpwaveFeatures(BoolSelector):
     peak_left: bool = False
     peak_right: bool = False
+    num_peaks: bool = False
     trough: bool = False
     width: bool = False
     prominence: bool = True
@@ -368,6 +372,11 @@ class SharpwaveAnalyzer(NMFeature):
             # results["sharpness"] = ((trough_height - left_height) + (trough_height - right_height)) / 2
             results["sharpness"] = trough_height - 0.5 * (left_height + right_height)
 
+        if self.sw_settings.sharpwave_features.num_peaks:
+            results["num_peaks"] = [
+                trough_idx.shape[0]
+            ]  # keep list to the estimator can be applied
+
         if self.need_steepness:
             # steepness is calculated as the first derivative
             steepness: np.ndarray = np.concatenate((np.zeros(1), np.diff(data)))

py_neuromodulation/filter/__init__.py

@@ -0,0 +1,3 @@
+from .kalman_filter import define_KF, KalmanSettings
+from .notch_filter import NotchFilter
+from .mne_filter import MNEFilter

py_neuromodulation/{nm_kalmanfilter.py → filter/kalman_filter.py}

@@ -1,71 +1,67 @@
-from numpy import array, cov
-from py_neuromodulation.nm_types import NMBaseModel
-from typing import TYPE_CHECKING
-
-from pydantic import field_validator
-
-if TYPE_CHECKING:
-    from py_neuromodulation.nm_settings import NMSettings
-
-
-class KalmanSettings(NMBaseModel):
-    Tp: float = 0.1
-    sigma_w: float = 0.7
-    sigma_v: float = 1.0
-    frequency_bands: list[str] = [
-        "theta",
-        "alpha",
-        "low_beta",
-        "high_beta",
-        "low_gamma",
-        "high_gamma",
-        "HFA",
-    ]
-
-    @field_validator("frequency_bands")
-    def fbands_spaces_to_underscores(cls, frequency_bands):
-        return [f.replace(" ", "_") for f in frequency_bands]
-
-    def validate_fbands(self, settings: "NMSettings") -> None:
-        assert all(
-            (item in settings.frequency_ranges_hz for item in self.frequency_bands)
-        ), (
-            "Frequency bands for Kalman filter must also be specified in "
-            "bandpass_filter_settings."
-        )
-
-
-def define_KF(Tp, sigma_w, sigma_v):
-    """Define Kalman filter according to white noise acceleration model.
-    See DOI: 10.1109/TBME.2009.2038990  for explanation
-    See https://filterpy.readthedocs.io/en/latest/kalman/KalmanFilter.html#r64ca38088676-2 for implementation details
-
-    Parameters
-    ----------
-    Tp : float
-        prediction interval
-    sigma_w : float
-        process noise
-    sigma_v : float
-        measurement noise
-
-    Returns
-    -------
-    filterpy.KalmanFilter
-        initialized KalmanFilter object
-    """
-    from filterpy.kalman import KalmanFilter
-
-    f = KalmanFilter(dim_x=2, dim_z=1)
-    f.x = array([0, 1])  # x here sensor signal and it's first derivative
-    f.F = array([[1, Tp], [0, 1]])
-    f.H = array([[1, 0]])
-    f.R = sigma_v
-    f.Q = array(
-        [
-            [(sigma_w**2) * (Tp**3) / 3, (sigma_w**2) * (Tp**2) / 2],
-            [(sigma_w**2) * (Tp**2) / 2, (sigma_w**2) * Tp],
-        ]
-    )
-    f.P = cov([[1, 0], [0, 1]])
-    return f
+import numpy as np
+from typing import TYPE_CHECKING
+
+from py_neuromodulation.utils.types import NMBaseModel
+
+
+if TYPE_CHECKING:
+    from py_neuromodulation.stream.settings import NMSettings
+
+
+class KalmanSettings(NMBaseModel):
+    Tp: float = 0.1
+    sigma_w: float = 0.7
+    sigma_v: float = 1.0
+    frequency_bands: list[str] = [
+        "theta",
+        "alpha",
+        "low_beta",
+        "high_beta",
+        "low_gamma",
+        "high_gamma",
+        "HFA",
+    ]
+
+    def validate_fbands(self, settings: "NMSettings") -> None:
+        assert all(
+            (item in settings.frequency_ranges_hz for item in self.frequency_bands)
+        ), (
+            "Frequency bands for Kalman filter must also be specified in "
+            "bandpass_filter_settings."
+        )
+
+
+def define_KF(Tp, sigma_w, sigma_v):
+    """Define Kalman filter according to white noise acceleration model.
+    See DOI: 10.1109/TBME.2009.2038990  for explanation
+    See https://filterpy.readthedocs.io/en/latest/kalman/KalmanFilter.html#r64ca38088676-2 for implementation details
+
+    Parameters
+    ----------
+    Tp : float
+        prediction interval
+    sigma_w : float
+        process noise
+    sigma_v : float
+        measurement noise
+
+    Returns
+    -------
+    filterpy.KalmanFilter
+        initialized KalmanFilter object
+    """
+    from .kalman_filter_external import KalmanFilter
+
+    f = KalmanFilter(dim_x=2, dim_z=1)
+    f.x = np.array([0, 1])  # x here sensor signal and it's first derivative
+    f.F = np.array([[1, Tp], [0, 1]])
+    f.H = np.array([[1, 0]])
+    f.R = sigma_v
+    f.Q = np.array(
+        [
+            [(sigma_w**2) * (Tp**3) / 3, (sigma_w**2) * (Tp**2) / 2],
+            [(sigma_w**2) * (Tp**2) / 2, (sigma_w**2) * Tp],
+        ]
+    )
+    f.P = np.cov([[1, 0], [0, 1]])
+    return f