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

braindecode/preprocessing/mne_preprocess.py

@@ -6,20 +6,46 @@
 # License: BSD-3
 import inspect
 
+import mne.channels
 import mne.io
+import mne.preprocessing
 
 from braindecode.preprocessing.preprocess import Preprocessor
-from braindecode.util import _update_moabb_docstring
 
 
-def _generate_init_method(func):
+def _is_standalone_function(func):
+    """
+    Determine if a function is standalone based on its module.
+
+    Standalone functions are those in mne.preprocessing, mne.channels, mne.filter, etc.
+    that are not methods of mne.io.Raw.
+    """
+    # Check if it's a method of Raw by seeing if it's bound or unbound method
+    if hasattr(mne.io.Raw, func.__name__):
+        return False
+    # Otherwise, it's a standalone function
+    return True
+
+
+def _generate_init_method(func, force_copy_false=False):
     """
     Generate an __init__ method for a class based on the function's signature.
+
+    Parameters
+    ----------
+    func : callable
+        The function to wrap.
+    force_copy_false : bool
+        If True, forces copy=False by default for functions that have a copy parameter.
     """
     parameters = list(inspect.signature(func).parameters.values())
     param_names = [param.name for param in parameters]
 
     def init_method(self, *args, **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):
             setattr(self, name, value)
         for name, value in kwargs.items():
@@ -33,19 +59,70 @@ def _generate_init_method(func):
 def _generate_mne_pre_processor(function):
     """
     Generate a class based on an MNE function for preprocessing.
+
+    Parameters
+    ----------
+    function : callable
+        The MNE function to wrap. Automatically determines if it's standalone
+        or a Raw method based on the function's module and name.
     """
     class_name = "".join(word.title() for word in function.__name__.split("_")).replace(
         "Eeg", "EEG"
     )
-    import_path = f"{function.__module__}.{function.__name__}"
-    doc = f" See more details in {import_path}"
+    # 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 hasattr(mne.io.Raw, function.__name__):
+        ref_path = f"mne.io.Raw.{function.__name__}"
+        ref_role = "meth"
+    else:
+        # For standalone functions, try common MNE public APIs
+        # These are more likely to be in intersphinx inventory
+        func_name = function.__name__
+        if function.__module__.startswith("mne.preprocessing"):
+            ref_path = f"mne.preprocessing.{func_name}"
+        elif function.__module__.startswith("mne.channels"):
+            ref_path = f"mne.channels.{func_name}"
+        elif function.__module__.startswith("mne.filter"):
+            ref_path = f"mne.filter.{func_name}"
+        else:
+            ref_path = f"{function.__module__}.{func_name}"
+        ref_role = "func"
+
+    # Use proper Sphinx cross-reference for intersphinx linking
+    wrapper_note = (
+        f"Braindecode preprocessor wrapper for :{ref_role}:`~{ref_path}`.\n\n"
+    )
 
     base_classes = (Preprocessor,)
