braindecode 1.3.0.dev177628147__py3-none-any.whl → 1.3.0.dev182330353__py3-none-any.whl

braindecode/preprocessing/eegprep_preprocess.py

@@ -77,14 +77,6 @@ class EEGPrepBasePreprocessor(Preprocessor):
         self.record_orig_chanlocs = record_orig_chanlocs
         self.force_dtype = np.dtype(force_dtype) if force_dtype is not None else None
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "can_change_duration",
-            "record_orig_chanlocs",
-            "force_dtype",
-        ]
-
     @abstractmethod
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure. Overridden by subclass."""
@@ -388,46 +380,31 @@ class EEGPrep(EEGPrepBasePreprocessor):
             can_change_duration=can_change_duration or False,
         )
         self.resample_to = resample_to
-        self.bad_channel_reinterpolate = bad_channel_reinterpolate
+        self.reinterpolate = bad_channel_reinterpolate
         self.common_avg_ref = common_avg_ref
         self.burst_removal_cutoff = burst_removal_cutoff
         self.bad_window_max_bad_channels = bad_window_max_bad_channels
-        self.bad_channel_corr_threshold = bad_channel_corr_threshold
-        self.highpass_frequencies = highpass_frequencies
-        self.flatline_maxdur = flatline_maxdur
-        self.bad_channel_hf_threshold = bad_channel_hf_threshold
-        self.bad_channel_max_broken_time = bad_channel_max_broken_time
-        self.bad_window_tolerances = bad_window_tolerances
-        self.refdata_max_bad_channels = refdata_max_bad_channels
-        self.refdata_max_tolerances = refdata_max_tolerances
-        self.num_samples = num_samples
-        self.subset_size = subset_size
-        self.bad_channel_nolocs_threshold = bad_channel_nolocs_threshold
-        self.bad_channel_nolocs_exclude_frac = bad_channel_nolocs_exclude_frac
-        self.max_mem_mb = max_mem_mb
 
-    @property
-    def clean_artifacts_params(self):
-        if self.bad_channel_corr_threshold is None:
+        if bad_channel_corr_threshold is None:
             line_noise_crit = None
         else:
-            line_noise_crit = self.bad_channel_hf_threshold
-        return dict(
-            ChannelCriterion=self.bad_channel_corr_threshold,
+            line_noise_crit = bad_channel_hf_threshold
+        self.clean_artifacts_params = dict(
+            ChannelCriterion=bad_channel_corr_threshold,
             LineNoiseCriterion=line_noise_crit,
-            BurstCriterion=self.burst_removal_cutoff,
-            WindowCriterion=self.bad_window_max_bad_channels,
-            Highpass=self.highpass_frequencies,
-            ChannelCriterionMaxBadTime=self.bad_channel_max_broken_time,
-            BurstCriterionRefMaxBadChns=self.refdata_max_bad_channels,
-            BurstCriterionRefTolerances=self.refdata_max_tolerances,
-            WindowCriterionTolerances=self.bad_window_tolerances,
-            FlatlineCriterion=self.flatline_maxdur,
-            NumSamples=self.num_samples,
-            SubsetSize=self.subset_size,
-            NoLocsChannelCriterion=self.bad_channel_nolocs_threshold,
-            NoLocsChannelCriterionExcluded=self.bad_channel_nolocs_exclude_frac,
-            MaxMem=self.max_mem_mb,
+            BurstCriterion=burst_removal_cutoff,
+            WindowCriterion=bad_window_max_bad_channels,
+            Highpass=highpass_frequencies,
+            ChannelCriterionMaxBadTime=bad_channel_max_broken_time,
+            BurstCriterionRefMaxBadChns=refdata_max_bad_channels,
+            BurstCriterionRefTolerances=refdata_max_tolerances,
+            WindowCriterionTolerances=bad_window_tolerances,
+            FlatlineCriterion=flatline_maxdur,
+            NumSamples=num_samples,
+            SubsetSize=subset_size,
+            NoLocsChannelCriterion=bad_channel_nolocs_threshold,
+            NoLocsChannelCriterionExcluded=bad_channel_nolocs_exclude_frac,
+            MaxMem=max_mem_mb,
             # For reference, the function additionally accepts these (legacy etc.)
             # arguments, which we're not exposing here (current defaults as below):
             # BurstRejection='off',
@@ -437,29 +414,6 @@ class EEGPrep(EEGPrepBasePreprocessor):
             # availableRAM_GB=None,
         )
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "resample_to",
-            "bad_channel_reinterpolate",
-            "common_avg_ref",
-            "burst_removal_cutoff",
-            "bad_window_max_bad_channels",
-            "bad_channel_corr_threshold",
-            "highpass_frequencies",
-            "flatline_maxdur",
-            "bad_channel_hf_threshold",
-            "bad_channel_max_broken_time",
-            "bad_window_tolerances",
-            "refdata_max_bad_channels",
-            "refdata_max_tolerances",
-            "num_samples",
-            "subset_size",
-            "bad_channel_nolocs_threshold",
-            "bad_channel_nolocs_exclude_frac",
-            "max_mem_mb",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         # remove per-channel DC offset (can be huge)
@@ -495,9 +449,7 @@ class EEGPrep(EEGPrepBasePreprocessor):
             eeg["data"] = eeg["data"].astype(np.float32)
 
         # optionally reinterpolate dropped channels
-        if self.bad_channel_reinterpolate and (
-            len(orig_chanlocs) > len(eeg["chanlocs"])
-        ):
+        if self.reinterpolate and (len(orig_chanlocs) > len(eeg["chanlocs"])):
             eeg = eegprep.eeg_interp(eeg, orig_chanlocs)
 
         # optionally apply common average reference
@@ -561,13 +513,6 @@ class RemoveFlatChannels(EEGPrepBasePreprocessor):
         self.max_flatline_duration = max_flatline_duration
         self.max_allowed_jitter = max_allowed_jitter
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "max_flatline_duration",
-            "max_allowed_jitter",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_flatlines(
@@ -664,14 +609,6 @@ class RemoveDrifts(EEGPrepBasePreprocessor):
         self.attenuation = attenuation
         self.method = method
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "transition",
-            "attenuation",
-            "method",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_drifts(
@@ -738,10 +675,6 @@ class Resampling(EEGPrepBasePreprocessor):
         super().__init__(can_change_duration=True)
         self.sfreq = sfreq
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + ["sfreq"]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         if self.sfreq is not None:
@@ -846,17 +779,6 @@ class RemoveBadChannels(EEGPrepBasePreprocessor):
         self.num_samples = num_samples
         self.subset_size = subset_size
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "corr_threshold",
-            "noise_threshold",
-            "window_len",
-            "max_broken_time",
-            "num_samples",
-            "subset_size",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_channels(
@@ -947,16 +869,6 @@ class RemoveBadChannelsNoLocs(EEGPrepBasePreprocessor):
         self.max_broken_time = max_broken_time
         self.linenoise_aware = linenoise_aware
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "min_corr",
-            "ignored_quantile",
-            "window_len",
-            "max_broken_time",
-            "linenoise_aware",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg, _ = eegprep.clean_channels_nolocs(
@@ -1070,19 +982,6 @@ class RemoveBursts(EEGPrepBasePreprocessor):
         self.ref_wndlen = ref_wndlen
         self.maxmem = maxmem
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "cutoff",
-            "window_len",
-            "step_size",
-            "max_dims",
-            "ref_maxbadchannels",
-            "ref_tolerances",
-            "ref_wndlen",
-            "maxmem",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_asr(
@@ -1199,20 +1098,6 @@ class RemoveBadWindows(EEGPrepBasePreprocessor):
         self.step_sizes = step_sizes
         self.shape_range = shape_range
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "max_bad_channels",
-            "zthresholds",
-            "window_len",
-            "window_overlap",
-            "max_dropout_fraction",
-            "min_clean_fraction",
-            "truncate_quant",
-            "step_sizes",
-            "shape_range",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg, _ = eegprep.clean_windows(

braindecode/preprocessing/mne_preprocess.py

@@ -38,60 +38,24 @@ def _generate_init_method(func, force_copy_false=False):
     force_copy_false : bool
         If True, forces copy=False by default for functions that have a copy parameter.
     """
