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

py_neuromodulation/utils/pydantic_extensions.py

@@ -0,0 +1,322 @@
+import copy
+from typing import (
+    Any,
+    get_origin,
+    get_args,
+    get_type_hints,
+    Literal,
+    cast,
+    Sequence,
+)
+from typing_extensions import Unpack, TypedDict
+from pydantic import BaseModel, GetCoreSchemaHandler, ConfigDict
+
+from pydantic_core import (
+    ErrorDetails,
+    PydanticUndefined,
+    InitErrorDetails,
+    ValidationError,
+    CoreSchema,
+    core_schema,
+)
+from pydantic.fields import FieldInfo, _FieldInfoInputs, _FromFieldInfoInputs
+from pprint import pformat
+
+
+def create_validation_error(
+    error_message: str,
+    location: list[str | int] = [],
+    title: str = "Validation Error",
+    error_type="value_error",
+) -> ValidationError:
+    """
+    Factory function to create a Pydantic v2 ValidationError.
+
+    Args:
+    error_message (str): The error message for the ValidationError.
+    loc (List[str | int], optional): The location of the error. Defaults to None.
+    title (str, optional): The title of the error. Defaults to "Validation Error".
+
+    Returns:
+    ValidationError: A Pydantic ValidationError instance.
+    """
+
+    return ValidationError.from_exception_data(
+        title=title,
+        line_errors=[
+            InitErrorDetails(
+                type=error_type,
+                loc=tuple(location),
+                input=None,
+                ctx={"error": error_message},
+            )
+        ],
+        input_type="python",
+        hide_input=False,
+    )
+
+
+class NMErrorList:
+    """Class to handle data about Pydantic errors.
+    Stores data in a list of InitErrorDetails. Errors can be accessed but not modified.
+
+    :return: _description_
+    :rtype: _type_
+    """
+
+    def __init__(
+        self, errors: Sequence[InitErrorDetails | ErrorDetails] | None = None
+    ) -> None:
+        if errors is None:
+            self.__errors: list[InitErrorDetails | ErrorDetails] = []
+        else:
+            self.__errors: list[InitErrorDetails | ErrorDetails] = [e for e in errors]
+
+    def add_error(
+        self,
+        error_message: str,
+        location: list[str | int] = [],
+        error_type="value_error",
+    ) -> None:
+        self.__errors.append(
+            InitErrorDetails(
+                type=error_type,
+                loc=tuple(location),
+                input=None,
+                ctx={"error": error_message},
+            )
+        )
+
+    def create_error(self, title: str = "Validation Error") -> ValidationError:
+        return ValidationError.from_exception_data(
+            title=title, line_errors=cast(list[InitErrorDetails], self.__errors)
+        )
+
+    def extend(self, errors: "NMErrorList"):
+        self.__errors.extend(errors.__errors)
+
+    def __iter__(self):
+        return iter(self.__errors)
+
+    def __len__(self):
+        return len(self.__errors)
+
+    def __getitem__(self, idx):
+        # Return a copy of the error to prevent modification
+        return copy.deepcopy(self.__errors[idx])
+
+    def __repr__(self):
+        return repr(self.__errors)
+
+    def __str__(self):
+        return str(self.__errors)
+
+
+class _NMExtraFieldInputs(TypedDict, total=False):
+    """Additional fields to add on top of the pydantic FieldInfo"""
+
+    custom_metadata: dict[str, Any]
+
+
+class _NMFieldInfoInputs(_FieldInfoInputs, _NMExtraFieldInputs, total=False):
+    """Combine pydantic FieldInfo inputs with PyNM additional inputs"""
+
+    pass
+
+
+class _NMFromFieldInfoInputs(_FromFieldInfoInputs, _NMExtraFieldInputs, total=False):
+    """Combine pydantic FieldInfo.from_field inputs with PyNM additional inputs"""
+
+    pass
+
+
+class NMFieldInfo(FieldInfo):
+    # Add default values for any other custom fields here
+    _default_values = {}
+
+    def __init__(self, **kwargs: Unpack[_NMFieldInfoInputs]) -> None:
+        self.sequence: bool = kwargs.pop("sequence", False)  # type: ignore
+        self.custom_metadata: dict[str, Any] = kwargs.pop("custom_metadata", {})
+        super().__init__(**kwargs)
+
+    def __get_pydantic_core_schema__(
+        self, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        schema = handler(source_type)
+
+        if self.sequence:
+
+            def sequence_validator(v: Any) -> Any:
+                if isinstance(v, (list, tuple)):
+                    return v
+                if isinstance(v, dict) and "root" in v:
+                    return v["root"]
+                return [v]
+
+            return core_schema.no_info_before_validator_function(
+                sequence_validator, schema
+            )
+
+        return schema
+
+    @staticmethod
+    def from_field(
+        default: Any = PydanticUndefined,
+        **kwargs: Unpack[_NMFromFieldInfoInputs],
+    ) -> "NMFieldInfo":
+        if "annotation" in kwargs:
+            raise TypeError('"annotation" is not permitted as a Field keyword argument')
+        return NMFieldInfo(default=default, **kwargs)
+
+    def __repr_args__(self):
+        yield from super().__repr_args__()
+        extra_fields = get_type_hints(_NMExtraFieldInputs)
+        for field in extra_fields:
+            value = getattr(self, field)
+            yield field, value
+
+
+def NMField(
+    default: Any = PydanticUndefined,
+    **kwargs: Unpack[_NMFromFieldInfoInputs],
+) -> Any:
+    return NMFieldInfo.from_field(default=default, **kwargs)
+
+
+class NMBaseModel(BaseModel):
+    model_config = ConfigDict(validate_assignment=False, extra="allow")
+
+    def __init__(self, *args, **kwargs) -> None:
+        """Pydantic does not support positional arguments by default.
+        This is a workaround to support positional arguments for models like FrequencyRange.
+        It converts positional arguments to kwargs and then calls the base class __init__.
+        """
+
+        if not args:
+            # Simple case - just use kwargs
+            super().__init__(*args, **kwargs)
+            return
+
+        field_names = list(self.model_fields.keys())
+        # If we have more positional args than fields, that's an error
+        if len(args) > len(field_names):
+            raise ValueError(
+                f"Too many positional arguments. Expected at most {len(field_names)}, got {len(args)}"
+            )
+
+        # Convert positional args to kwargs, checking for duplicates        if args:
+        complete_kwargs = {}
+        for i, arg in enumerate(args):
+            field_name = field_names[i]
+            if field_name in kwargs:
+                raise ValueError(
+                    f"Got multiple values for field '{field_name}': "
+                    f"positional argument and keyword argument"
+                )
+            complete_kwargs[field_name] = arg
+
+        # Add remaining kwargs
+        complete_kwargs.update(kwargs)
+        super().__init__(**complete_kwargs)
+
+    __init__.__pydantic_base_init__ = True  # type: ignore
+
+    def __str__(self):
+        return pformat(self.model_dump())
+
+    # def __repr__(self):
+    #     return pformat(self.model_dump())
+
+    def validate(self, context: Any | None = None) -> Any:  # type: ignore
+        return self.model_validate(self.model_dump(), context=context)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __setitem__(self, key, value) -> None:
+        setattr(self, key, value)
+
+    @property
+    def fields(self) -> dict[str, FieldInfo | NMFieldInfo]:
+        return self.model_fields  # type: ignore
+
+    def serialize_with_metadata(self):
+        result: dict[str, Any] = {"__field_type__": self.__class__.__name__}
+
+        for field_name, field_info in self.fields.items():
+            value = getattr(self, field_name)
+            if isinstance(value, NMBaseModel):
+                result[field_name] = value.serialize_with_metadata()
+            elif isinstance(value, list):
+                result[field_name] = [
+                    item.serialize_with_metadata()
+                    if isinstance(item, NMBaseModel)
+                    else item
+                    for item in value
+                ]
+            elif isinstance(value, dict):
+                result[field_name] = {
+                    k: v.serialize_with_metadata() if isinstance(v, NMBaseModel) else v
+                    for k, v in value.items()
+                }
+            else:
+                result[field_name] = value
+
+            # Extract unit information from Annotated type
+            if isinstance(field_info, NMFieldInfo):
+                # Convert scalar value to dict with metadata
+                field_dict = {
+                    "__value__": value,
+                    # __field_type__ will be overwritte if set in custom_metadata
+                    "__field_type__": type(value).__name__,
+                    **{
+                        f"__{tag}__": value
+                        for tag, value in field_info.custom_metadata.items()
+                    },
+                }
+                # Add possible values for Literal types
+                if get_origin(field_info.annotation) is Literal:
+                    field_dict["__valid_values__"] = list(
+                        get_args(field_info.annotation)
+                    )
+
+                result[field_name] = field_dict
+        return result
+
+    @classmethod
+    def unvalidated(cls, **data: Any) -> Any:
+        def process_value(value: Any, field_type: Any) -> Any:
+            if isinstance(value, dict) and hasattr(
+                field_type, "__pydantic_core_schema__"
+            ):
+                # Recursively handle nested Pydantic models
+                return field_type.unvalidated(**value)
+            elif isinstance(value, list):
+                # Handle lists of Pydantic models
+                if hasattr(field_type, "__args__") and hasattr(
+                    field_type.__args__[0], "__pydantic_core_schema__"
+                ):
+                    return [
+                        field_type.__args__[0].unvalidated(**item)
+                        if isinstance(item, dict)
+                        else item
+                        for item in value
+                    ]
+            return value
+
+        processed_data = {}
+        for name, field in cls.model_fields.items():
+            try:
+                value = data[name]
+                processed_data[name] = process_value(value, field.annotation)
+            except KeyError:
+                if not field.is_required():
+                    processed_data[name] = copy.deepcopy(field.default)
+                else:
+                    raise TypeError(f"Missing required keyword argument {name!r}")
+
+        self = cls.__new__(cls)
+        object.__setattr__(self, "__dict__", processed_data)
+        object.__setattr__(self, "__pydantic_private__", {"extra": None})
+        object.__setattr__(self, "__pydantic_fields_set__", set(processed_data.keys()))
+        return self

py_neuromodulation/utils/types.py

@@ -1,10 +1,13 @@
 from os import PathLike
 from math import isnan
-from typing import Any, Literal, Protocol, TYPE_CHECKING, runtime_checkable
-from pydantic import ConfigDict, Field, model_validator, BaseModel
-from pydantic_core import ValidationError, InitErrorDetails
-from pprint import pformat
+from typing import Literal, TYPE_CHECKING, Any
+from pydantic import BaseModel, model_validator, Field
+from .pydantic_extensions import NMBaseModel, NMField
+from abc import abstractmethod
+
 from collections.abc import Sequence
+from datetime import datetime
+
 
 if TYPE_CHECKING:
     import numpy as np
@@ -16,7 +19,7 @@ if TYPE_CHECKING:
 
 _PathLike = str | PathLike
 
-FeatureName = Literal[
+FEATURE_NAME = Literal[
     "raw_hjorth",
     "return_raw",
     "bandpass_filter",
@@ -33,7 +36,7 @@ FeatureName = Literal[
     "bispectrum",
 ]
 
-PreprocessorName = Literal[
+PREPROCESSOR_NAME = Literal[
     "preprocessing_filter",
     "notch_filter",
     "raw_resampling",
@@ -41,7 +44,7 @@ PreprocessorName = Literal[
     "raw_normalization",
 ]
 
-NormMethod = Literal[
+NORM_METHOD = Literal[
     "mean",
     "median",
     "zscore",
@@ -52,13 +55,8 @@ NormMethod = Literal[
     "minmax",
 ]
 
-###################################
-######## PROTOCOL CLASSES  ########
-###################################
-
 
-@runtime_checkable
-class NMFeature(Protocol):
+class NMFeature:
     def __init__(
         self, settings: "NMSettings", ch_names: Sequence[str], sfreq: int | float
     ) -> None: ...
@@ -79,46 +77,10 @@ class NMFeature(Protocol):
         ...
 
 
-class NMPreprocessor(Protocol):
-    def __init__(self, sfreq: float, settings: "NMSettings") -> None: ...
-
+class NMPreprocessor:
     def process(self, data: "np.ndarray") -> "np.ndarray": ...
 
 
-###################################
-######## PYDANTIC CLASSES  ########
-###################################
-
-
-class NMBaseModel(BaseModel):
-    model_config = ConfigDict(validate_assignment=False, extra="allow")
-
-    def __init__(self, *args, **kwargs) -> None:
-        if kwargs:
-            super().__init__(**kwargs)
-        else:
-            field_names = list(self.model_fields.keys())
-            kwargs = {}
-            for i in range(len(args)):
-                kwargs[field_names[i]] = args[i]
-            super().__init__(**kwargs)
-
-    def __str__(self):
-        return pformat(self.model_dump())
-
-    def __repr__(self):
-        return pformat(self.model_dump())
-
-    def validate(self) -> Any:  # type: ignore
-        return self.model_validate(self.model_dump())
-
-    def __getitem__(self, key):
-        return getattr(self, key)
-
-    def __setitem__(self, key, value) -> None:
-        setattr(self, key, value)
-
-
 class FrequencyRange(NMBaseModel):
     frequency_low_hz: float = Field(gt=0)
     frequency_high_hz: float = Field(gt=0)
@@ -144,28 +106,18 @@ class FrequencyRange(NMBaseModel):
     @model_validator(mode="after")
     def validate_range(self):
         if not (isnan(self.frequency_high_hz) or isnan(self.frequency_low_hz)):
-            assert (
-                self.frequency_high_hz > self.frequency_low_hz
-            ), "Frequency high must be greater than frequency low"
+            assert self.frequency_high_hz > self.frequency_low_hz, (
+                "Frequency high must be greater than frequency low"
+            )
         return self
 
-    @classmethod
-    def create_from(cls, input) -> "FrequencyRange":
-        match input:
-            case FrequencyRange():
-                return input
-            case dict() if "frequency_low_hz" in input and "frequency_high_hz" in input:
-                return FrequencyRange(
-                    input["frequency_low_hz"], input["frequency_high_hz"]
-                )
-            case Sequence() if len(input) == 2:
-                return FrequencyRange(input[0], input[1])
-            case _:
-                raise ValueError("Invalid input for FrequencyRange creation.")
-
     @model_validator(mode="before")
     @classmethod
     def check_input(cls, input):
+        """Pydantic validator to convert the input to a dictionary when passed as a list
+        as we have it by default in the default_settings.yaml file
+        For example, [1,2] will be converted to {"frequency_low_hz": 1, "frequency_high_hz": 2}
+        """
         match input:
             case dict() if "frequency_low_hz" in input and "frequency_high_hz" in input:
                 return input
@@ -209,43 +161,17 @@ class BoolSelector(NMBaseModel):
         for f in cls.list_all():
             print(f)
 
-    @classmethod
-    def get_fields(cls):
-        return cls.model_fields
-
-
-def create_validation_error(
-    error_message: str,
-    loc: list[str | int] = None,
-    title: str = "Validation Error",
-    input_type: Literal["python", "json"] = "python",
-    hide_input: bool = False,
-) -> ValidationError:
-    """
-    Factory function to create a Pydantic v2 ValidationError instance from a single error message.
-
-    Args:
-    error_message (str): The error message for the ValidationError.
-    loc (List[str | int], optional): The location of the error. Defaults to None.
-    title (str, optional): The title of the error. Defaults to "Validation Error".
-    input_type (Literal["python", "json"], optional): Whether the error is for a Python object or JSON. Defaults to "python".
-    hide_input (bool, optional): Whether to hide the input value in the error message. Defaults to False.
-
-    Returns:
-    ValidationError: A Pydantic ValidationError instance.
-    """
-    if loc is None:
-        loc = []
-
-    line_errors = [
-        InitErrorDetails(
-            type="value_error", loc=tuple(loc), input=None, ctx={"error": error_message}
-        )
-    ]
-
-    return ValidationError.from_exception_data(
-        title=title,
-        line_errors=line_errors,
-        input_type=input_type,
-        hide_input=hide_input,
-    )
+
+#################
+### GUI TYPES ###
+#################
+
+
+class FileInfo(BaseModel):
+    name: str
+    path: str
+    dir: str
+    is_directory: bool
+    size: int
+    created_at: datetime
+    modified_at: datetime

{py_neuromodulation-0.0.7.dist-info → py_neuromodulation-0.1.1.dist-info}/METADATA

@@ -1,9 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: py_neuromodulation
-Version: 0.0.7
+Version: 0.1.1
 Summary: Real-time analysis of intracranial neurophysiology recordings.
-Project-URL: bugtracker, https://github.com/neuromodulation/py_neuromodulation/issues
-Project-URL: repository, https://github.com/neuromodulation/py_neuromodulation
+Project-URL: Homepage, https://neuromodulation.github.io/py_neuromodulation/
+Project-URL: Documentation, https://neuromodulation.github.io/py_neuromodulation/
+Project-URL: Repository, https://github.com/neuromodulation/py_neuromodulation
+Project-URL: Issues, https://github.com/neuromodulation/py_neuromodulation/issues
 Author-email: Timon Merk <timon.merk@charite.de>
 Maintainer: Timon Merk
 License: MIT License
@@ -34,7 +36,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
+Requires-Dist: cbor2>=5.6.4
+Requires-Dist: fastapi
 Requires-Dist: fooof
+Requires-Dist: imbalanced-learn
 Requires-Dist: joblib>=1.3.2
 Requires-Dist: llvmlite>=0.43.0
 Requires-Dist: matplotlib>=3.9.0
@@ -43,18 +48,25 @@ Requires-Dist: mne-bids>=0.8
 Requires-Dist: mne-connectivity
 Requires-Dist: mne-lsl>=1.2.0
 Requires-Dist: mrmr-selection
+Requires-Dist: msgpack>=1.1.0
+Requires-Dist: nibabel>=5.3.2
 Requires-Dist: nolds>=0.6.1
 Requires-Dist: numba>=0.60.0
 Requires-Dist: numpy>=1.21.2
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: pyarrow>=14.0.2
 Requires-Dist: pybispectra>=1.2.0
 Requires-Dist: pydantic>=2.7.3
 Requires-Dist: pyparrm
+Requires-Dist: pywebview
 Requires-Dist: scikit-learn>=0.24.2
 Requires-Dist: scikit-optimize
 Requires-Dist: scipy>=1.7.1
 Requires-Dist: seaborn>=0.11
+Requires-Dist: skops>=0.10.0
+Requires-Dist: uvicorn[standard]>=0.30.6
+Requires-Dist: uvloop; platform_system != 'Windows'
 Provides-Extra: dev
 Requires-Dist: notebook; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
@@ -81,6 +93,8 @@ Description-Content-Type: text/x-rst
 py_neuromodulation
 ==================
 
+Documentation: https://neuromodulation.github.io/py_neuromodulation/
+
 Analyzing neural data can be a troublesome, trial and error prone,
 and beginner unfriendly process. *py_neuromodulation* allows using a simple
 interface for extraction of established neurophysiological features and includes commonly applied pre -and postprocessing methods.
@@ -161,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
 ----------