-    class_attrs = {
-        "__init__": _generate_init_method(function),
-        "__doc__": _update_moabb_docstring(function, doc),
-        "fn": function.__name__,
-    }
+
+    # Automatically determine if function is standalone
+    is_standalone = _is_standalone_function(function)
+
+    # 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
+
+    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
@@ -53,12 +130,65 @@ def _generate_mne_pre_processor(function):
 
 # List of MNE functions to generate classes for
 mne_functions = [
+    # From mne.filter
     mne.filter.resample,
+    mne.filter.filter_data,
+    mne.filter.notch_filter,
+    # From mne.io.Raw methods
+    mne.io.Raw.add_channels,
+    mne.io.Raw.add_events,
+    mne.io.Raw.add_proj,
+    mne.io.Raw.add_reference_channels,
+    mne.io.Raw.anonymize,
+    mne.io.Raw.apply_gradient_compensation,
+    mne.io.Raw.apply_hilbert,
+    mne.io.Raw.apply_proj,
+    mne.io.Raw.crop,
+    mne.io.Raw.crop_by_annotations,
+    mne.io.Raw.del_proj,
     mne.io.Raw.drop_channels,
     mne.io.Raw.filter,
-    mne.io.Raw.crop,
+    mne.io.Raw.fix_mag_coil_types,
+    mne.io.Raw.interpolate_bads,
+    mne.io.Raw.interpolate_to,
+    mne.io.Raw.notch_filter,
     mne.io.Raw.pick,
+    mne.io.Raw.pick_channels,
+    mne.io.Raw.pick_types,
+    mne.io.Raw.rename_channels,
+    mne.io.Raw.reorder_channels,
+    mne.io.Raw.rescale,
+    mne.io.Raw.resample,
+    mne.io.Raw.savgol_filter,
+    mne.io.Raw.set_annotations,
+    mne.io.Raw.set_channel_types,
     mne.io.Raw.set_eeg_reference,
+    mne.io.Raw.set_meas_date,
+    mne.io.Raw.set_montage,
+    # Standalone functions from mne.preprocessing
+    mne.preprocessing.annotate_amplitude,
+    mne.preprocessing.annotate_break,
+    mne.preprocessing.annotate_movement,
+    mne.preprocessing.annotate_muscle_zscore,
+    mne.preprocessing.annotate_nan,
+    mne.preprocessing.compute_current_source_density,
+    mne.preprocessing.compute_bridged_electrodes,
+    mne.preprocessing.equalize_bads,
+    mne.preprocessing.find_bad_channels_lof,
+    mne.preprocessing.fix_stim_artifact,
+    mne.preprocessing.interpolate_bridged_electrodes,
+    mne.preprocessing.maxwell_filter,
+    mne.preprocessing.oversampled_temporal_projection,
+    mne.preprocessing.realign_raw,
+    mne.preprocessing.regress_artifact,
+    # Standalone functions from mne.channels
+    mne.channels.combine_channels,
+    mne.channels.equalize_channels,
+    mne.channels.rename_channels,
+    # Top-level mne functions for referencing
+    mne.add_reference_channels,
+    mne.set_bipolar_reference,
+    mne.set_eeg_reference,
 ]
 
 # Automatically generate and add classes to the global namespace
@@ -71,6 +201,8 @@ __all__ = [
     class_obj.__name__
     for class_obj in globals().values()
     if isinstance(class_obj, type)
+    and issubclass(class_obj, Preprocessor)
+    and class_obj != Preprocessor
 ]
 
 # Clean up unnecessary variables

braindecode/preprocessing/preprocess.py