-    func_name = func.__name__
     parameters = list(inspect.signature(func).parameters.values())
-    param_names = [
-        param.name
-        for param in parameters[1:]  # Skip 'self' or 'raw' or 'epochs'
-    ]
-    all_mandatory = [
-        param.name
-        for param in parameters[1:]  # Skip 'self' or 'raw' or 'epochs'
-        if param.default == inspect.Parameter.empty
-    ]
+    param_names = [param.name for param in parameters]
 
     def init_method(self, *args, **kwargs):
-        used = []
-        mandatory = list(all_mandatory)
-        init_kwargs = {}
-
         # For standalone functions with copy parameter, set copy=False by default
         if force_copy_false and "copy" in param_names and "copy" not in kwargs:
             kwargs["copy"] = False
 
         for name, value in zip(param_names, args):
-            init_kwargs[name] = value
-            used.append(name)
-            if name in mandatory:
-                mandatory.remove(name)
+            setattr(self, name, value)
         for name, value in kwargs.items():
-            if name in used:
-                raise TypeError(f"Multiple values for argument '{name}'")
-            if name not in param_names:
-                raise TypeError(
-                    f"'{name}' is an invalid keyword argument for {func_name}()"
-                )
-            init_kwargs[name] = value
-            if name in mandatory:
-                mandatory.remove(name)
-        if len(mandatory) > 0:
-            raise TypeError(
-                f"{func_name}() missing required arguments: {', '.join(mandatory)}"
-            )
-        Preprocessor.__init__(self, fn=func_name, apply_on_array=False, **init_kwargs)
+            setattr(self, name, value)
+        self.kwargs = kwargs
 
     init_method.__signature__ = inspect.signature(func)
     return init_method
 
 
