Braindecode 1.8.0.dev1058__tar.gz → 1.8.0.dev1122__tar.gz

{braindecode-1.8.0.dev1058/braindecode.egg-info → braindecode-1.8.0.dev1122}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0.dev1058
+Version: 1.8.0.dev1122
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Alexandre Gramfort <agramfort@meta.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>

{braindecode-1.8.0.dev1058 → braindecode-1.8.0.dev1122}/braindecode/datasets/bids/hub.py

@@ -28,7 +28,6 @@ The format follows a BIDS-inspired sourcedata structure:
 # License: BSD (3-clause)
 
 import contextlib
-import copy
 import json
 import logging
 import tempfile
@@ -57,7 +56,6 @@ from .hub_io import (
     _load_eegwindows_from_zarr,
     _load_raw_from_zarr,
     _load_windows_from_zarr,
-    _prepare_info_for_json,
     _save_eegwindows_to_zarr,
     _save_raw_to_zarr,
     _save_windows_to_zarr,
@@ -74,33 +72,6 @@ log = logging.getLogger(__name__)
 _LOCK_FILE = "format_info.json"
 
 
-def _normalize_kwargs_for_json(value, field_name):
-    """Return one preprocessing-kwargs value as native strict JSON."""
-
-    def _convert(obj):
-        if isinstance(obj, np.ndarray):
-            return _convert(obj.tolist())
-        if isinstance(obj, dict):
-            return {key: _convert(item) for key, item in obj.items()}
-        if isinstance(obj, (list, tuple)):
-            return [_convert(item) for item in obj]
-        if isinstance(obj, np.generic):
-            return _convert(obj.item())
-        return obj
-
-    try:
-        converted = _convert(value)
-        if isinstance(converted, str):
-            raise ValueError(
-                "a root string is ambiguous with the legacy encoded format"
-            )
-        return json.loads(json.dumps(converted, allow_nan=False))
-    except (OverflowError, RecursionError, TypeError, ValueError) as error:
-        raise ValueError(
-            f"{field_name} must contain only finite JSON-serializable values"
-        ) from error
-
-
 class HubDatasetMixin:
     """
     Mixin class for Hugging Face Hub integration with EEG datasets.
@@ -714,57 +685,14 @@ class HubDatasetMixin:
                 f"{output_path} already exists. Set overwrite=True to replace it."
             )
 
+        # Create zarr store (zarr v3 API)
+        root = zarr.open(str(output_path), mode="w")
+
         # Validate uniformity across all datasets using shared validation
         dataset_type, _, _ = hub_validation.validate_dataset_uniformity(self.datasets)
 
-        # Normalize every JSON value before opening the output store. The cached
-        # values below are the exact values handed to the write helpers.
-        prepared_infos = []
-        for ds in self.datasets:
-            if dataset_type == "WindowsDataset":
-                info = ds.windows.info
-            elif dataset_type in ("EEGWindowsDataset", "RawDataset"):
-                info = ds.raw.info
-            prepared_infos.append(_prepare_info_for_json(info.to_json_dict()))
-
-        prepared_kwargs = {}
-        for kwarg_name in [
-            "raw_preproc_kwargs",
-            "window_kwargs",
-            "window_preproc_kwargs",
-        ]:
-            expected_present = hasattr(self.datasets[0], kwarg_name)
-            expected_value = None
-            expected_token = None
-            for i_ds, ds in enumerate(self.datasets):
-                present = hasattr(ds, kwarg_name)
-                if present != expected_present:
-                    raise ValueError(
-                        f"{kwarg_name} on dataset {i_ds} has inconsistent presence; "
-                        "the Zarr format stores one global value"
-                    )
-                if not present:
-                    continue
-                value = _normalize_kwargs_for_json(
-                    getattr(ds, kwarg_name), f"{kwarg_name} on dataset {i_ds}"
-                )
-                value_token = json.dumps(
-                    value, sort_keys=True, separators=(",", ":"), allow_nan=False
-                )
-                if i_ds == 0:
-                    expected_value = value
-                    expected_token = value_token
-                elif value_token != expected_token:
-                    raise ValueError(
-                        f"{kwarg_name} on dataset {i_ds} differs from dataset 0; "
-                        "the Zarr format stores one global value"
-                    )
-            if expected_present:
-                prepared_kwargs[kwarg_name] = expected_value
-
-        # Create compressor and zarr store (zarr v3 API) only after preflight.
-        compressor = _create_compressor(compression, compression_level)
-        root = zarr.open(str(output_path), mode="w")
+        # Keep reference to first dataset for preprocessing kwargs
+        first_ds = self.datasets[0]
 
         # Store global metadata
         root.attrs["n_datasets"] = len(self.datasets)
@@ -778,10 +706,21 @@ class HubDatasetMixin:
         root.attrs["zarr_version"] = zarr.__version__
         root.attrs["scipy_version"] = scipy.__version__
 
-        # Save preprocessing kwargs from the preflight cache. These are
-        # typically set by windowing functions on individual datasets.
-        for kwarg_name, kwargs in prepared_kwargs.items():
-            root.attrs[kwarg_name] = kwargs
+        # Save preprocessing kwargs (check first dataset, assuming uniform preprocessing)
+        # These are typically set by windowing functions on individual datasets
+        for kwarg_name in [
+            "raw_preproc_kwargs",
+            "window_kwargs",
+            "window_preproc_kwargs",
+        ]:
+            # Check first dataset for these attributes
+            if hasattr(first_ds, kwarg_name):
+                kwargs = getattr(first_ds, kwarg_name)
+                if kwargs:
+                    root.attrs[kwarg_name] = json.dumps(kwargs)
+
+        # Create compressor
+        compressor = _create_compressor(compression, compression_level)
 
         # Save each recording
         for i_ds, ds in enumerate(self.datasets):
@@ -792,7 +731,7 @@ class HubDatasetMixin:
                 data = ds.windows.get_data()
                 metadata = ds.windows.metadata
                 description = ds.description
-                info_dict = prepared_infos[i_ds]
+                info_dict = ds.windows.info.to_json_dict()
                 target_name = ds.target_name if hasattr(ds, "target_name") else None
 
                 # Save using inlined function
@@ -811,7 +750,7 @@ class HubDatasetMixin:
                 raw = ds.raw
                 metadata = ds.metadata
                 description = ds.description
-                info_dict = prepared_infos[i_ds]
+                info_dict = ds.raw.info.to_json_dict()
                 targets_from = ds.targets_from
                 last_target_only = ds.last_target_only
 
@@ -832,7 +771,7 @@ class HubDatasetMixin:
                 # Get continuous raw data from RawDataset
                 raw = ds.raw
                 description = ds.description
-                info_dict = prepared_infos[i_ds]
+                info_dict = ds.raw.info.to_json_dict()
                 target_name = ds.target_name if hasattr(ds, "target_name") else None
 
                 # Save using inlined function
@@ -1017,14 +956,10 @@ class HubDatasetMixin:
             "window_preproc_kwargs",
         ]:
             if kwarg_name in root.attrs:
-                kwargs = root.attrs[kwarg_name]
-                if isinstance(kwargs, str):
-                    # Stores written by older braindecode versions kept
-                    # these attributes as double-encoded JSON strings.
-                    kwargs = json.loads(kwargs)
+                kwargs = json.loads(root.attrs[kwarg_name])
                 # Set on each individual dataset (where they were originally stored)
                 for ds in datasets:
-                    setattr(ds, kwarg_name, copy.deepcopy(kwargs))
+                    setattr(ds, kwarg_name, kwargs)
 
         return concat_ds
 

{braindecode-1.8.0.dev1058 → braindecode-1.8.0.dev1122}/braindecode/datasets/bids/hub_io.py

@@ -8,7 +8,6 @@ These functions keep the Zarr serialization details isolated from hub.py.
 from __future__ import annotations
 
 import json
-from numbers import Real
 from pathlib import Path
 
 import numpy as np
@@ -18,78 +17,17 @@ from mne.utils import _soft_import
 zarr = _soft_import("zarr", purpose="hugging face integration", strict=False)
 
 
-def _is_non_bool_real(value):
-    return not isinstance(value, (bool, np.bool_)) and isinstance(
-        value, (Real, np.integer, np.floating)
-    )
-
-
-def _prepare_info_for_json(obj, path="info", *, _in_numeric_sequence=False):
-    """Normalize an MNE Info value to strict JSON without losing sequence NaNs."""
-    if isinstance(obj, np.ndarray):
-        obj = obj.tolist()
-
-    if isinstance(obj, dict):
-        return {
-            key: _prepare_info_for_json(value, f"{path}.{key}")
-            for key, value in obj.items()
-        }
-
-    if isinstance(obj, (list, tuple)):
-        values = list(obj)
-        has_none = any(value is None for value in values)
-        has_number = any(_is_non_bool_real(value) for value in values)
-        all_none = bool(values) and all(value is None for value in values)
-        if all_none or (has_none and has_number):
-            raise ValueError(
-                f"{path} is ambiguous: numeric sequences cannot contain JSON null"
-            )
-
-        is_numeric_sequence = bool(values) and all(
-            _is_non_bool_real(value) for value in values
-        )
-        return [
-            _prepare_info_for_json(
-                value,
-                f"{path}[{index}]",
-                _in_numeric_sequence=is_numeric_sequence,
-            )
-            for index, value in enumerate(values)
-        ]
-
-    if isinstance(obj, (bool, np.bool_)):
-        return bool(obj)
-    if isinstance(obj, (int, np.integer)):
-        return int(obj)
-    if _is_non_bool_real(obj):
-        value = float(obj)
-        if np.isnan(value):
-            if _in_numeric_sequence:
-                return None
-            raise ValueError(f"{path} contains unsupported NaN")
-        if np.isposinf(value):
-            raise ValueError(f"{path} contains positive infinity")
-        if np.isneginf(value):
-            raise ValueError(f"{path} contains negative infinity")
-        return value
-    if obj is None or isinstance(obj, str):
-        return obj
-    raise ValueError(f"{path} contains a non-JSON-serializable value")
-
-
 def _restore_nan_from_json(obj):
-    """Restore NaN values from None in JSON-loaded attributes.
+    """Restore NaN values from None in legacy zarr stores.
 
-    JSON null is reserved for NaN only in non-boolean numeric sequences.
-    All-null lists are therefore the representation of validated all-NaN
-    sequences, while ordinary null values elsewhere remain unchanged.
+    Datasets saved before zarr v3 native NaN support used
+    ``_sanitize_for_json`` to convert NaN/Inf → None. This restores them
+    on load so ``mne.Info.from_json_dict`` gets proper NaN arrays.
     """
     if isinstance(obj, dict):
         return {k: _restore_nan_from_json(v) for k, v in obj.items()}
     if isinstance(obj, list):
-        if len(obj) > 0 and all(
-            value is None or _is_non_bool_real(value) for value in obj
-        ):
+        if len(obj) > 0 and all(isinstance(x, (int, float, type(None))) for x in obj):
             return [np.nan if x is None else x for x in obj]
         return [_restore_nan_from_json(v) for v in obj]
     return obj

{braindecode-1.8.0.dev1058 → braindecode-1.8.0.dev1122}/braindecode/models/base.py

@@ -198,34 +198,7 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
     See :ref:`load-pretrained-models` for a complete tutorial.
     """
 
-    #: Attributes that :func:`torch.jit.script` must not introspect. The
-    #: signal-related properties raise :class:`ValueError` when their value was
-    #: neither given nor inferable, and ``mapping`` carries a postponed
-    #: annotation TorchScript cannot resolve. Either one aborts scripting
-    #: before ``forward`` is ever compiled.
-    __jit_ignored_attributes__ = [
-        *sorted(_EEG_PARAMS),
-        "_chs_info",
-        "input_shape",
-        "mapping",
-    ]
-    #: Rich MNE channel dictionaries are intentionally unavailable in scripted
-    #: forwards; they remain unchanged on eager models and in saved configs.
-    __jit_unused_properties__ = ["chs_info"]
-
     def __init_subclass__(cls, **kwargs):
-        # TorchScript only honours ``__jit_ignored_attributes__`` for
-        # properties defined directly on the concrete class: it collects them
-        # with ``vars(type(module))``, which skips inherited ones. Rebinding
-        # the very same property objects on each subclass makes them visible
-        # there without changing any runtime behaviour.
-        for name in cls.__jit_ignored_attributes__:
-            if name in cls.__dict__:
-                continue
-            prop = getattr(cls, name, None)
-            if isinstance(prop, property):
-                setattr(cls, name, prop)
-
         # Append model-specific Hub integration notes to the docstring.
         # This runs before the metaclass __init__, so the Hub notes will
         # be included in the docstring that the metaclass processes.
@@ -313,12 +286,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         self._chs_info = chs_info  # type: ignore[assignment]
         self._n_outputs = n_outputs  # type: ignore[assignment]
         self._n_chans = n_chans  # type: ignore[assignment]
-        # TorchScript cannot represent the rich MNE dictionaries in _chs_info.
-        # Keep the original eager state above and expose only the derived scalar
-        # to scripted signal-property getters.
-        self._n_chans_for_jit = (
-            len(chs_info) if n_chans is None and chs_info is not None else n_chans
-        )
         self._n_times = n_times  # type: ignore[assignment]
         self._sfreq = sfreq  # type: ignore[assignment]
 
@@ -343,12 +310,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
 
     @property
     def n_chans(self) -> int:
-        if torch.jit.is_scripting():
-            if self._n_chans_for_jit is None:
-                raise ValueError(
-                    "n_chans could not be inferred. Either specify n_chans or chs_info."
-                )
-            return self._n_chans_for_jit
         if self._n_chans is None and self._chs_info is not None:
             return len(self._chs_info)
         elif self._n_chans is None:
@@ -358,7 +319,7 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         return self._n_chans
 
     @property
-    def chs_info(self) -> list[dict]:
+    def chs_info(self) -> list[str]:
         if self._chs_info is None:
             raise ValueError("chs_info not specified.")
         return self._chs_info

{braindecode-1.8.0.dev1058 → braindecode-1.8.0.dev1122}/braindecode/preprocessing/windowers.py

@@ -194,43 +194,6 @@ def _get_use_mne_epochs(use_mne_epochs, reject, picks, flat, drop_bad_windows):
     return use_mne_epochs
 
 
-_LastWindowStrategy = Literal["overlap", "drop"]
-_VALID_LAST_WINDOW_STRATEGIES = ("overlap", "drop")
-
-
-def _resolve_on_last_window(
-    drop_last_window: bool | None,
-    on_last_window: _LastWindowStrategy | None,
-    *,
-    default: _LastWindowStrategy | None,
-) -> _LastWindowStrategy | None:
-    """Resolve the replacement spelling without changing placement semantics."""
-    if drop_last_window is not None and on_last_window is not None:
-        raise ValueError(
-            "Cannot specify both `drop_last_window` and `on_last_window`. "
-            "Use `on_last_window` only, as `drop_last_window` is deprecated."
-        )
-    if (
-        on_last_window is not None
-        and on_last_window not in _VALID_LAST_WINDOW_STRATEGIES
-    ):
-        raise ValueError(
-            "on_last_window must be one of 'overlap' or 'drop', "
-            f"got {on_last_window!r}."
-        )
-    if drop_last_window is not None:
-        warnings.warn(
-            "`drop_last_window` is deprecated and will be removed in version 2.0. "
-            "Use `on_last_window='drop'` if True or "
-            "`on_last_window='overlap'` if False. "
-            "See https://github.com/braindecode/braindecode/pull/1058 for feedback.",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        return "drop" if drop_last_window else "overlap"
-    return default if on_last_window is None else on_last_window
-
-
 # XXX it's called concat_ds...
 def create_windows_from_events(
     concat_ds: BaseConcatDataset[RawDataset],
@@ -238,7 +201,7 @@ def create_windows_from_events(
     trial_stop_offset_samples: int | dict[str, int] = 0,
     window_size_samples: int | None = None,
     window_stride_samples: int | dict[str, int] | None = None,
-    drop_last_window: bool | None = None,
+    drop_last_window: bool = False,
     mapping: dict[str, int] | None = None,
     preload: bool = False,
     drop_bad_windows: bool | None = None,
@@ -251,8 +214,6 @@ def create_windows_from_events(
     on_overlapping_events: Literal["raise", "warn", "ignore"] = "raise",
     n_jobs: int = 1,
     verbose: bool | str | int | None = "error",
-    *,
-    on_last_window: _LastWindowStrategy | None = None,
 ) -> BaseConcatDataset[WindowsDataset | EEGWindowsDataset]:
     """Create windows based on events in mne.Raw.
 
@@ -295,11 +256,10 @@ def create_windows_from_events(
         trial_start_offset_samples and trial_stop_offset_samples.
         If a dict, keys must match the keys of ``mapping`` and different
         strides are applied per event type.
-    drop_last_window: bool | None
-        Deprecated; use ``on_last_window`` instead. Explicit ``False`` maps to
-        ``'overlap'`` and explicit ``True`` maps to ``'drop'``. Either value
-        emits a ``DeprecationWarning`` and this parameter will be removed in
-        version 2.0.
+    drop_last_window: bool
+        If False, an additional overlapping window that ends at
+        trial_stop_offset_samples will be extracted around each event when the
+        last window does not end exactly at trial_stop_offset_samples.
     mapping: dict(str: int)
         Mapping from event description to numerical target value. Must be
         provided when any of ``trial_start_offset_samples``,
@@ -344,25 +304,12 @@ def create_windows_from_events(
         Number of jobs to use to parallelize the windowing.
     verbose: bool | str | int | None
         Control verbosity of the logging output when calling mne.Epochs.
-    on_last_window: {'overlap', 'drop'} | None
-        Behavior when the final regular window does not end exactly at the
-        trial boundary. ``'overlap'`` adds a final overlapping window ending
-        at the boundary; ``'drop'`` does not. Defaults to ``'overlap'`` when
-        neither this parameter nor ``drop_last_window`` is supplied.
 
     Returns
     -------
     windows_datasets: BaseConcatDataset[WindowsDataset | EEGWindowsDataset]
         Concatenated datasets of WindowsDataset containing the extracted windows.
     """
-    on_last_window = _resolve_on_last_window(
-        drop_last_window,
-        on_last_window,
-        default="overlap",
-    )
-    assert on_last_window is not None
-    drop_last_window_for_internal = on_last_window == "drop"
-
     _check_windowing_arguments(
         trial_start_offset_samples,
         trial_stop_offset_samples,
@@ -444,7 +391,7 @@ def create_windows_from_events(
             trial_stop_offset_samples,
             window_size_samples,
             window_stride_samples,
-            drop_last_window_for_internal,
+            drop_last_window,
             mapping,
             preload,
             drop_bad_windows,
@@ -482,8 +429,6 @@ def create_fixed_length_windows(
     use_mne_epochs: bool | None = None,
     n_jobs: int = 1,
     verbose: bool | str | int | None = "error",
-    *,
-    on_last_window: _LastWindowStrategy | None = None,
 ) -> BaseConcatDataset[WindowsDataset | EEGWindowsDataset]:
     """Windower that creates sliding windows.
 
@@ -503,10 +448,9 @@ def create_fixed_length_windows(
         Stride between windows in samples. If None, set to be equal to winddow_size_samples, so
         windows will not overlap.
     drop_last_window: bool | None
-        Deprecated; use ``on_last_window`` instead. Explicit ``False`` maps to
-        ``'overlap'`` and explicit ``True`` maps to ``'drop'``. Either value
-        emits a ``DeprecationWarning`` and this parameter will be removed in
-        version 2.0.
+        Whether or not have a last overlapping window, when windows do not
+        equally divide the continuous signal. Must be set to a bool if window size and stride are
+        not None.
     mapping: dict(str: int)
         Mapping from event description to target value.
     preload: bool
@@ -546,15 +490,6 @@ def create_fixed_length_windows(
         Number of jobs to use to parallelize the windowing.
     verbose: bool | str | int | None
         Control verbosity of the logging output when calling mne.Epochs.
-    on_last_window: {'overlap', 'drop'} | None
-        Behavior when the final regular window does not end exactly at the
-        recording boundary. ``'overlap'`` adds a final overlapping window
-        ending at the boundary; ``'drop'`` does not. A policy is required when
-        both an explicit window size and stride are supplied. A size without a
-        stride defaults to non-overlapping windows and ``'drop'``. With no
-        explicit size or stride, the policy is immaterial and normalizes to
-        the existing single full-recording window. ``'overlap'`` is
-        incompatible with ``lazy_metadata=True``.
 
     Returns
     -------
@@ -563,24 +498,16 @@ def create_fixed_length_windows(
         EEGWindowsDataset objects with the extracted windows, depending on
         the value of ``use_mne_epochs``.
     """
-    on_last_window = _resolve_on_last_window(
-        drop_last_window,
-        on_last_window,
-        default=None,
-    )
-    stop_offset_samples, window_stride_samples, on_last_window = (
+    stop_offset_samples, window_stride_samples, drop_last_window = (
         _check_and_set_fixed_length_window_arguments(
             start_offset_samples,
             stop_offset_samples,
             window_size_samples,
             window_stride_samples,
-            on_last_window,
+            drop_last_window,
             lazy_metadata,
         )
     )
-    drop_last_window_for_internal = (
-        None if on_last_window is None else on_last_window == "drop"
-    )
 
     if drop_bad_windows is not None:
         warnings.warn(
@@ -612,7 +539,7 @@ def create_fixed_length_windows(
             stop_offset_samples,
             window_size_samples,
             window_stride_samples,
-            drop_last_window_for_internal,
+            drop_last_window,
             mapping,
             preload,
             drop_bad_windows,
@@ -1317,17 +1244,17 @@ def _check_and_set_fixed_length_window_arguments(
     stop_offset_samples,
     window_size_samples,
     window_stride_samples,
-    on_last_window,
+    drop_last_window,
     lazy_metadata,
 ):
     """Raises warnings for incorrect input arguments and will set correct default values for
-    stop_offset_samples, window_stride_samples & on_last_window, if necessary.
+    stop_offset_samples, window_stride_samples & drop_last_window, if necessary.
     """
     # default stride to window size for non-overlapping windows
     if window_size_samples is not None and window_stride_samples is None:
         window_stride_samples = window_size_samples
-        if on_last_window is None:
-            on_last_window = "drop"
+        if drop_last_window is None:
+            drop_last_window = True
 
     _check_windowing_arguments(
         start_offset_samples,
@@ -1354,30 +1281,30 @@ def _check_and_set_fixed_length_window_arguments(
     if (
         window_size_samples is not None
         and window_stride_samples is not None
-        and on_last_window is None
+        and drop_last_window is None
     ):
         raise ValueError(
-            "on_last_window must be set if both window_size_samples & "
-            "window_stride_samples have also been set. "
-            "Use 'drop' or 'overlap'."
+            "drop_last_window must be set if both window_size_samples &"
+            " window_stride_samples have also been set"
         )
-    if (
+    elif (
         window_size_samples is None
         and window_stride_samples is None
-        and on_last_window is not None
+        and drop_last_window is False
     ):
-        on_last_window = None
+        # necessary for following assertion
+        drop_last_window = None
 
     assert (
         (window_size_samples is None)
         == (window_stride_samples is None)
-        == (on_last_window is None)
+        == (drop_last_window is None)
     )
-    if on_last_window != "drop" and lazy_metadata:
+    if not drop_last_window and lazy_metadata:
         raise ValueError(
-            "Cannot use on_last_window other than 'drop' with lazy_metadata=True."
+            "Cannot have drop_last_window=False and lazy_metadata=True at the same time."
         )
-    return stop_offset_samples, window_stride_samples, on_last_window
+    return stop_offset_samples, window_stride_samples, drop_last_window
 
 
 def _get_windowing_kwargs(windowing_func_locals):