braindecode 1.3.0.dev177069446__py3-none-any.whl

braindecode/datasets/bids/hub_io.py

@@ -0,0 +1,197 @@
+# mypy: ignore-errors
+"""
+Low-level Zarr I/O helpers for Hub integration.
+
+These functions keep the Zarr serialization details isolated from hub.py.
+"""
+
+from __future__ import annotations
+
+import json
+import warnings
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from mne.utils import _soft_import
+
+zarr = _soft_import("zarr", purpose="hugging face integration", strict=False)
+
+
+def _sanitize_for_json(obj):
+    """Replace NaN/Inf with None for valid JSON."""
+    if isinstance(obj, float):
+        if np.isnan(obj) or np.isinf(obj):
+            return None
+        return obj
+    if isinstance(obj, dict):
+        return {k: _sanitize_for_json(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_sanitize_for_json(v) for v in obj]
+    if isinstance(obj, np.ndarray):
+        return _sanitize_for_json(obj.tolist())
+    return obj
+
+
+def _restore_nan_from_json(obj):
+    """Restore NaN values from None in JSON-loaded data."""
+    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(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
+
+
+def _save_windows_to_zarr(
+    grp, data, metadata, description, info, compressor, target_name
+):
+    """Save windowed data to Zarr group (low-level function)."""
+    data_array = data.astype(np.float32)
+    compressors_list = [compressor] if compressor is not None else None
+
+    grp.create_array(
+        "data",
+        data=data_array,
+        chunks=(1, data_array.shape[1], data_array.shape[2]),
+        compressors=compressors_list,
+    )
+
+    store_path = getattr(grp.store, "path", getattr(grp.store, "root", None))
+    metadata_path = Path(store_path) / grp.path / "metadata.tsv"
+    metadata.to_csv(metadata_path, sep="\t", index=True)
+
+    grp.attrs["description"] = json.loads(description.to_json(date_format="iso"))
+    grp.attrs["info"] = _sanitize_for_json(info)
+
+    if target_name is not None:
+        grp.attrs["target_name"] = target_name
+
+
+def _save_eegwindows_to_zarr(
+    grp, raw, metadata, description, info, targets_from, last_target_only, compressor
+):
+    """Save EEG continuous raw data to Zarr group (low-level function)."""
+    continuous_data = raw.get_data()
+    continuous_float = continuous_data.astype(np.float32)
+    compressors_list = [compressor] if compressor is not None else None
+
+    grp.create_array(
+        "data",
+        data=continuous_float,
+        chunks=(continuous_float.shape[0], min(10000, continuous_float.shape[1])),
+        compressors=compressors_list,
+    )
+
+    store_path = getattr(grp.store, "path", getattr(grp.store, "root", None))
+    metadata_path = Path(store_path) / grp.path / "metadata.tsv"
+    metadata.to_csv(metadata_path, sep="\t", index=True)
+
+    grp.attrs["description"] = json.loads(description.to_json(date_format="iso"))
+    grp.attrs["info"] = _sanitize_for_json(info)
+    grp.attrs["targets_from"] = targets_from
+    grp.attrs["last_target_only"] = last_target_only
+
+
+def _load_windows_from_zarr(grp, preload):
+    """Load windowed data from Zarr group (low-level function)."""
+    store_path = getattr(grp.store, "path", getattr(grp.store, "root", None))
+    metadata_path = Path(store_path) / grp.path / "metadata.tsv"
+    metadata = pd.read_csv(metadata_path, sep="\t", index_col=0)
+
+    description = pd.Series(grp.attrs["description"])
+    info_dict = _restore_nan_from_json(grp.attrs["info"])
+
+    if preload:
+        data = grp["data"][:]
+    else:
+        data = grp["data"][:]
+        warnings.warn(
+            "Lazy loading from Zarr not fully implemented yet. "
+            "Loading all data into memory.",
+            UserWarning,
+        )
+
+    target_name = grp.attrs.get("target_name", None)
+
+    return data, metadata, description, info_dict, target_name
+
+
+def _load_eegwindows_from_zarr(grp, preload):
+    """Load EEG continuous raw data from Zarr group (low-level function)."""
+    store_path = getattr(grp.store, "path", getattr(grp.store, "root", None))
+    metadata_path = Path(store_path) / grp.path / "metadata.tsv"
+    metadata = pd.read_csv(metadata_path, sep="\t", index_col=0)
+
+    description = pd.Series(grp.attrs["description"])
+    info_dict = _restore_nan_from_json(grp.attrs["info"])
+
+    if preload:
+        data = grp["data"][:]
+    else:
+        data = grp["data"][:]
+        warnings.warn(
+            "Lazy loading from Zarr not fully implemented yet. "
+            "Loading all data into memory.",
+            UserWarning,
+        )
+
+    targets_from = grp.attrs.get("targets_from", "metadata")
+    last_target_only = grp.attrs.get("last_target_only", True)
+
+    return data, metadata, description, info_dict, targets_from, last_target_only
+
+
+def _save_raw_to_zarr(grp, raw, description, info, target_name, compressor):
+    """Save RawDataset continuous raw data to Zarr group (low-level function)."""
+    continuous_data = raw.get_data()
+    continuous_float = continuous_data.astype(np.float32)
+    compressors_list = [compressor] if compressor is not None else None
+
+    grp.create_array(
+        "data",
+        data=continuous_float,
+        chunks=(continuous_float.shape[0], min(10000, continuous_float.shape[1])),
+        compressors=compressors_list,
+    )
+
+    grp.attrs["description"] = json.loads(description.to_json(date_format="iso"))
+    grp.attrs["info"] = _sanitize_for_json(info)
+
+    if target_name is not None:
+        grp.attrs["target_name"] = target_name
+
+
+def _load_raw_from_zarr(grp, preload):
+    """Load RawDataset continuous raw data from Zarr group (low-level function)."""
+    description = pd.Series(grp.attrs["description"])
+    info_dict = _restore_nan_from_json(grp.attrs["info"])
+
+    if preload:
+        data = grp["data"][:]
+    else:
+        data = grp["data"][:]
+        warnings.warn(
+            "Lazy loading from Zarr not fully implemented yet. "
+            "Loading all data into memory.",
+            UserWarning,
+        )
+
+    target_name = grp.attrs.get("target_name", None)
+
+    return data, description, info_dict, target_name
+
+
+def _create_compressor(compression, compression_level):
+    """Create a Zarr v3 compressor codec."""
+    if zarr is False:
+        raise ImportError(
+            "Zarr is not installed. Install with: pip install braindecode[hub]"
+        )
+
+    if compression is None or compression not in ("blosc", "zstd", "gzip"):
+        return None
+
+    name = "zstd" if compression == "blosc" else compression
+    return {"name": name, "configuration": {"level": compression_level}}

braindecode/datasets/bids/hub_validation.py

@@ -0,0 +1,114 @@
+# mypy: ignore-errors
+"""
+Shared validation utilities for Hub format operations.
+
+This module provides validation functions used by hub.py to avoid code duplication.
+"""
+
+# Authors: Kuntal Kokate
+#
+# License: BSD (3-clause)
+
+from typing import Any, List, Tuple
+
+from ..registry import get_dataset_type
+
+
+def validate_dataset_uniformity(
+    datasets: List[Any],
+) -> Tuple[str, List[str], float]:
+    """
+    Validate all datasets have uniform type, channels, and sampling frequency.
+
+    Parameters
+    ----------
+    datasets : list
+        List of dataset objects to validate.
+
+    Returns
+    -------
+    dataset_type : str
+        The validated dataset type (WindowsDataset, EEGWindowsDataset, or RawDataset).
+    first_ch_names : list of str
+        Channel names from the first dataset.
+    first_sfreq : float
+        Sampling frequency from the first dataset.
+
+    Raises
+    ------
+    ValueError
+        If datasets have mixed types, inconsistent channels, or inconsistent
+        sampling frequencies.
+    TypeError
+        If dataset type is not supported.
+    """
+    if not datasets:
+        raise ValueError("No datasets provided for validation.")
+
+    first_ds = datasets[0]
+    dataset_type = get_dataset_type(first_ds)
+
+    # Get reference channel names and sampling frequency from the first dataset
+    first_ch_names, first_sfreq = _get_ch_names_and_sfreq(first_ds, dataset_type)
+
+    # Validate all datasets have uniform properties
+    for i, ds in enumerate(datasets):
+        ds_type = get_dataset_type(ds)
+        if ds_type != dataset_type:
+            raise ValueError(
+                f"Mixed dataset types in concat: dataset 0 is {dataset_type} "
+                f"but dataset {i} is {ds_type}"
+            )
+
+        ch_names, sfreq = _get_ch_names_and_sfreq(ds, dataset_type)
+
+        if ch_names != first_ch_names:
+            raise ValueError(
+                f"Inconsistent channel names: dataset 0 has {first_ch_names} "
+                f"but dataset {i} has {ch_names}"
+            )
+
+        if sfreq != first_sfreq:
+            _raise_sfreq_error(first_sfreq, sfreq, i)
+
+    return dataset_type, first_ch_names, first_sfreq
+
+
+def _get_ch_names_and_sfreq(ds: Any, dataset_type: str) -> Tuple[List[str], float]:
+    """Return (ch_names, sfreq) for supported dataset types."""
+    if dataset_type == "WindowsDataset":
+        obj = ds.windows
+    elif dataset_type in ("EEGWindowsDataset", "RawDataset"):
+        obj = ds.raw
+    else:
+        raise TypeError(f"Unsupported dataset type: {dataset_type}")
+
+    return obj.ch_names, obj.info["sfreq"]
+
+
+def _raise_sfreq_error(expected: float, actual: float, idx: int):
+    """
+    Raise standardized sampling frequency error.
+
+    Parameters
+    ----------
+    expected : float
+        Expected sampling frequency from dataset 0.
+    actual : float
+        Actual sampling frequency from current dataset.
+    idx : int
+        Index of the dataset with inconsistent sampling frequency.
+
+    Raises
+    ------
+    ValueError
+        Always raised with standardized error message.
+    """
+    raise ValueError(
+        f"Inconsistent sampling frequencies: dataset 0 has {expected} Hz "
+        f"but dataset {idx} has {actual} Hz. "
+        f"Please resample all datasets to a common frequency before saving. "
+        f"Use braindecode.preprocessing.preprocess("
+        f"[Preprocessor(Resample(sfreq={expected}))], concat_ds) "
+        f"to resample your datasets."
+    )

braindecode/datasets/bids/iterable.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import random
+from pathlib import Path
+from typing import Callable, Sequence
+
+import mne_bids
+from torch.utils.data import IterableDataset, get_worker_info
+
+
+class BIDSIterableDataset(IterableDataset):
+    """Dataset for loading BIDS.
+
+    .. warning::
+        This class is experimental and may change in the future.
+
+    .. warning::
+        This dataset is not consistent with the Braindecode API.
+
+    This class has the same parameters as the :func:`mne_bids.find_matching_paths` function
+    as it will be used to find the files to load. The default ``extensions`` parameter was changed.
+
+    More information on BIDS (Brain Imaging Data Structure)
+    can be found at https://bids.neuroimaging.io
+
+    Examples
+    --------
+    >>> from braindecode.datasets import BaseConcatDataset, RawDataset, RecordDataset
+    >>> from braindecode.datasets.bids import BIDSIterableDataset
+    >>> from braindecode.preprocessing import create_fixed_length_windows
+    >>>
+    >>> def my_reader_fn(path):
+    ...     raw = mne_bids.read_raw_bids(path)
+    ...     ds: RecordDataset = RawDataset(raw, description={"path": path.fpath})
+    ...     windows_ds = create_fixed_length_windows(
+    ...         BaseConcatDataset([ds]),
+    ...         window_size_samples=400,
+    ...         window_stride_samples=200,
+    ...     )
+    ...     return windows_ds
+    >>>
+    >>> dataset = BIDSIterableDataset(
+    ...     reader_fn=my_reader_fn,
+    ...     root="root/of/my/bids/dataset/",
+    ... )
+
+    Parameters
+    ----------
+    reader_fn : Callable[[mne_bids.BIDSPath], Sequence]
+        A function that takes a BIDSPath and returns a dataset (e.g., a
+        RecordDataset or BaseConcatDataset of RecordDataset).
+    pool_size : int
+        The number of recordings to read and sample from.
+    bids_paths : list[mne_bids.BIDSPath] | None
+        A list of BIDSPaths to load. If None, will use the paths found by
+        :func:`mne_bids.find_matching_paths` and the arguments below.
+    root : pathlib.Path | str
+        The root of the BIDS path.
+    subjects : str | array-like of str | None
+        The subject ID. Corresponds to "sub".
+    sessions : str | array-like of str | None
+        The acquisition session. Corresponds to "ses".
+    tasks : str | array-like of str | None
+        The experimental task. Corresponds to "task".
+    acquisitions : str | array-like of str | None
+        The acquisition parameters. Corresponds to "acq".
+    runs : str | array-like of str | None
+        The run number. Corresponds to "run".
+    processings : str | array-like of str | None
+        The processing label. Corresponds to "proc".
+    recordings : str | array-like of str | None
+        The recording name. Corresponds to "rec".
+    spaces : str | array-like of str | None
+        The coordinate space for anatomical and sensor location
+        files (e.g., ``*_electrodes.tsv``, ``*_markers.mrk``).
+        Corresponds to "space".
+        Note that valid values for ``space`` must come from a list
+        of BIDS keywords as described in the BIDS specification.
+    splits : str | array-like of str | None
+        The split of the continuous recording file for ``.fif`` data.
+        Corresponds to "split".
+    descriptions : str | array-like of str | None
+        This corresponds to the BIDS entity ``desc``. It is used to provide
+        additional information for derivative data, e.g., preprocessed data
+        may be assigned ``description='cleaned'``.
+    suffixes : str | array-like of str | None
+        The filename suffix. This is the entity after the
+        last ``_`` before the extension. E.g., ``'channels'``.
+        The following filename suffix's are accepted:
+        'meg', 'markers', 'eeg', 'ieeg', 'T1w',
+        'participants', 'scans', 'electrodes', 'coordsystem',
+        'channels', 'events', 'headshape', 'digitizer',
+        'beh', 'physio', 'stim'
+    extensions : str | array-like of str | None
+        The extension of the filename. E.g., ``'.json'``.
+        By default, uses the ones accepted by :func:`mne_bids.read_raw_bids`.
+    datatypes : str | array-like of str | None
+        The BIDS data type, e.g., ``'anat'``, ``'func'``, ``'eeg'``, ``'meg'``,
+        ``'ieeg'``.
+    check : bool
+        If ``True``, only returns paths that conform to BIDS. If ``False``
+        (default), the ``.check`` attribute of the returned
+        :class:`mne_bids.BIDSPath` object will be set to ``True`` for paths that
+        do conform to BIDS, and to ``False`` for those that don't.
+    preload : bool
+        If True, preload the data. Defaults to False.
+    n_jobs : int
+        Number of jobs to run in parallel. Defaults to 1.
+
+
+    """
+
+    def __init__(
+        self,
+        reader_fn: Callable[[mne_bids.BIDSPath], Sequence],
+        pool_size: int = 4,
+        bids_paths: list[mne_bids.BIDSPath] | None = None,
+        root: Path | str | None = None,
+        subjects: str | list[str] | None = None,
+        sessions: str | list[str] | None = None,
+        tasks: str | list[str] | None = None,
+        acquisitions: str | list[str] | None = None,
+        runs: str | list[str] | None = None,
+        processings: str | list[str] | None = None,
+        recordings: str | list[str] | None = None,
+        spaces: str | list[str] | None = None,
+        splits: str | list[str] | None = None,
+        descriptions: str | list[str] | None = None,
+        suffixes: str | list[str] | None = None,
+        extensions: str | list[str] | None = [
+            ".con",
+            ".sqd",
+            ".pdf",
+            ".fif",
+            ".ds",
+            ".vhdr",
+            ".set",
+            ".edf",
+            ".bdf",
+            ".EDF",
+            ".snirf",
+            ".cdt",
+            ".mef",
+            ".nwb",
+        ],
+        datatypes: str | list[str] | None = None,
+        check: bool = False,
+    ):
+        if bids_paths is None:
+            bids_paths = mne_bids.find_matching_paths(
+                root=root,
+                subjects=subjects,
+                sessions=sessions,
+                tasks=tasks,
+                acquisitions=acquisitions,
+                runs=runs,
+                processings=processings,
+                recordings=recordings,
+                spaces=spaces,
+                splits=splits,
+                descriptions=descriptions,
+                suffixes=suffixes,
+                extensions=extensions,
+                datatypes=datatypes,
+                check=check,
+                ignore_json=True,
+            )
+            # Filter out _epo.fif files:
+            bids_paths = [
+                bids_path
+                for bids_path in bids_paths
+                if not (bids_path.suffix == "epo" and bids_path.extension == ".fif")
+            ]
+        self.bids_paths = bids_paths
+        self.reader_fn = reader_fn
+        self.pool_size = pool_size
+
+    def __add__(self, other):
+        assert isinstance(other, BIDSIterableDataset)
+        return BIDSIterableDataset(
+            reader_fn=self.reader_fn,
+            bids_paths=self.bids_paths + other.bids_paths,
+            pool_size=self.pool_size,
+        )
+
+    def __iadd__(self, other):
+        assert isinstance(other, BIDSIterableDataset)
+        self.bids_paths += other.bids_paths
+        return self
+
+    def __iter__(self):
+        worker_info = get_worker_info()
+        if worker_info is None:  # single-process data loading, return the full iterator
+            bids_paths = self.bids_paths
+        else:  # in a worker process
+            # split workload
+            bids_paths = self.bids_paths[worker_info.id :: worker_info.num_workers]
+
+        pool = []
+        end = False
+        paths_it = iter(random.sample(bids_paths, k=len(bids_paths)))
+        while not (end and len(pool) == 0):
+            while not end and len(pool) < self.pool_size:
+                try:
+                    bids_path = next(paths_it)
+                    ds = self.reader_fn(bids_path)
+                    if ds is None:
+                        print(f"Skipping {bids_path} as it is too short.")
+                        continue
+                    idx = iter(random.sample(range(len(ds)), k=len(ds)))
+                    pool.append((ds, idx))
+                except StopIteration:
+                    end = True
+            i_pool = random.randint(0, len(pool) - 1)
+            ds, idx = pool[i_pool]
+            try:
+                i_ds = next(idx)
+                yield ds[i_ds]
+            except StopIteration:
+                pool.pop(i_pool)

braindecode/datasets/chb_mit.py

@@ -0,0 +1,163 @@
+"""
+This dataset is a BIDS-compatible version of the CHB-MIT Scalp EEG Database.
+
+It reorganizes the file structure to comply with the BIDS specification. To this effect:
+
+    The data from subject chb21 was moved to sub-01/ses-02.
+    Metadata was organized according to BIDS.
+    Data in the EEG edf files was modified to keep only the 18 channels from a double banana bipolar montage.
+    Annotations were formatted as BIDS-score compatible `tsv` files.
+"""
+
+# Authors: Dan, Jonathan
+#          Shoeb, Ali (Data collector)
+#          Bruno Aristimunha <b.aristimunha@gmail.com>
+#
+# License: BSD (3-clause)
+from __future__ import annotations
+
+from pathlib import Path
+
+from mne.datasets import fetch_dataset
+
+from braindecode.datasets import BIDSDataset
+from braindecode.datasets.utils import _correct_dataset_path
+
+CHB_MIT_URL = "https://zenodo.org/records/10259996/files/BIDS_CHB-MIT.zip"
+CHB_MIT_archive_name = "chb_mit_bids.zip"
+CHB_MIT_folder_name = "CHB-MIT-BIDS-eeg-dataset"
+CHB_MIT_dataset_name = "CHB-MIT-EEG-Corpus"
+
+CHB_MIT_dataset_params = {
+    "dataset_name": CHB_MIT_dataset_name,
+    "url": CHB_MIT_URL,
+    "archive_name": CHB_MIT_archive_name,
+    "folder_name": CHB_MIT_folder_name,
+    "hash": "078f4e110e40d10fef1a38a892571ad24666c488e8118a01002c9224909256ed",  # sha256
+    "config_key": CHB_MIT_dataset_name,
+}
+
+
+class CHBMIT(BIDSDataset):
+    """The Children's Hospital Boston EEG Dataset.
+
+    This database, collected at the Children's Hospital Boston, consists of EEG recordings
+    from pediatric subjects with intractable seizures. Subjects were monitored for up to
+    several days following withdrawal of anti-seizure medication in order to characterize
+    their seizures and assess their candidacy for surgical intervention.
+
+    **Description of the contents of the dataset:**
+
+    Each folder (sub-01, sub-01, etc.) contains between 9 and 42 continuous .edf
+    files from a single subject. Hardware limitations resulted in gaps between
+    consecutively-numbered .edf files, during which the signals were not recorded;
+    in most cases, the gaps are 10 seconds or less, but occasionally there are much
+    longer gaps. In order to protect the privacy of the subjects, all protected health
+    information (PHI) in the original .edf files has been replaced with surrogate information
+    in the files provided here. Dates in the original .edf files have been replaced by
+    surrogate dates, but the time relationships between the individual files belonging
+    to each case have been preserved. In most cases, the .edf files contain exactly one
+    hour of digitized EEG signals, although those belonging to case sub-10 are two hours
+    long, and those belonging to cases sub-04, sub-06, sub-07, sub-09, and sub-23 are
+    four hours long; occasionally, files in which seizures are recorded are shorter.
+
+    The EEG is recorded at 256 Hz with a 16-bit resolution. The recordings are
+    referenced in a double banana bipolar montage with 18 channels from the 10-20 electrode system.
+
+    This BIDS-compatible version of the dataset was published by Jonathan Dan :footcite:`Dan2025`
+    and is based on the original CHB MIT EEG Database :footcite:`Guttag2010`, :footcite:`Shoeb2009`.
+
+    .. versionadded:: 1.3
+
+    Parameters
+    ----------
+    root : pathlib.Path | str
+        The root of the BIDS path.
+    subjects : str | array-like of str | None
+        The subject ID. Corresponds to "sub".
+    sessions : str | array-like of str | None
+        The acquisition session. Corresponds to "ses".
+    tasks : str | array-like of str | None
+        The experimental task. Corresponds to "task".
+    acquisitions : str | array-like of str | None
+        The acquisition parameters. Corresponds to "acq".
+    runs : str | array-like of str | None
+        The run number. Corresponds to "run".
+    processings : str | array-like of str | None
+        The processing label. Corresponds to "proc".
+    recordings : str | array-like of str | None
+        The recording name. Corresponds to "rec".
+    spaces : str | array-like of str | None
+        The coordinate space for anatomical and sensor location
+        files (e.g., ``*_electrodes.tsv``, ``*_markers.mrk``).
+        Corresponds to "space".
+        Note that valid values for ``space`` must come from a list
+        of BIDS keywords as described in the BIDS specification.
+    splits : str | array-like of str | None
+        The split of the continuous recording file for ``.fif`` data.
+        Corresponds to "split".
+    descriptions : str | array-like of str | None
+        This corresponds to the BIDS entity ``desc``. It is used to provide
+        additional information for derivative data, e.g., preprocessed data
+        may be assigned ``description='cleaned'``.
+    suffixes : str | array-like of str | None
+        The filename suffix. This is the entity after the
+        last ``_`` before the extension. E.g., ``'channels'``.
+        The following filename suffix's are accepted:
+        'meg', 'markers', 'eeg', 'ieeg', 'T1w',
+        'participants', 'scans', 'electrodes', 'coordsystem',
+        'channels', 'events', 'headshape', 'digitizer',
+        'beh', 'physio', 'stim'
+    extensions : str | array-like of str | None
+        The extension of the filename. E.g., ``'.json'``.
+        By default, uses the ones accepted by :func:`mne_bids.read_raw_bids`.
+    datatypes : str | array-like of str | None
+        The BIDS data type, e.g., ``'anat'``, ``'func'``, ``'eeg'``, ``'meg'``,
+        ``'ieeg'``.
+    check : bool
+        If ``True``, only returns paths that conform to BIDS. If ``False``
+        (default), the ``.check`` attribute of the returned
+        :class:`mne_bids.BIDSPath` object will be set to ``True`` for paths that
+        do conform to BIDS, and to ``False`` for those that don't.
+    preload : bool
+        If True, preload the data. Defaults to False.
+    n_jobs : int
+        Number of jobs to run in parallel. Defaults to 1.
+
+    References
+    ----------
+    .. footbibliography::
+    """
+
+    def __init__(self, root=None, *args, **kwargs):
+        # Download dataset if not present
+        if root is None:
+            path_root = fetch_dataset(
+                dataset_params=CHB_MIT_dataset_params,
+                path=None,
+                processor="unzip",
+                force_update=False,
+            )
+            # First time we fetch the dataset, we need to move the files to the
+            # correct directory.
+            path_root = _correct_dataset_path(
+                path_root, CHB_MIT_archive_name, "BIDS_CHB-MIT"
+            )
+        else:
+            # Validate that the provided root is a valid BIDS dataset
+            if not Path(f"{root}/participants.tsv").exists():
+                raise ValueError(
+                    f"The provided root directory {root} does not contain a valid "
+                    "BIDS dataset (missing participants.tsv). Please ensure the "
+                    "root points directly to the BIDS dataset directory."
+                )
+            path_root = root
+
+        kwargs["root"] = path_root
+
+        super().__init__(
+            *args,
+            extensions=".edf",
+            check=False,
+            **kwargs,
+        )