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

py_neuromodulation/ConnectivityDecoding/_get_grid_whole_brain.py

@@ -70,7 +70,6 @@ class NiiToMNI:
         coord_arr = np.array(coord_)
         ival_non_zero = ival_arr[ival != 0]
         coord_non_zero = coord_arr[ival != 0]
-        print(coord_non_zero.shape)
 
         return coord_non_zero, ival_non_zero
 

py_neuromodulation/ConnectivityDecoding/_helper_write_connectome.py

@@ -58,8 +58,6 @@ def write_connectome_mat(
             dict_connectome[
                 f[f.find("ROI-") + 4 : f.find("_func_seed_AvgR_Fz.nii")]
             ] = fp
-
-        print(idx)
     # save the dictionary
     sio.savemat(
         PATH_CONNECTOME,

py_neuromodulation/__init__.py

@@ -4,11 +4,12 @@ from pathlib import PurePath
 from importlib.metadata import version
 from py_neuromodulation.utils.logging import NMLogger
 
+
 #####################################
 # Globals and environment variables #
 #####################################
 
-__version__ = version("py_neuromodulation")  # get version from pyproject.toml
+__version__ = version("py_neuromodulation")
 
 # Check if the module is running headless (no display) for tests and doc builds
 PYNM_HEADLESS: bool = not os.environ.get("DISPLAY")
@@ -16,6 +17,9 @@ PYNM_DIR = PurePath(__file__).parent  # Define constant for py_nm directory
 
 os.environ["MPLBACKEND"] = "agg" if PYNM_HEADLESS else "qtagg"  # Set matplotlib backend
 
+os.environ["LSLAPICFG"] = str(PYNM_DIR / "lsl_api.cfg")  # LSL config file
+
+
 # Set  environment variable MNE_LSL_LIB (required to import Stream below)
 LSL_DICT = {
     "windows_32bit": "windows/x86/liblsl.1.16.2.dll",
@@ -34,15 +38,17 @@ LSL_DICT = {
 
 PLATFORM = platform.system().lower().strip()
 ARCH = platform.architecture()[0]
+
 match PLATFORM:
     case "windows":
         KEY = PLATFORM + "_" + ARCH
     case "darwin":
         KEY = PLATFORM + "_" + platform.processor()
     case "linux":
-        DIST = platform.freedesktop_os_release()["VERSION_CODENAME"]
-        KEY = PLATFORM + "_" + DIST + "_" + ARCH
-        if KEY not in LSL_DICT:
+        if "VERSION_CODENAME" in platform.freedesktop_os_release().keys():
+            DIST = platform.freedesktop_os_release()["VERSION_CODENAME"]
+            KEY = PLATFORM + "_" + DIST + "_" + ARCH
+        else:
             KEY = PLATFORM + "_" + ARCH
     case _:
         KEY = ""
@@ -78,3 +84,5 @@ from . import stream
 from . import analysis
 
 from .stream.settings import get_default_settings, get_fast_compute, reset_settings
+
+from .gui.backend.app_manager import AppManager as App

py_neuromodulation/analysis/RMAP.py

@@ -8,8 +8,8 @@ import pandas as pd
 import nibabel as nib
 from matplotlib import pyplot as plt
 
-from py_neuromodulation.plots import reg_plot
-from py_neuromodulation.types import _PathLike
+from py_neuromodulation.analysis import reg_plot
+from py_neuromodulation.utils.types import _PathLike
 from py_neuromodulation import PYNM_DIR
 
 LIST_STRUC_UNCONNECTED_GRIDPOINTS_HULL = [256, 385, 417, 447, 819, 914]
@@ -335,7 +335,7 @@ class RMAPCross_Val_ChannelSelector:
         reshape: bool = True,
     ):
         if reshape:
-            fp = np.reshape(fp, (91, 109, 91), order="F")
+            fp = np.reshape(fp, (91, 109, 91), order="C")
 
         img = nib.nifti1.Nifti1Image(fp, affine=affine)
 

py_neuromodulation/analysis/decode.py

@@ -6,14 +6,67 @@ from sklearn.metrics import r2_score
 import pandas as pd
 import numpy as np
 from copy import deepcopy
-from pathlib import PurePath
+from pathlib import Path, PurePath
 import pickle
 
 from py_neuromodulation import logger
+from py_neuromodulation.utils.types import _PathLike
 
 from typing import Callable
 
 
+class RealTimeDecoder:
+    def __init__(self, model_path: _PathLike):
+        self.model_path = Path(model_path)
+        if not self.model_path.exists():
+            raise FileNotFoundError(f"Model file {self.model_path} not found")
+        if not self.model_path.is_file():
+            raise IsADirectoryError(f"Model file {self.model_path} is a directory")
+
+        if self.model_path.suffix == ".skops":
+            from skops import io as skops_io
+
+            self.model = skops_io.load(self.model_path)
+        else:
+            return NotImplementedError("Only skops models are supported")
+
+    def predict(
+        self,
+        feature_dict: dict,
+        channel: str | None = None,
+        fft_bands_only: bool = True,
+    ) -> dict:
+        try:
+            if channel is not None:
+                features_ch = {
+                    f: feature_dict[f]
+                    for f in feature_dict.keys()
+                    if f.startswith(channel)
+                }
+                if fft_bands_only is True:
+                    features_ch_fft = {
+                        f: features_ch[f]
+                        for f in features_ch.keys()
+                        if "fft" in f and "psd" not in f
+                    }
+                    out = self.model.predict_proba(
+                        np.array(list(features_ch_fft.values())).reshape(1, -1)
+                    )
+                else:
+                    out = self.model.predict_proba(features_ch)
+            else:
+                out = self.model.predict(feature_dict)
+            for decode_output_idx in range(out.shape[1]):
+                feature_dict[f"decode_{decode_output_idx}"] = np.squeeze(out)[
+                    decode_output_idx
+                ]
+            logger.debug(f"Decoded values: {out}")
+            return feature_dict
+        except Exception as e:
+            logger.error(f"Error in decoding: {e}")
+        return feature_dict
+
+
 class CV_res:
     def __init__(
         self,
@@ -168,7 +221,7 @@ class Decoder:
             self.feature_names = [
                 col
                 for col in self.features.columns
-                if not (("time" in col) or (self.label_name in col))
+                if any(col.startswith(used_ch) for used_ch in self.used_chs)
             ]
             self.data = np.nan_to_num(np.array(self.features[self.feature_names]))
 

py_neuromodulation/analysis/feature_reader.py

@@ -51,6 +51,7 @@ class FeatureReader:
         self.feature_file = feature_file if feature_file else self.feature_list[0]
 
         FILE_BASENAME = PurePath(self.feature_file).stem
+        # the features are saved in a directory feature_file, and each file hold the name starting with feature_file
         PATH_READ_FILE = str(PurePath(self.feature_dir, FILE_BASENAME, FILE_BASENAME))
 
         self.settings = NMSettings.from_file(PATH_READ_FILE)

py_neuromodulation/analysis/stats.py

@@ -6,7 +6,7 @@ import matplotlib.pyplot as plt
 # from numba import njit
 import numpy as np
 import pandas as pd
-import scipy.stats as stats
+import scipy.stats as scipy_stats
 
 
 def fitlm_kfold(x, y, kfold_splits=5):
@@ -51,7 +51,7 @@ def permutationTestSpearmansRho(x, y, plot_distr=True, x_unit=None, p=5000):
     """
 
     # compute ground truth difference
-    gT = stats.spearmanr(x, y)[0]
+    gT = scipy_stats.spearmanr(x, y)[0]
     #
     pV = np.array((x, y))
     # Initialize permutation:
@@ -65,7 +65,7 @@ def permutationTestSpearmansRho(x, y, plot_distr=True, x_unit=None, p=5000):
         random.shuffle(args_order_2)
         # Compute permuted absolute difference of your two sampled
         # distributions and store it in pD:
-        pD.append(stats.spearmanr(pV[0, args_order], pV[1, args_order_2])[0])
+        pD.append(scipy_stats.spearmanr(pV[0, args_order], pV[1, args_order_2])[0])
 
     # calculate p value
     if gT < 0:

py_neuromodulation/default_settings.yaml

@@ -1,4 +1,15 @@
----
+# We
+# should
+# have
+# a
+# brief
+# explanation
+# of
+# the
+# settings
+# format
+# here
+
 ########################
 ### General settings ###
 ########################
@@ -51,12 +62,8 @@ preprocessing_filter:
   lowpass_filter: true
   highpass_filter: true
   bandpass_filter: true
-  bandstop_filter_settings:
-    frequency_low_hz: 100
-    frequency_high_hz: 160
-  bandpass_filter_settings:
-    frequency_low_hz: 3
-    frequency_high_hz: 200
+  bandstop_filter_settings: [100, 160] # [low_hz, high_hz]
+  bandpass_filter_settings: [3, 200] # [hz, _hz]
   lowpass_filter_cutoff_hz: 200
   highpass_filter_cutoff_hz: 3
 
@@ -71,6 +78,7 @@ postprocessing:
 feature_normalization_settings:
   normalization_time_s: 30
   normalization_method: zscore # supported methods: mean, median, zscore, zscore-median, quantile, power, robust, minmax
+  normalize_psd: false
   clip: 3
 
 project_cortex_settings:
@@ -91,7 +99,7 @@ fft_settings:
     median: false
     std: false
     max: false
-  return_spectrum: false
+  return_spectrum: true
 
 welch_settings:
   windowlength_ms: 1000
@@ -101,7 +109,7 @@ welch_settings:
     median: false
     std: false
     max: false
-  return_spectrum: false
+  return_spectrum: true
 
 stft_settings:
   windowlength_ms: 500
@@ -136,7 +144,7 @@ kalman_filter_settings:
   frequency_bands:
     [theta, alpha, low_beta, high_beta, low_gamma, high_gamma, HFA]
 
-burst_settings:
+bursts_settings:
   threshold: 75
   time_duration_s: 30
   frequency_bands: [low_beta, high_beta, low_gamma]
@@ -161,11 +169,9 @@ sharpwave_analysis_settings:
     rise_steepness: false
     decay_steepness: false
     slope_ratio: false
-  filter_ranges_hz:
-    - frequency_low_hz: 5
-      frequency_high_hz: 80
-    - frequency_low_hz: 5
-      frequency_high_hz: 30
+  filter_ranges_hz: # list of [low_hz, high_hz]
+    - [5, 80]
+    - [5, 30]
   detect_troughs:
     estimate: true
     distance_troughs_ms: 10
@@ -174,6 +180,7 @@ sharpwave_analysis_settings:
     estimate: true
     distance_troughs_ms: 5
     distance_peaks_ms: 10
+  # TONI: Reverse this setting? e.g. interval: [mean, var]
   estimator:
     mean: [interval]
     median: []
@@ -193,6 +200,7 @@ coherence_settings:
   method:
     coh: true
     icoh: true
+  nperseg: 128
 
 fooof_settings:
   aperiodic:
@@ -222,8 +230,8 @@ nolds_settings:
     frequency_bands: [low_beta]
 
 mne_connectiviy_settings:
-  method: plv
-  mode: multitaper
+  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']
 
 bispectrum_settings:
   f1s: [5, 35]

py_neuromodulation/features/bandpower.py

@@ -2,8 +2,13 @@ import numpy as np
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 from pydantic import field_validator
-
 from py_neuromodulation.utils.types import NMBaseModel, BoolSelector, NMFeature
+from py_neuromodulation.utils.pydantic_extensions import (
+    NMField,
+    NMErrorList,
+    create_validation_error,
+)
+from py_neuromodulation import logger
 
 if TYPE_CHECKING:
     from py_neuromodulation.stream.settings import NMSettings
@@ -17,15 +22,18 @@ class BandpowerFeatures(BoolSelector):
 
 
 class BandPowerSettings(NMBaseModel):
-    segment_lengths_ms: dict[str, int] = {
-        "theta": 1000,
-        "alpha": 500,
-        "low beta": 333,
-        "high beta": 333,
-        "low gamma": 100,
-        "high gamma": 100,
-        "HFA": 100,
-    }
+    segment_lengths_ms: dict[str, int] = NMField(
+        default={
+            "theta": 1000,
+            "alpha": 500,
+            "low beta": 333,
+            "high beta": 333,
+            "low gamma": 100,
+            "high gamma": 100,
+            "HFA": 100,
+        },
+        custom_metadata={"field_type": "FrequencySegmentLength"},
+    )
     bandpower_features: BandpowerFeatures = BandpowerFeatures()
     log_transform: bool = True
     kalman_filter: bool = False
@@ -33,24 +41,58 @@ class BandPowerSettings(NMBaseModel):
     @field_validator("bandpower_features")
     @classmethod
     def bandpower_features_validator(cls, bandpower_features: BandpowerFeatures):
-        assert (
-            len(bandpower_features.get_enabled()) > 0
-        ), "Set at least one bandpower_feature to True."
-
+        if not len(bandpower_features.get_enabled()) > 0:
+            raise create_validation_error(
+                error_message="Set at least one bandpower_feature to True.",
+                location=["bandpass_filter_settings", "bandpower_features"],
+            )
         return bandpower_features
 
-    def validate_fbands(self, settings: "NMSettings") -> None:
+    def validate_fbands(self, settings: "NMSettings") -> NMErrorList:
+        """_summary_
+
+        :param settings: _description_
+        :type settings: NMSettings
+        :raises create_validation_error: _description_
+        :raises create_validation_error: _description_
+        :raises ValueError: _description_
+        """
+        errors: NMErrorList = NMErrorList()
+
         for fband_name, seg_length_fband in self.segment_lengths_ms.items():
-            assert seg_length_fband <= settings.segment_length_features_ms, (
-                f"segment length {seg_length_fband} needs to be smaller than "
-                f" settings['segment_length_features_ms'] = {settings.segment_length_features_ms}"
-            )
+            # Check that all frequency bands are defined in settings.frequency_ranges_hz
+            if fband_name not in settings.frequency_ranges_hz:
+                logger.warning(
+                    f"Frequency band {fband_name} in bandpass_filter_settings.segment_lengths_ms"
+                    " is not defined in settings.frequency_ranges_hz"
+                )
+
+            # Check that all segment lengths are smaller than settings.segment_length_features_ms
+            if not seg_length_fband <= settings.segment_length_features_ms:
+                errors.add_error(
+                    f"segment length {seg_length_fband} needs to be smaller than "
+                    f" settings['segment_length_features_ms'] = {settings.segment_length_features_ms}",
+                    location=[
+                        "bandpass_filter_settings",
+                        "segment_lengths_ms",
+                        fband_name,
+                    ],
+                )
 
+        # Check that all frequency bands defined in settings.frequency_ranges_hz
         for fband_name in settings.frequency_ranges_hz.keys():
-            assert fband_name in self.segment_lengths_ms, (
-                f"frequency range {fband_name} "
-                "needs to be defined in settings.bandpass_filter_settings.segment_lengths_ms]"
-            )
+            if fband_name not in self.segment_lengths_ms:
+                errors.add_error(
+                    f"frequency range {fband_name} "
+                    "needs to be defined in settings.bandpass_filter_settings.segment_lengths_ms",
+                    location=[
+                        "bandpass_filter_settings",
+                        "segment_lengths_ms",
+                        fband_name,
+                    ],
+                )
+
+        return errors
 
 
 class BandPower(NMFeature):

py_neuromodulation/features/bispectra.py

@@ -96,11 +96,8 @@ class Bispectra(NMFeature):
     def calc_feature(self, data: np.ndarray) -> dict:
         from pybispectra import compute_fft, WaveShape
 
-        # PyBispectra's compute_fft uses PQDM to parallelize the calculation per channel
-        # Is this necessary? Maybe the overhead of parallelization is not worth it
-        # considering that we incur in it once per batch of data
         fft_coeffs, freqs = compute_fft(
-            data=np.expand_dims(data, axis=(0)),
+            data=np.expand_dims(data, axis=0),
             sampling_freq=self.sfreq,
             n_points=data.shape[1],
             verbose=False,
@@ -127,12 +124,11 @@ class Bispectra(NMFeature):
             f1s=tuple(self.settings.f1s),  # type: ignore
             f2s=tuple(self.settings.f2s),  # type: ignore
         )
+        waveshape = waveshape.results.get_results(copy=False)  # can overwrite obj with array
 
         feature_results = {}
         for ch_idx, ch_name in enumerate(self.ch_names):
-            bispectrum = waveshape._bicoherence[
-                ch_idx
-            ]  # Same as waveshape.results._data, skips a copy
+            bispectrum = waveshape[ch_idx]
 
             for component in self.settings.components.get_enabled():
                 spectrum_ch = COMPONENT_DICT[component](bispectrum)

py_neuromodulation/features/bursts.py

@@ -7,11 +7,12 @@ else:
 from collections.abc import Sequence
 from itertools import product
 
-from pydantic import Field, field_validator
+from pydantic import field_validator
 from py_neuromodulation.utils.types import BoolSelector, NMBaseModel, NMFeature
+from py_neuromodulation.utils.pydantic_extensions import NMField
 
 from typing import TYPE_CHECKING, Callable
-from py_neuromodulation.utils.types import create_validation_error
+from py_neuromodulation.utils.pydantic_extensions import create_validation_error
 
 if TYPE_CHECKING:
     from py_neuromodulation import NMSettings
@@ -46,8 +47,8 @@ class BurstFeatures(BoolSelector):
 
 
 class BurstsSettings(NMBaseModel):
-    threshold: float = Field(default=75, ge=0, le=100)
-    time_duration_s: float = Field(default=30, ge=0)
+    threshold: float = NMField(default=75, ge=0)
+    time_duration_s: float = NMField(default=30, ge=0, custom_metadata={"unit": "s"})
     frequency_bands: list[str] = ["low_beta", "high_beta", "low_gamma"]
     burst_features: BurstFeatures = BurstFeatures()
 
@@ -64,16 +65,16 @@ class Bursts(NMFeature):
         settings.validate()
 
         # Validate that all frequency bands are defined in the settings
-        for fband_burst in settings.burst_settings.frequency_bands:
+        for fband_burst in settings.bursts_settings.frequency_bands:
             if fband_burst not in list(settings.frequency_ranges_hz.keys()):
                 raise create_validation_error(
                     f"bursting {fband_burst} needs to be defined in settings['frequency_ranges_hz']",
-                    loc=["burst_settings", "frequency_bands"],
+                    location=["burst_settings", "frequency_bands"],
                 )
 
         from py_neuromodulation.filter import MNEFilter
 
-        self.settings = settings.burst_settings
+        self.settings = settings.bursts_settings
         self.sfreq = sfreq
         self.ch_names = ch_names
         self.segment_length_features_s = settings.segment_length_features_ms / 1000
@@ -83,7 +84,7 @@ class Bursts(NMFeature):
             / settings.sampling_rate_features_hz
         )
 
-        self.fband_names = settings.burst_settings.frequency_bands
+        self.fband_names = settings.bursts_settings.frequency_bands
 
         f_ranges: list[tuple[float, float]] = [
             (

py_neuromodulation/features/coherence.py

@@ -3,7 +3,7 @@ from collections.abc import Iterable
 
 
 from typing import TYPE_CHECKING, Annotated
-from pydantic import Field, field_validator
+from pydantic import field_validator
 
 from py_neuromodulation.utils.types import (
     NMFeature,
@@ -11,6 +11,7 @@ from py_neuromodulation.utils.types import (
     FrequencyRange,
     NMBaseModel,
 )
+from py_neuromodulation.utils.pydantic_extensions import NMField
 from py_neuromodulation import logger
 
 if TYPE_CHECKING:
@@ -26,16 +27,19 @@ class CoherenceFeatures(BoolSelector):
     mean_fband: bool = True
     max_fband: bool = True
     max_allfbands: bool = True
+    
 
-
-ListOfTwoStr = Annotated[list[str], Field(min_length=2, max_length=2)]
+# TODO: make this into a pydantic model that only accepts names from
+# the channels objects and does not accept the same string twice
+ListOfTwoStr = Annotated[list[str], NMField(min_length=2, max_length=2)]
 
 
 class CoherenceSettings(NMBaseModel):
     features: CoherenceFeatures = CoherenceFeatures()
     method: CoherenceMethods = CoherenceMethods()
     channels: list[ListOfTwoStr] = []
-    frequency_bands: list[str] = Field(default=["high_beta"], min_length=1)
+    nperseg: int = NMField(default=256, ge=1)
+    frequency_bands: list[str] = NMField(default=["high_beta"], min_length=1)
 
     @field_validator("frequency_bands")
     def fbands_spaces_to_underscores(cls, frequency_bands):
@@ -49,6 +53,7 @@ class CoherenceObject:
         window: str,
         fbands: list[FrequencyRange],
         fband_names: list[str],
+        nperseg: int,
         ch_1_name: str,
         ch_2_name: str,
         ch_1_idx: int,
@@ -65,6 +70,7 @@ class CoherenceObject:
         self.ch_2 = ch_2_name
         self.ch_1_idx = ch_1_idx
         self.ch_2_idx = ch_2_idx
+        self.nperseg = nperseg
         self.coh = coh
         self.icoh = icoh
         self.features_coh = features_coh
@@ -79,14 +85,15 @@ class CoherenceObject:
     def get_coh(self, feature_results, x, y):
         from scipy.signal import welch, csd
 
-        self.f, self.Pxx = welch(x, self.sfreq, self.window, nperseg=128)
-        self.Pyy = welch(y, self.sfreq, self.window, nperseg=128)[1]
-        self.Pxy = csd(x, y, self.sfreq, self.window, nperseg=128)[1]
+        self.f, self.Pxx = welch(x, self.sfreq, self.window, nperseg=self.nperseg)
+        self.Pyy = welch(y, self.sfreq, self.window, nperseg=self.nperseg)[1]
+        self.Pxy = csd(x, y, self.sfreq, self.window, nperseg=self.nperseg)[1]
 
         if self.coh:
-            self.coh_val = np.abs(self.Pxy**2) / (self.Pxx * self.Pyy)
+            # XXX: gives different output to abs(Sxy) / sqrt(Sxx * Syy)
+            self.coh_val = np.abs(self.Pxy) ** 2 / (self.Pxx * self.Pyy)
         if self.icoh:
-            self.icoh_val = np.array(self.Pxy / (self.Pxx * self.Pyy)).imag
+            self.icoh_val = self.Pxy.imag / np.sqrt(self.Pxx * self.Pyy)
 
         for coh_idx, coh_type in enumerate([self.coh, self.icoh]):
             if coh_type:
@@ -180,6 +187,7 @@ class Coherence(NMFeature):
                     "hann",
                     fband_specs,
                     fband_names,
+                    self.settings.nperseg,
                     ch_1_name,
                     ch_2_name,
                     ch_1_idx,

py_neuromodulation/features/feature_processor.py

@@ -1,13 +1,13 @@
 from typing import Type, TYPE_CHECKING
 
-from py_neuromodulation.utils.types import NMFeature, FeatureName
+from py_neuromodulation.utils.types import NMFeature, FEATURE_NAME
 
 if TYPE_CHECKING:
     import numpy as np
     from py_neuromodulation import NMSettings
 
 
-FEATURE_DICT: dict[FeatureName | str, str] = {
+FEATURE_DICT: dict[FEATURE_NAME | str, str] = {
     "raw_hjorth": "Hjorth",
     "return_raw": "Raw",
     "bandpass_filter": "BandPower",
@@ -42,7 +42,7 @@ class FeatureProcessors:
         from importlib import import_module
 
         # Accept 'str' for custom features
-        self.features: dict[FeatureName | str, NMFeature] = {
+        self.features: dict[FEATURE_NAME | str, NMFeature] = {
             feature_name: getattr(
                 import_module("py_neuromodulation.features"), FEATURE_DICT[feature_name]
             )(settings, ch_names, sfreq)
@@ -83,7 +83,7 @@ class FeatureProcessors:
 
         return feature_results
 
-    def get_feature(self, fname: FeatureName) -> NMFeature:
+    def get_feature(self, fname: FEATURE_NAME) -> NMFeature:
         return self.features[fname]
 
 

py_neuromodulation/features/fooof.py

@@ -9,6 +9,7 @@ from py_neuromodulation.utils.types import (
     BoolSelector,
     FrequencyRange,
 )
+from py_neuromodulation.utils.pydantic_extensions import NMField
 
 if TYPE_CHECKING:
     from py_neuromodulation import NMSettings
@@ -29,11 +30,11 @@ class FooofPeriodicSettings(BoolSelector):
 class FooofSettings(NMBaseModel):
     aperiodic: FooofAperiodicSettings = FooofAperiodicSettings()
     periodic: FooofPeriodicSettings = FooofPeriodicSettings()
-    windowlength_ms: float = 800
+    windowlength_ms: float = NMField(800, gt=0, custom_metadata={"unit": "ms"})
     peak_width_limits: FrequencyRange = FrequencyRange(0.5, 12)
-    max_n_peaks: int = 3
-    min_peak_height: float = 0
-    peak_threshold: float = 2
+    max_n_peaks: int = NMField(3, ge=0)
+    min_peak_height: float = NMField(0, ge=0)
+    peak_threshold: float = NMField(2, ge=0)
     freq_range_hz: FrequencyRange = FrequencyRange(2, 40)
     knee: bool = True
 
@@ -63,12 +64,12 @@ class FooofAnalyzer(NMFeature):
 
         assert (
             self.settings.windowlength_ms <= settings.segment_length_features_ms
-        ), f"fooof windowlength_ms ({settings.fooof.windowlength_ms}) needs to be smaller equal than segment_length_features_ms ({settings.segment_length_features_ms})."
+        ), f"fooof windowlength_ms ({settings.fooof_settings.windowlength_ms}) needs to be smaller equal than segment_length_features_ms ({settings.segment_length_features_ms})."
 
         assert (
             self.settings.freq_range_hz[0] < sfreq
             and self.settings.freq_range_hz[1] < sfreq
-        ), f"fooof frequency range needs to be below sfreq, got {settings.fooof.freq_range_hz}"
+        ), f"fooof frequency range needs to be below sfreq, got {settings.fooof_settings.freq_range_hz}"
 
         from fooof import FOOOFGroup