braindecode 1.3.2.dev170848736__tar.gz → 1.3.2.dev173417708__tar.gz

{braindecode-1.3.2.dev170848736/braindecode.egg-info → braindecode-1.3.2.dev173417708}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.3.2.dev170848736
+Version: 1.3.2.dev173417708
 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>
@@ -84,8 +84,8 @@ Requires-Dist: braindecode[eegprep]; extra == "all"
 Requires-Dist: braindecode[typing]; extra == "all"
 Dynamic: license-file
 
-.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.8214376.svg
-    :target: https://doi.org/10.5281/zenodo.8214376
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17699192.svg
+    :target: https://doi.org/10.5281/zenodo.17699192
     :alt: DOI
 
 .. image:: https://github.com/braindecode/braindecode/workflows/docs/badge.svg
@@ -173,13 +173,43 @@ https://github.com/braindecode/braindecode/blob/master/CONTRIBUTING.md
  Citing
 ########
 
-If you use Braindecode in scientific work, please cite the software using the Zenodo DOI
-shown in the badge below:
+If you use Braindecode in scientific work, please cite the software using the global
+Zenodo DOI shown in the badge below:
 
-.. image:: https://zenodo.org/badge/232335424.svg
-    :target: https://doi.org/10.5281/zenodo.8214376
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17699192.svg
+    :target: https://doi.org/10.5281/zenodo.17699192
     :alt: DOI
 