-def _generate_repr_method(class_name):
-    def repr_method(self):
-        args_str = ", ".join(f"{k}={v.__repr__()}" for k, v in self.kwargs.items())
-        return f"{class_name}({args_str})"
-
-    return repr_method
-
-
 def _generate_mne_pre_processor(function):
     """
     Generate a class based on an MNE function for preprocessing.
@@ -105,14 +69,10 @@ def _generate_mne_pre_processor(function):
     class_name = "".join(word.title() for word in function.__name__.split("_")).replace(
         "Eeg", "EEG"
     )
-
-    # Automatically determine if function is standalone
-    is_standalone = _is_standalone_function(function)
-
     # Create a wrapper note that references the original MNE function
     # For Raw methods, use mne.io.Raw.method_name format with :meth:
     # For standalone functions, use the function name only with :func:
-    if not is_standalone:
+    if hasattr(mne.io.Raw, function.__name__):
         ref_path = f"mne.io.Raw.{function.__name__}"
         ref_role = "meth"
     else:
@@ -136,10 +96,6 @@ def _generate_mne_pre_processor(function):
 
     base_classes = (Preprocessor,)
 
-    # Check if function has a 'copy' parameter
-    sig = inspect.signature(function)
-    has_copy_param = "copy" in sig.parameters
-    force_copy_false = is_standalone and has_copy_param
     # Automatically determine if function is standalone
     is_standalone = _is_standalone_function(function)
 
@@ -147,13 +103,26 @@ def _generate_mne_pre_processor(function):
     sig = inspect.signature(function)
     has_copy_param = "copy" in sig.parameters
     force_copy_false = is_standalone and has_copy_param
-    class_attrs = {
-        "__init__": _generate_init_method(function, force_copy_false),
-        "__doc__": wrapper_note + (function.__doc__ or ""),
-        "__repr__": _generate_repr_method(class_name),
-        "fn": function if is_standalone else function.__name__,
-        "_is_standalone": is_standalone,
-    }
+
+    if is_standalone:
+        # For standalone functions, store the actual function object
+        class_attrs = {
+            "__init__": _generate_init_method(
+                function, force_copy_false=force_copy_false
+            ),
+            "__doc__": wrapper_note + (function.__doc__ or ""),
+            "fn": function,  # Store the function itself, not the name
+            "_is_standalone": True,
+        }
+    else:
+        # For methods, store the function name as before
+        class_attrs = {
+            "__init__": _generate_init_method(function),
+            "__doc__": wrapper_note + (function.__doc__ or ""),
+            "fn": function.__name__,
+            "_is_standalone": False,
+        }
+
     generated_class = type(class_name, base_classes, class_attrs)
 
     return generated_class

braindecode/preprocessing/preprocess.py

@@ -13,9 +13,7 @@ from __future__ import annotations
 import platform
 import sys
 from collections.abc import Iterable
-from functools import cached_property, partial
-from importlib import import_module
-from inspect import signature
+from functools import partial
 from warnings import warn
 
 if sys.version_info < (3, 9):
@@ -34,7 +32,6 @@ from braindecode.datasets.base import (
     BaseConcatDataset,
     EEGWindowsDataset,
     RawDataset,
-    RecordDataset,
     WindowsDataset,
 )
 from braindecode.datautil.serialization import (
@@ -72,30 +69,7 @@ class Preprocessor(object):
     def __init__(self, fn: Callable | str, *, apply_on_array: bool = True, **kwargs):
         if hasattr(fn, "__name__") and fn.__name__ == "<lambda>":
             warn("Preprocessing choices with lambda functions cannot be saved.")
-        if apply_on_array and not callable(fn):
-            warn(
-                "apply_on_array can only be True if fn is a callable function. "
-                "Automatically correcting to apply_on_array=False."
-            )
-            apply_on_array = False
-        # We store the exact input parameters. Simpler for serialization.
-        self.fn = fn
-        self.apply_on_array = apply_on_array
-        self.kwargs = kwargs
-
-    @property
-    def _all_attrs(self):
-        return ["fn", "apply_on_array", "kwargs"]
-
-    @property
-    def _init_attrs(self):
-        return [k for k in self._all_attrs if k in signature(self.__init__).parameters]
-
-    @cached_property
-    def _function(self):
-        kwargs = dict(self.kwargs)
-        fn = self.fn
-        if self.apply_on_array:
+        if callable(fn) and apply_on_array:
             channel_wise = kwargs.pop("channel_wise", False)
             picks = kwargs.pop("picks", None)
             n_jobs = kwargs.pop("n_jobs", 1)
@@ -106,21 +80,12 @@ class Preprocessor(object):
                 n_jobs=n_jobs,
             )
             fn = "apply_function"
-
-        if callable(fn):
-            return partial(fn, **kwargs)
-        return partial(self._apply_str, fn=fn, **kwargs)
-
-    @staticmethod
-    def _apply_str(raw_or_epochs: BaseRaw | BaseEpochs, fn: str, **kwargs):
-        if not hasattr(raw_or_epochs, fn):
-            raise AttributeError(f"MNE object does not have a {fn} method.")
-        return getattr(raw_or_epochs, fn)(**kwargs)
+        self.fn = fn
+        self.kwargs = kwargs
 
     def apply(self, raw_or_epochs: BaseRaw | BaseEpochs):
-        function = self._function
         try:
-            result = function(raw_or_epochs)
+            return self._try_apply(raw_or_epochs)
         except RuntimeError:
             # Maybe the function needs the data to be loaded and the data was
             # not loaded yet. Not all MNE functions need data to be loaded,
@@ -128,83 +93,20 @@ class Preprocessor(object):
             # without preloading data which can make the overall preprocessing
             # pipeline substantially faster.
             raw_or_epochs.load_data()
-            result = function(raw_or_epochs)
-        if result is not None:
-            return result
-        return raw_or_epochs
-
-    def serialize(self):
-        """Return a serializable representation of the Preprocessor.
-
-        Returns
-        -------
-        dict
-            Dictionary with keys 'fn' and 'kwargs' representing the
-            Preprocessor.
-        """
-        out = {k: getattr(self, k) for k in self._init_attrs}
-        if "fn" in out and callable(self.fn):
-            out["fn"] = self.fn.__module__ + "." + self.fn.__name__
-        out["__class_path__"] = (
-            self.__class__.__module__ + "." + self.__class__.__name__
-        )
-        if "kwargs" not in out and self.kwargs:
-            out["kwargs"] = self.kwargs
-        return out
-
-    @classmethod
-    def deserialize(cls_parent, data: dict):
-        """Create a Preprocessor from its serializable representation.
-
-        Parameters
-        ----------
-        data : dict
-            Dictionary with keys 'fn' and 'kwargs' representing the
-            Preprocessor.
-        Returns
-        -------
-        Preprocessor
-            The deserialized Preprocessor object.
-        """
-        class_path = data.pop("__class_path__")
-        cls_name = class_path.split(".")[-1]
-        cls_module_name = ".".join(class_path.split(".")[:-1])
-        cls_module = import_module(cls_module_name)
-        cls = getattr(cls_module, cls_name)
-
-        kwargs = data.pop("kwargs") if "kwargs" in data else {}
-
-        fn = data.get("fn", None)
-        if fn is not None and "." in fn:  # callable function
-            fn_name = fn.split(".")[-1]
-            module_name = ".".join(fn.split(".")[:-1])
-            module = import_module(module_name)
-            data["fn"] = getattr(module, fn_name)
-
-        return cls(**data, **kwargs)
-
-    def __repr__(self):
-        cls_name = self.__class__.__name__
-        args_str = ", ".join(
-            f"{k}={getattr(self, k).__repr__()}" for k in self._init_attrs
-        )
-        return f"{cls_name}({args_str})"
-
-    def _same_attr(self, other, attr):
-        a = getattr(self, attr)
-        b = getattr(other, attr)
-        if attr == "fn" and callable(a):
-            return a.__module__ == b.__module__ and a.__name__ == b.__name__
-        if isinstance(a, np.ndarray):
-            return np.array_equal(a, b)
-        return a == b
-
-    def __eq__(self, other):
-        if not isinstance(other, Preprocessor):
-            return False
-        return all(self._same_attr(other, attr) for attr in self._all_attrs) and (
-            self.__class__ == other.__class__
-        )
+            return self._try_apply(raw_or_epochs)
+
+    def _try_apply(self, raw_or_epochs):
+        if callable(self.fn):
+            result = self.fn(raw_or_epochs, **self.kwargs)
+            # For standalone functions that return a new object, propagate it back
+            if result is not None and result is not raw_or_epochs:
+                return result
+            return raw_or_epochs
+        else:
+            if not hasattr(raw_or_epochs, self.fn):
+                raise AttributeError(f"MNE object does not have a {self.fn} method.")
+            getattr(raw_or_epochs, self.fn)(**self.kwargs)
+            return raw_or_epochs
 
 
 def preprocess(
@@ -326,12 +228,7 @@ def _replace_inplace(concat_ds, new_concat_ds):
 
 
 def _preprocess(
-    ds: RecordDataset,
-    ds_index,
-    preprocessors,
-    save_dir=None,
-    overwrite=False,
-    copy_data=False,
+    ds, ds_index, preprocessors, save_dir=None, overwrite=False, copy_data=False
 ):
     """Apply preprocessor(s) to Raw or Epochs object.
 