@@ -30,8 +30,8 @@ from numpy.typing import NDArray
 
 from braindecode.datasets.base import (
     BaseConcatDataset,
-    BaseDataset,
     EEGWindowsDataset,
+    RawDataset,
     WindowsDataset,
 )
 from braindecode.datautil.serialization import (
@@ -85,7 +85,7 @@ class Preprocessor(object):
 
     def apply(self, raw_or_epochs: BaseRaw | BaseEpochs):
         try:
-            self._try_apply(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,
@@ -93,15 +93,20 @@ class Preprocessor(object):
             # without preloading data which can make the overall preprocessing
             # pipeline substantially faster.
             raw_or_epochs.load_data()
-            self._try_apply(raw_or_epochs)
+            return self._try_apply(raw_or_epochs)
 
     def _try_apply(self, raw_or_epochs):
         if callable(self.fn):
-            self.fn(raw_or_epochs, **self.kwargs)
+            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(
@@ -119,7 +124,7 @@ def preprocess(
     Parameters
     ----------
     concat_ds : BaseConcatDataset
-        A concat of ``BaseDataset`` or ``WindowsDataset`` to be preprocessed.
+        A concat of ``RecordDataset`` to be preprocessed.
     preprocessors : list of Preprocessor
         Preprocessor objects to apply to each dataset.
     save_dir : str | None
@@ -229,15 +234,15 @@ def _preprocess(
 
     Parameters
     ----------
-    ds: BaseDataset | WindowsDataset
+    ds: RecordDataset
         Dataset object to preprocess.
     ds_index : int
-        Index of the BaseDataset in its BaseConcatDataset. Ignored if save_dir
+        Index of the ``RecordDataset`` in its ``BaseConcatDataset``. Ignored if save_dir
         is None.
     preprocessors: list(Preprocessor)
         List of preprocessors to apply to the dataset.
     save_dir : str | None
-        If provided, save the preprocessed BaseDataset in the
+        If provided, save the preprocessed RecordDataset in the
         specified directory.
     overwrite : bool
         If True, overwrite existing file with the same name.
@@ -251,20 +256,25 @@ def _preprocess(
         if raw_or_epochs.preload and copy_data:
             raw_or_epochs._data = raw_or_epochs._data.copy()
         for preproc in preprocessors:
-            preproc.apply(raw_or_epochs)
+            raw_or_epochs = preproc.apply(raw_or_epochs)
+        return raw_or_epochs
 
     if hasattr(ds, "raw"):
         if isinstance(ds, EEGWindowsDataset):
             warn(
                 f"Applying preprocessors {preprocessors} to the mne.io.Raw of an EEGWindowsDataset."
             )
-        _preprocess_raw_or_epochs(ds.raw, preprocessors)
+        processed = _preprocess_raw_or_epochs(ds.raw, preprocessors)
+        if processed is not ds.raw:
+            ds.raw = processed
     elif hasattr(ds, "windows"):
-        _preprocess_raw_or_epochs(ds.windows, preprocessors)
+        processed = _preprocess_raw_or_epochs(ds.windows, preprocessors)
+        if processed is not ds.windows:
+            ds.windows = processed
     else:
         raise ValueError(
-            "Can only preprocess concatenation of BaseDataset or "
-            "WindowsDataset, with either a `raw` or `windows` attribute."
+            "Can only preprocess concatenation of RecordDataset, "
+            "with either a `raw` or `windows` attribute."
         )
 
     # Store preprocessing keyword arguments in the dataset
@@ -297,11 +307,11 @@ def _get_preproc_kwargs(preprocessors):
 
 
 def _set_preproc_kwargs(ds, preprocessors):
-    """Record preprocessing keyword arguments in BaseDataset or WindowsDataset.
+    """Record preprocessing keyword arguments in RecordDataset.
 
     Parameters
     ----------
-    ds : BaseDataset | WindowsDataset
+    ds : RecordDataset
         Dataset in which to record preprocessing keyword arguments.
     preprocessors : list
         List of preprocessors.
@@ -309,12 +319,12 @@ def _set_preproc_kwargs(ds, preprocessors):
     preproc_kwargs = _get_preproc_kwargs(preprocessors)
     if isinstance(ds, WindowsDataset):
         kind = "window"
-    if isinstance(ds, EEGWindowsDataset):
+    elif isinstance(ds, EEGWindowsDataset):
         kind = "raw"
-    elif isinstance(ds, BaseDataset):
+    elif isinstance(ds, RawDataset):
         kind = "raw"
     else:
-        raise TypeError(f"ds must be a BaseDataset or a WindowsDataset, got {type(ds)}")
+        raise TypeError(f"ds must be a RecordDataset, got {type(ds)}")
     setattr(ds, kind + "_preproc_kwargs", preproc_kwargs)
 
 

braindecode/preprocessing/util.py

@@ -0,0 +1,166 @@
+"""Utilities for preprocessing functionality in Braindecode."""
+
+# Authors: Christian Kothe <christian.kothe@intheon.io>
+#
+# License: BSD-3
+
+import base64
+import json
+import re
+from typing import Any
+
+import numpy as np
+from mne.io.base import BaseRaw
+
+__all__ = ["mne_store_metadata", "mne_load_metadata"]
+
+
+# Use a unique marker for embedding structured data in info['description']
+_MARKER_PATTERN = re.compile(r"<!-- braindecode-meta:\s*(\S+)\s*-->", re.DOTALL)
+_MARKER_START = "<!-- braindecode-meta:"
+_MARKER_END = "-->"
+
+# Marker key for numpy arrays
+_NP_ARRAY_TAG = "__numpy_array__"
+
+
+def _numpy_decoder(dct):
+    """Internal JSON decoder hook to handle numpy arrays."""
+    if dct.get(_NP_ARRAY_TAG):
+        arr = np.array(dct["data"], dtype=dct["dtype"])
+        return arr.reshape(dct["shape"])
+    return dct
+
+
+class NumpyEncoder(json.JSONEncoder):
+    """Custom JSON encoder hook to handle numpy arrays."""
+
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            # Reject complex-valued dtypes as they're not JSON serializable
+            if np.issubdtype(obj.dtype, np.complexfloating):
+                raise TypeError(
+                    f"Cannot serialize numpy array with complex dtype {obj.dtype}. "
+                    "Complex dtypes are not supported."
+                )
+            return {
+                _NP_ARRAY_TAG: True,
+                "dtype": obj.dtype.str,
+                "shape": obj.shape,
+                "data": obj.flatten().tolist(),
+            }
+        return super().default(obj)
+
+
+def _encode_payload(data: dict) -> str:
+    """Serializes, encodes, and formats data into a marker string."""
+    json_str = json.dumps(data, cls=NumpyEncoder)
+    encoded = base64.b64encode(json_str.encode("utf-8")).decode("ascii")
+    return f"{_MARKER_START} {encoded} {_MARKER_END}"
+
+
+def mne_store_metadata(
+    raw: BaseRaw, payload: Any, *, key: str, no_overwrite: bool = False
+) -> None:
+    """Embed a JSON-serializable metadata payload in an MNE BaseRaw dataset
+    under a specified key.
+
+    This will encode the payload as a base64-encoded JSON string and store it
+    in the `info['description']` field of the Raw object while preserving any
+    existing content. Note this is not particularly efficient and should not
+    be used for very large payloads.
+
+    Parameters
+    ----------
+    raw : BaseRaw
+        The MNE Raw object to store data in.
+    payload : Any
+        The JSON-serializable data to store.
+    key : str
+        The key under which to store the payload.
+    no_overwrite : bool
+        If True, will not overwrite an existing entry with the same key.
+
+    """
+    # the description is apparently the only viable place where custom metadata may be
+    # stored in MNE Raw objects that persists through saving/loading
+    description = raw.info.get("description") or ""
+
+    # Try to find existing eegprep data
+    if match := _MARKER_PATTERN.search(description):
+        # Parse existing data
+        try:
+            decoded = base64.b64decode(match.group(1)).decode("utf-8")
+            existing_data = json.loads(decoded, object_hook=_numpy_decoder)
+        except (ValueError, json.JSONDecodeError):
+            existing_data = {}
+        # Check no_overwrite condition
+        if no_overwrite and key in existing_data:
+            return
+        # Update data
+        existing_data[key] = payload
+        new_marker = _encode_payload(existing_data)
+        # Replace the old marker with updated one
+        new_description = _MARKER_PATTERN.sub(new_marker, description, count=1)
+    else:
+        # No existing data, append new marker
+        data = {key: payload}
+        new_marker = _encode_payload(data)
+        # Append with spacing if description exists
+        if description.strip():
+            new_description = f"{description.rstrip()}\n{new_marker}"
+        else:
+            new_description = new_marker
+
+    raw.info["description"] = new_description
+
+
+def mne_load_metadata(raw: BaseRaw, *, key: str, delete: bool = False) -> Any | None:
+    """Retrieves data that was previously stored using mne_store_metadata from an MNE
+    BaseRaw dataset.
+
+    This function can retrieve data from an MNE Raw object that was stored
+    using `mne_store_metadata`. It decodes the base64-encoded JSON string from the
+    `info['description']` field and extracts the payload associated with the
+    specified key.
+
+    Parameters
+    ----------
+    raw : BaseRaw
+        The MNE Raw object to retrieve data from.
+    key : str
+        The key under which the payload was stored.
+    delete : bool
+        If True, removes the key from the stored data after retrieval.
+
+    Returns
+    -------
+    Any | None
+        The retrieved payload, or None if not found.
+    """
+    description = raw.info.get("description") or ""
+    match = _MARKER_PATTERN.search(description)
+    if not match:
+        return None
+
+    try:
+        decoded = base64.b64decode(match.group(1)).decode("utf-8")
+        data = json.loads(decoded, object_hook=_numpy_decoder)
+    except (ValueError, json.JSONDecodeError):
+        return None
+
+    result = data.get(key)
+
+    if delete and key in data:
+        # Remove the key from data
+        del data[key]
+        if data:
+            # Still have other keys, update the marker
+            new_marker = _encode_payload(data)
+            new_description = _MARKER_PATTERN.sub(new_marker, description, count=1)
+        else:
+            # No more keys, remove the entire marker
+            new_description = _MARKER_PATTERN.sub("", description, count=1).rstrip()
+        raw.info["description"] = new_description
+
+    return result

braindecode/preprocessing/windowers.py

@@ -11,6 +11,7 @@
 #          Maciej Sliwowski <maciek.sliwowski@gmail.com>
 #          Mohammed Fattouh <mo.fattouh@gmail.com>
 #          Robin Schirrmeister <robintibor@gmail.com>
+#          Matthew Chen <matt.chen42601@gmail.com>
 #
 # License: BSD (3-clause)
 
@@ -25,7 +26,12 @@ import pandas as pd
 from joblib import Parallel, delayed
 from numpy.typing import ArrayLike
 
-from ..datasets.base import BaseConcatDataset, EEGWindowsDataset, WindowsDataset
+from ..datasets.base import (
+    BaseConcatDataset,
+    EEGWindowsDataset,
+    RawDataset,
+    WindowsDataset,
+)
 
 
 class _LazyDataFrame:
@@ -189,7 +195,7 @@ def _get_use_mne_epochs(use_mne_epochs, reject, picks, flat, drop_bad_windows):
 
 # XXX it's called concat_ds...
 def create_windows_from_events(
-    concat_ds: BaseConcatDataset,
+    concat_ds: BaseConcatDataset[RawDataset],
     trial_start_offset_samples: int = 0,
     trial_stop_offset_samples: int = 0,
     window_size_samples: int | None = None,
@@ -206,7 +212,7 @@ def create_windows_from_events(
     use_mne_epochs: bool | None = None,
     n_jobs: int = 1,
     verbose: bool | str | int | None = "error",
-):
+) -> BaseConcatDataset[WindowsDataset | EEGWindowsDataset]:
     """Create windows based on events in mne.Raw.
 
     This function extracts windows of size window_size_samples in the interval
@@ -228,7 +234,7 @@ def create_windows_from_events(
 
     Parameters
     ----------
-    concat_ds: BaseConcatDataset
+    concat_ds: BaseConcatDataset[RawDataset]
         A concat of base datasets each holding raw and description.
     trial_start_offset_samples: int
         Start offset from original trial onsets, in samples. Defaults to zero.
@@ -268,7 +274,7 @@ def create_windows_from_events(
         rejection based on flatness is done. See mne.Epochs.
     on_missing: str
         What to do if one or several event ids are not found in the recording.
-        Valid keys are ‘error’ | ‘warning’ | ‘ignore’. See mne.Epochs.
+        Valid keys are ‘error' | ‘warning' | ‘ignore'. See mne.Epochs.
     accepted_bads_ratio: float, optional
         Acceptable proportion of trials with inconsistent length in a raw. If
         the number of trials whose length is exceeded by the window size is
@@ -286,7 +292,7 @@ def create_windows_from_events(
 
     Returns
     -------
-    windows_datasets: BaseConcatDataset
+    windows_datasets: BaseConcatDataset[WindowsDataset | EEGWindowsDataset]
         Concatenated datasets of WindowsDataset containing the extracted windows.
     """
     _check_windowing_arguments(
@@ -341,7 +347,7 @@ def create_windows_from_events(
 
 
 def create_fixed_length_windows(
-    concat_ds: BaseConcatDataset,
+    concat_ds: BaseConcatDataset[RawDataset],
     start_offset_samples: int = 0,
     stop_offset_samples: int | None = None,
     window_size_samples: int | None = None,
@@ -358,12 +364,12 @@ def create_fixed_length_windows(
     on_missing: str = "error",
     n_jobs: int = 1,
     verbose: bool | str | int | None = "error",
-):
+) -> BaseConcatDataset[EEGWindowsDataset]:
     """Windower that creates sliding windows.
 
     Parameters
     ----------
-    concat_ds: ConcatDataset
+    concat_ds: ConcatDataset[RawDataset]
         A concat of base datasets each holding raw and description.
     start_offset_samples: int
         Start offset from beginning of recording in samples.
@@ -398,7 +404,7 @@ def create_fixed_length_windows(
         by using the _LazyDataFrame (experimental).
     on_missing: str
         What to do if one or several event ids are not found in the recording.
-        Valid keys are ‘error’ | ‘warning’ | ‘ignore’. See mne.Epochs.
+        Valid keys are ‘error' | ‘warning' | ‘ignore'. See mne.Epochs.
     n_jobs: int
         Number of jobs to use to parallelize the windowing.
     verbose: bool | str | int | None
@@ -406,7 +412,7 @@ def create_fixed_length_windows(
 
     Returns
     -------
-    windows_datasets: BaseConcatDataset
+    windows_datasets: BaseConcatDataset[EEGWindowsDataset]
         Concatenated datasets of WindowsDataset containing the extracted windows.
     """
     stop_offset_samples, drop_last_window = (
@@ -473,11 +479,11 @@ def _create_windows_from_events(
     verbose="error",
     use_mne_epochs=False,
 ):
-    """Create WindowsDataset from BaseDataset based on events.
+    """Create WindowsDataset from RawDataset based on events.
 
     Parameters
     ----------
-    ds : BaseDataset
+    ds : RawDataset
         Dataset containing continuous data and description.
     infer_mapping : bool
         If True, extract all events from all datasets and map them to
@@ -509,7 +515,7 @@ def _create_windows_from_events(
             }
         )
 
-    events, events_id = mne.events_from_annotations(ds.raw, mapping)
+    events, events_id = mne.events_from_annotations(ds.raw, mapping, verbose=verbose)
     onsets = events[:, 0]
     # Onsets are relative to the beginning of the recording
     filtered_durations = np.array(
@@ -648,11 +654,11 @@ def _create_fixed_length_windows(
     on_missing="error",
     verbose="error",
 ):
-    """Create WindowsDataset from BaseDataset with sliding windows.
+    """Create WindowsDataset from RawDataset with sliding windows.
 
     Parameters
     ----------
-    ds : BaseDataset
+    ds : RawDataset
         Dataset containing continuous data and description.
 
     See `create_fixed_length_windows` for description of other parameters.
@@ -750,7 +756,7 @@ def _create_fixed_length_windows(
 
 
 def create_windows_from_target_channels(
-    concat_ds,
+    concat_ds: BaseConcatDataset[RawDataset],
     window_size_samples=None,
     preload=False,
     picks=None,
@@ -759,7 +765,7 @@ def create_windows_from_target_channels(
     n_jobs=1,
     last_target_only=True,
     verbose="error",
-):
+) -> BaseConcatDataset[EEGWindowsDataset]:
     list_of_windows_ds = Parallel(n_jobs=n_jobs)(
         delayed(_create_windows_from_target_channels)(
             ds,
@@ -788,11 +794,11 @@ def _create_windows_from_target_channels(
     on_missing="error",
     verbose="error",
 ):
-    """Create WindowsDataset from BaseDataset using targets `misc` channels from mne.Raw.
+    """Create WindowsDataset from RawDataset using targets `misc` channels from mne.Raw.
 
     Parameters
     ----------
-    ds : BaseDataset
+    ds : RawDataset
         Dataset containing continuous data and description.
 
     See `create_fixed_length_windows` for description of other parameters.