+You can use the following BibTeX entry:
+
+.. code-block:: bibtex
+
+    @software{braindecode,
+      author = {Aristimunha, Bruno and
+                Guetschel, Pierre and
+                Wimpff, Martin and
+                Gemein, Lukas and
+                Rommel, Cedric and
+                Banville, Hubert and
+                Sliwowski, Maciej and
+                Wilson, Daniel and
+                Brandt, Simon and
+                Gnassounou, Théo and
+                Paillard, Joseph and
+                {Junqueira Lopes}, Bruna and
+                Sedlar, Sara and
+                Moreau, Thomas and
+                Chevallier, Sylvain and
+                Gramfort, Alexandre and
+                Schirrmeister, Robin Tibor},
+      title = {Braindecode: toolbox for decoding raw electrophysiological brain data
+               with deep learning models},
+      url = {https://github.com/braindecode/braindecode},
+      doi = {10.5281/zenodo.17699192},
+      publisher = {Zenodo},
+      license = {BSD-3-Clause},
+    }
+
 Additionally, we highly encourage you to cite the article that originally introduced the
 Braindecode library and has served as a foundational reference for many works on deep
 learning with EEG recordings. Please use the following reference:

{braindecode-1.3.2.dev170848736 → braindecode-1.3.2.dev173417708}/README.rst

@@ -1,5 +1,5 @@
-.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.8214376.svg
-    :target: https://doi.org/10.5281/zenodo.8214376
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17699192.svg
+    :target: https://doi.org/10.5281/zenodo.17699192
     :alt: DOI
 
 .. image:: https://github.com/braindecode/braindecode/workflows/docs/badge.svg
@@ -87,13 +87,43 @@ https://github.com/braindecode/braindecode/blob/master/CONTRIBUTING.md
  Citing
 ########
 
-If you use Braindecode in scientific work, please cite the software using the Zenodo DOI
-shown in the badge below:
+If you use Braindecode in scientific work, please cite the software using the global
+Zenodo DOI shown in the badge below:
 
-.. image:: https://zenodo.org/badge/232335424.svg
-    :target: https://doi.org/10.5281/zenodo.8214376
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17699192.svg
+    :target: https://doi.org/10.5281/zenodo.17699192
     :alt: DOI
 
+You can use the following BibTeX entry:
+
+.. code-block:: bibtex
+
+    @software{braindecode,
+      author = {Aristimunha, Bruno and
+                Guetschel, Pierre and
+                Wimpff, Martin and
+                Gemein, Lukas and
+                Rommel, Cedric and
+                Banville, Hubert and
+                Sliwowski, Maciej and
+                Wilson, Daniel and
+                Brandt, Simon and
+                Gnassounou, Théo and
+                Paillard, Joseph and
+                {Junqueira Lopes}, Bruna and
+                Sedlar, Sara and
+                Moreau, Thomas and
+                Chevallier, Sylvain and
+                Gramfort, Alexandre and
+                Schirrmeister, Robin Tibor},
+      title = {Braindecode: toolbox for decoding raw electrophysiological brain data
+               with deep learning models},
+      url = {https://github.com/braindecode/braindecode},
+      doi = {10.5281/zenodo.17699192},
+      publisher = {Zenodo},
+      license = {BSD-3-Clause},
+    }
+
 Additionally, we highly encourage you to cite the article that originally introduced the
 Braindecode library and has served as a foundational reference for many works on deep
 learning with EEG recordings. Please use the following reference:

{braindecode-1.3.2.dev170848736 → braindecode-1.3.2.dev173417708}/braindecode/datasets/base.py

@@ -11,11 +11,13 @@
 from __future__ import annotations
 
 import bisect
+import html as _html
 import json
 import os
 import shutil
 import warnings
 from abc import abstractmethod
+from collections import Counter
 from collections.abc import Callable
 from glob import glob
 from typing import Any, Generic, Iterable, no_type_check
@@ -42,6 +44,256 @@ def _create_description(description) -> pd.Series:
     return description
 
 
+def _html_row(label, value):
+    """Generate a single HTML table row."""
+    label = _html.escape(str(label))
+    value = _html.escape(str(value))
+    return f"<tr><td><b>{label}</b></td><td>{value}</td></tr>"
+
+
+_METADATA_INTERNAL_COLS = {
+    "i_window_in_trial",
+    "i_start_in_trial",
+    "i_stop_in_trial",
+    "target",
+}
+
+
+def _metadata_summary(metadata):
+    """Summarize window metadata into a dict.
+
+    Returns a dict with keys: n_windows, target_info, extra_columns,
+    window_info, is_lazy.
+    """
+    is_lazy = not isinstance(metadata, pd.DataFrame)
+
+    if is_lazy:
+        n_windows = len(metadata)
+        columns = list(metadata.columns) if hasattr(metadata, "columns") else []
+        extra_columns = [str(c) for c in columns if c not in _METADATA_INTERNAL_COLS]
+        return {
+            "n_windows": n_windows,
+            "target_info": None,
+            "extra_columns": extra_columns,
+            "window_info": None,
+            "is_lazy": True,
+        }
+
+    n_windows = len(metadata)
+    extra_columns = [
+        str(c) for c in metadata.columns if c not in _METADATA_INTERNAL_COLS
+    ]
+
+    target_info = None
+    if "target" in metadata.columns:
+        targets = metadata["target"]
+        n_unique = targets.nunique()
+        if n_unique <= 10:
+            counts = targets.value_counts().sort_index().to_dict()
+            target_info = f"{n_unique} unique ({counts})"
+        else:
+            target_info = f"{n_unique} unique targets"
+
+    window_info = None
+    if "i_start_in_trial" in metadata.columns and "i_stop_in_trial" in metadata.columns:
+        sizes = metadata["i_stop_in_trial"] - metadata["i_start_in_trial"]
+        if len(sizes) == 0:
+            pass
+        elif (min_s := int(sizes.min())) == (max_s := int(sizes.max())):
+            window_info = {"min": min_s, "max": max_s, "uniform": True}
+        else:
+            window_info = {"min": min_s, "max": max_s, "uniform": False}
+
+    return {
+        "n_windows": n_windows,
+        "target_info": target_info,
+        "extra_columns": extra_columns,
+        "window_info": window_info,
+        "is_lazy": False,
+    }
+
+
+def _concat_metadata_summary(datasets):
+    """Aggregate metadata summary across datasets without full concatenation.
+
+    Returns a dict with keys: window_info, target_info, extra_columns.
+    """
+    overall_min = None
+    overall_max = None
+    target_counts = Counter()
+    extra_cols = set()
+
+    for ds in datasets:
+        if hasattr(ds, "windows"):
+            md = ds.windows.metadata
+        elif hasattr(ds, "metadata"):
+            md = ds.metadata
+        else:
+            continue
+        if md is None or len(md) == 0:
+            continue
+
+        extra_cols.update(
+            str(c) for c in md.columns if c not in _METADATA_INTERNAL_COLS
+        )
+
+        if "i_start_in_trial" in md.columns and "i_stop_in_trial" in md.columns:
+            sizes = md["i_stop_in_trial"] - md["i_start_in_trial"]
+            if len(sizes) > 0:
+                ds_min, ds_max = int(sizes.min()), int(sizes.max())
+                overall_min = (
+                    ds_min if overall_min is None else min(overall_min, ds_min)
+                )
+                overall_max = (
+                    ds_max if overall_max is None else max(overall_max, ds_max)
+                )
+
+        if "target" in md.columns:
+            target_counts.update(md["target"].value_counts().to_dict())
+
+    window_info = None
+    if overall_min is not None:
+        window_info = {
+            "min": overall_min,
+            "max": overall_max,
+            "uniform": overall_min == overall_max,
+        }
+
+    target_info = None
+    if target_counts:
+        n_unique = len(target_counts)
+        if n_unique <= 10:
+            sorted_counts = dict(sorted(target_counts.items()))
+            target_info = f"{n_unique} unique ({sorted_counts})"
+        else:
+            target_info = f"{n_unique} unique targets"
+
+    return {
+        "window_info": window_info,
+        "target_info": target_info,
+        "extra_columns": sorted(extra_cols),
+    }
+
+
+def _channel_info(mne_obj):
+    """Extract channel summary from an mne object.
+
+    Returns (n_ch, type_str, sfreq).
+    """
+    info = mne_obj.info
+    n_ch = info["nchan"]
+    sfreq = info["sfreq"]
+    ch_types = mne_obj.get_channel_types()
+    type_counts = Counter(ch_types)
+    type_str = ", ".join(f"{cnt} {t.upper()}" for t, cnt in sorted(type_counts.items()))
+    return n_ch, type_str, sfreq
+
+
+def _window_info(crop_inds, sfreq):
+    """Extract window size from crop indices.
+
+    Returns (win_samples, win_secs) or None if crop_inds is empty.
+    """
+    if len(crop_inds) == 0:
+        return None
+    first = crop_inds[0]
+    win_samples = int(first[2] - first[1])
+    win_secs = win_samples / sfreq
+    return win_samples, win_secs
+
+
+class _ReprBuilder:
+    """Lightweight builder that renders both text and HTML from the same data."""
+
+    def __init__(self, cls_name, type_display=None):
+        self._cls_name = cls_name
+        self._type_display = type_display or cls_name
+        self._header_parts = []
+        self._header_rows = []
+        self._items = []
+
+    def add_header(self, header_text, label, value):
+        """Add to both the compact ``<ClassName | ...>`` line and an HTML row."""
+        self._header_parts.append(header_text)
+        self._header_rows.append((label, value))
+        return self
+
+    def add_row(self, label, value):
+        """Add a detail row (text: ``  label: value``, HTML: ``<tr>``)."""
+        self._items.append(("row", label, value))
+        return self
+
+    def add_footnote(self, text):
+        """Add a footnote (text: ``  (text)``, HTML: italic ``<td colspan=2>``)."""
+        self._items.append(("footnote", text, None))
+        return self
+
+    def to_repr(self):
+        if self._header_parts:
+            parts = " | ".join(self._header_parts)
+            lines = [f"<{self._cls_name} | {parts}>"]
+        else:
+            lines = [f"<{self._cls_name}>"]
+        for kind, label, value in self._items:
+            if kind == "row":
+                lines.append(f"  {label}: {value}")
+            else:
+                lines.append(f"  ({label})")
+        return "\n".join(lines)
+
+    def to_html(self):
+        rows = [_html_row("Type", self._type_display)]
+        for label, value in self._header_rows:
+            rows.append(_html_row(label, value))
+        for kind, label, value in self._items:
+            if kind == "row":
+                html_label = label[0].upper() + label[1:]
+                rows.append(_html_row(html_label, value))
+            else:
+                rows.append(
+                    f"<tr><td colspan='2'><i>{_html.escape(str(label))}</i></td></tr>"
+                )
+        table_rows = "\n".join(rows)
+        esc_name = _html.escape(str(self._cls_name))
+        return (
+            f"<table border='1' class='dataframe'>\n"
+            f"  <thead><tr><th colspan='2'>{esc_name}</th></tr></thead>\n"
+            f"  <tbody>\n{table_rows}\n  </tbody>\n</table>"
+        )
+
+
+def _build_windowed_repr(
+    cls_name, n_windows, mne_obj, crop_inds, description, metadata
+):
+    """Build repr for EEGWindowsDataset and WindowsDataset."""
+    b = _ReprBuilder(cls_name)
+    n_ch, type_str, sfreq = _channel_info(mne_obj)
+    b.add_header(f"{n_windows} windows", "Windows", n_windows)
+    b.add_header(f"{n_ch} ch ({type_str})", "Channels", f"{n_ch} ({type_str})")
+    wi = _window_info(crop_inds, sfreq)
+    if wi is not None:
+        win_samples, win_secs = wi
+        b.add_header(
+            f"{win_samples} samples/win ({win_secs:.3f} s)",
+            "Window size",
+            f"{win_samples} samples ({win_secs:.3f} s)",
+        )
+    b.add_header(f"{sfreq:.1f} Hz", "Sfreq", f"{sfreq:.1f} Hz")
+    if description is not None:
+        desc_items = ", ".join(f"{k}={v}" for k, v in description.items())
+        b.add_row("description", desc_items)
+    if metadata is not None:
+        summary = _metadata_summary(metadata)
+        if summary["is_lazy"]:
+            b.add_row("metadata", f"lazy ({summary['n_windows']} windows)")
+        else:
+            if summary["target_info"]:
+                b.add_row("targets", summary["target_info"])
+            if summary["extra_columns"]:
+                b.add_row("extra metadata", ", ".join(summary["extra_columns"]))
+    return b
+
+
 class RecordDataset(Dataset[tuple[np.ndarray, int | str, tuple[int, int, int]]]):
     def __init__(
         self,
@@ -94,6 +346,15 @@ class RecordDataset(Dataset[tuple[np.ndarray, int | str, tuple[int, int, int]]])
             raise ValueError("Transform needs to be a callable.")
         self._transform = value
 
+    def _build_repr(self):
+        return _ReprBuilder(type(self).__name__)
+
+    def __repr__(self):
+        return self._build_repr().to_repr()
+
+    def _repr_html_(self):
+        return self._build_repr().to_html()
+
 
 # Type of the datasets contained in BaseConcatDataset
 T = TypeVar("T", bound=RecordDataset)
@@ -148,6 +409,23 @@ class RawDataset(RecordDataset):
     def __len__(self):
         return len(self.raw)
 
+    def _build_repr(self):
+        b = _ReprBuilder(type(self).__name__)
+        n_ch, type_str, sfreq = _channel_info(self.raw)
+        n_times = len(self.raw.times)
+        duration = n_times / sfreq
+        b.add_header(f"{n_ch} ch ({type_str})", "Channels", f"{n_ch} ({type_str})")
+        b.add_header(f"{sfreq:.1f} Hz", "Sfreq", f"{sfreq:.1f} Hz")
+        b.add_header(
+            f"{n_times} samples ({duration:.1f} s)",
+            "Samples",
+            f"{n_times} ({duration:.1f} s)",
+        )
+        if self.description is not None:
+            desc_items = ", ".join(f"{k}={v}" for k, v in self.description.items())
+            b.add_row("description", desc_items)
+        return b
+
     def _target_name(self, target_name):
         if target_name is not None and not isinstance(target_name, (str, tuple, list)):
             raise ValueError("target_name has to be None, str, tuple or list")
@@ -291,6 +569,16 @@ class EEGWindowsDataset(RecordDataset):
     def __len__(self):
         return len(self.crop_inds)
 
+    def _build_repr(self):
+        return _build_windowed_repr(
+            type(self).__name__,
+            len(self),
+            self.raw,
+            self.crop_inds,
+            self.description,
+            self.metadata,
+        )
+
 
 @register_dataset
 class WindowsDataset(RecordDataset):
@@ -383,6 +671,16 @@ class WindowsDataset(RecordDataset):
     def __len__(self) -> int:
         return len(self.windows.events)
 
+    def _build_repr(self):
+        return _build_windowed_repr(
+            type(self).__name__,
+            len(self),
+            self.windows,
+            self.crop_inds,
+            self.description,
+            self.windows.metadata,
+        )
+
 
 @register_dataset
 class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
@@ -887,3 +1185,101 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             target_file_path = os.path.join(sub_dir, "target_name.json")
             with open(target_file_path, "w") as f:
                 json.dump({"target_name": ds.target_name}, f)
+
+    @staticmethod
+    def _signal_summary(ds):
+        """Return (mne_obj, is_windowed) from a dataset."""
+        if hasattr(ds, "windows"):
+            mne_obj = ds.windows
+        elif hasattr(ds, "raw"):
+            mne_obj = ds.raw
+        else:
+            return None, False
+        is_windowed = hasattr(ds, "crop_inds")
+        return mne_obj, is_windowed
+
+    def _build_repr(self):
+        n_ds = len(self.datasets)
+        b = _ReprBuilder("BaseConcatDataset")
+        if n_ds == 0:
+            b.add_header("0 datasets", "Recordings", 0)
+            return b
+
+        n_total = len(self)
+        ds_type = type(self.datasets[0]).__name__
+        first_ds = self.datasets[0]
+        mne_obj, is_windowed = self._signal_summary(first_ds)
+
+        b._type_display = f"BaseConcatDataset of {ds_type}"
+        b.add_header(f"{n_ds} {ds_type}(s)", "Recordings", n_ds)
+        b.add_header(f"{n_total} total samples", "Total samples", n_total)
+
+        if mne_obj is not None:
+            n_ch, type_str, sfreq = _channel_info(mne_obj)
+            b.add_row("Sfreq*", f"{sfreq:.1f} Hz")
+            b.add_row("Channels*", f"{n_ch} ({type_str})")
+
+            ch_names = mne_obj.info["ch_names"]
+            if len(ch_names) <= 10:
+                ch_str = ", ".join(ch_names)
+            else:
+                ch_str = (
+                    ", ".join(ch_names[:10]) + f", ... (+{len(ch_names) - 10} more)"
+                )
+            b.add_row("Ch. names*", ch_str)
+
+            montage = mne_obj.get_montage()
+            if montage is not None:
+                b.add_row("Montage*", montage.get_positions()["coord_frame"])
+
+            if not is_windowed:
+                n_times = len(mne_obj.times)
+                duration = n_times / sfreq
+                b.add_row("Duration*", f"{duration:.1f} s")
+
+            b.add_footnote("* from first recording")
+
+        desc = self.description
+        if desc is not None and not desc.empty:
+            col_str = ", ".join(str(c) for c in desc.columns)
+            b.add_row(
+                "Description",
+                f"{desc.shape[0]} recordings × {desc.shape[1]} columns [{col_str}]",
+            )
+
+        if is_windowed:
+            try:
+                summary = _concat_metadata_summary(self.datasets)
+                if summary["window_info"] is not None and mne_obj is not None:
+                    wi = summary["window_info"]
+                    if wi["uniform"]:
+                        win_secs = wi["min"] / sfreq
+                        b.add_row(
+                            "Window",
+                            f"{wi['min']} samples ({win_secs:.3f} s)",
+                        )
+                    else:
+                        min_secs = wi["min"] / sfreq
+                        max_secs = wi["max"] / sfreq
+                        b.add_row(
+                            "Window",
+                            f"{wi['min']}-{wi['max']} samples"
+                            f" ({min_secs:.3f}-{max_secs:.3f} s)",
+                        )
+                if summary["target_info"]:
+                    b.add_row("Targets", summary["target_info"])
+                if summary["extra_columns"]:
+                    b.add_row(
+                        "Extra meta",
+                        ", ".join(summary["extra_columns"]),
+                    )
+            except (TypeError, AttributeError):
+                pass
+
+        return b
+
+    def __repr__(self):
+        return self._build_repr().to_repr()
+
+    def _repr_html_(self):
+        return self._build_repr().to_html()

{braindecode-1.3.2.dev170848736 → braindecode-1.3.2.dev173417708}/braindecode/datasets/mne.py

@@ -100,6 +100,11 @@ def create_from_mne_epochs(
     window_size_samples: int,
     window_stride_samples: int,
     drop_last_window: bool,
+    descriptions: list[dict | pd.Series] | None = None,
+    mapping: dict[str | int, int] | None = None,
+    preload: bool = False,
+    picks: str | list | slice | None = None,
+    drop_bad_windows: bool = True,
 ) -> BaseConcatDataset:
     """Create WindowsDatasets from mne.Epochs.
 
@@ -114,6 +119,25 @@ def create_from_mne_epochs(
     drop_last_window : bool
         whether or not have a last overlapping window, when
         windows do not equally divide the continuous signal
+    descriptions : array-like | None
+        list of dicts or pandas.Series with additional information about
+        the epochs. If None, no description is added. Length must match
+        ``list_of_epochs``. Each description is applied to all windows
+        generated from the corresponding Epochs object.
+    mapping : dict(str | int: int) | None
+        Mapping from event description to target value. Keys can be
+        integers (matching ``epochs.events[:, 2]``) or their string
+        representations. If None, targets are set to the raw integer
+        event codes. If a mapping is provided and an event code is not
+        found in the mapping, the original event code is kept as-is.
+    preload : bool
+        if True, preload the data of the Epochs objects.
+    picks : str | list | slice | None
+        channels to include. If None, all available channels are used.
+    drop_bad_windows : bool
+        If True, call `.drop_bad()` on the resulting mne.Epochs object.
+        This allows identifying windows that fall outside of the valid
+        signal range. Defaults to True.
 
     Returns
     -------
@@ -126,8 +150,15 @@ def create_from_mne_epochs(
 
     _check_windowing_arguments(0, 0, window_size_samples, window_stride_samples)
 
+    if descriptions is not None:
+        if len(descriptions) != len(list_of_epochs):
+            raise ValueError(
+                f"length of 'list_of_epochs' ({len(list_of_epochs)}) and "
+                f"'descriptions' ({len(descriptions)}) has to match"
+            )
+
     list_of_windows_ds = []
-    for epochs in list_of_epochs:
+    for i, epochs in enumerate(list_of_epochs):
         event_descriptions = epochs.events[:, 2]
         original_trial_starts = epochs.events[:, 0]
         stop = len(epochs.times) - window_size_samples
@@ -142,6 +173,15 @@ def create_from_mne_epochs(
         fake_events = [[start, window_size_samples, -1] for start in starts]
 
         for trial_i, trial in enumerate(epochs):
+            # resolve target using mapping if provided
+            event_code = event_descriptions[trial_i]
+            if mapping is not None:
+                target = mapping.get(
+                    event_code, mapping.get(str(event_code), event_code)
+                )
+            else:
+                target = event_code
+
             metadata = pd.DataFrame(
                 {
                     "i_window_in_trial": np.arange(len(fake_events)),
@@ -149,7 +189,7 @@ def create_from_mne_epochs(
                     "i_stop_in_trial": starts
                     + original_trial_starts[trial_i]
                     + window_size_samples,
-                    "target": len(fake_events) * [event_descriptions[trial_i]],
+                    "target": len(fake_events) * [target],
                 }
             )
             # window size - 1, since tmax is inclusive
@@ -160,11 +200,15 @@ def create_from_mne_epochs(
                 tmin=0,
                 tmax=(window_size_samples - 1) / epochs.info["sfreq"],
                 metadata=metadata,
+                preload=preload,
+                picks=picks,
             )
 
-            mne_epochs.drop_bad(reject=None, flat=None)
+            if drop_bad_windows:
+                mne_epochs.drop_bad(reject=None, flat=None)
 
-            windows_ds = WindowsDataset(mne_epochs)
+            desc = descriptions[i] if descriptions is not None else None
+            windows_ds = WindowsDataset(mne_epochs, description=desc)
             list_of_windows_ds.append(windows_ds)
 
     return BaseConcatDataset(list_of_windows_ds)