@@ -390,6 +287,25 @@ def _preprocess(
         return ds
 
 
+def _get_preproc_kwargs(preprocessors):
+    preproc_kwargs = []
+    for p in preprocessors:
+        # in case of a mne function, fn is a str, kwargs is a dict
+        func_name = p.fn
+        func_kwargs = p.kwargs
+        # in case of another function
+        # if apply_on_array=False
+        if callable(p.fn):
+            func_name = p.fn.__name__
+        # if apply_on_array=True
+        else:
+            if "fun" in p.fn:
+                func_name = p.kwargs["fun"].func.__name__
+                func_kwargs = p.kwargs["fun"].keywords
+        preproc_kwargs.append((func_name, func_kwargs))
+    return preproc_kwargs
+
+
 def _set_preproc_kwargs(ds, preprocessors):
     """Record preprocessing keyword arguments in RecordDataset.
 
@@ -400,7 +316,7 @@ def _set_preproc_kwargs(ds, preprocessors):
     preprocessors : list
         List of preprocessors.
     """
-    preproc_kwargs = [p.serialize() for p in preprocessors]
+    preproc_kwargs = _get_preproc_kwargs(preprocessors)
     if isinstance(ds, WindowsDataset):
         kind = "window"
     elif isinstance(ds, EEGWindowsDataset):
@@ -409,8 +325,7 @@ def _set_preproc_kwargs(ds, preprocessors):
         kind = "raw"
     else:
         raise TypeError(f"ds must be a RecordDataset, got {type(ds)}")
-    old_preproc_kwargs = getattr(ds, kind + "_preproc_kwargs")
-    old_preproc_kwargs.extend(preproc_kwargs)
+    setattr(ds, kind + "_preproc_kwargs", preproc_kwargs)
 
 
 def exponential_moving_standardize(

braindecode/preprocessing/util.py

@@ -5,7 +5,6 @@
 # License: BSD-3
 
 import base64
-import inspect
 import json
 import re
 from typing import Any
@@ -13,8 +12,6 @@ from typing import Any
 import numpy as np
 from mne.io.base import BaseRaw
 
-from braindecode import preprocessing
-
 __all__ = ["mne_store_metadata", "mne_load_metadata"]
 
 
@@ -26,14 +23,6 @@ _MARKER_END = "-->"
 # Marker key for numpy arrays
 _NP_ARRAY_TAG = "__numpy_array__"
 
-preprocessor_dict = {}
-
-
-def _init_preprocessor_dict():
-    for m in inspect.getmembers(preprocessing, inspect.isclass):
-        if issubclass(m[1], preprocessing.Preprocessor):
-            preprocessor_dict[m[0]] = m[1]
-
 
 def _numpy_decoder(dct):
     """Internal JSON decoder hook to handle numpy arrays."""

braindecode/version.py

@@ -1 +1 @@
-__version__ = "1.3.0.dev177628147"
+__version__ = "1.3.0.dev182330353"

{braindecode-1.3.0.dev177628147.dist-info → braindecode-1.3.0.dev182330353.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.3.0.dev177628147
+Version: 1.3.0.dev182330353
 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>
+Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>
 License: BSD-3-Clause
 Project-URL: homepage, https://braindecode.org
@@ -38,14 +38,12 @@ Requires-Dist: wfdb
 Requires-Dist: h5py
 Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
-Requires-Dist: rotary_embedding_torch
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.2.0; extra == "moabb"
 Provides-Extra: eegprep
 Requires-Dist: eegprep[eeglabio]>=0.1.1; extra == "eegprep"
-Provides-Extra: hub
-Requires-Dist: huggingface_hub[torch]>=0.20.0; extra == "hub"
-Requires-Dist: zarr<3.0,>=2.18; extra == "hub"
+Provides-Extra: hug
+Requires-Dist: huggingface_hub[torch]>=0.20.0; extra == "hug"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
@@ -71,11 +69,7 @@ Requires-Dist: pre-commit; extra == "docs"
 Requires-Dist: openneuro-py; extra == "docs"
 Requires-Dist: plotly; extra == "docs"
 Provides-Extra: all
-Requires-Dist: braindecode[moabb]; extra == "all"
-Requires-Dist: braindecode[hub]; extra == "all"
-Requires-Dist: braindecode[tests]; extra == "all"
-Requires-Dist: braindecode[docs]; extra == "all"
-Requires-Dist: braindecode[eegprep]; extra == "all"
+Requires-Dist: braindecode[docs,eegprep,hug,moabb,tests]; extra == "all"
 Dynamic: license-file
 
 .. image:: https://badges.gitter.im/braindecodechat/community.svg