def create_from_mne_epochs(
    list_of_epochs: list[mne.BaseEpochs],
    window_size_samples: int,
    window_stride_samples: int,
    drop_last_window: bool,
) -> BaseConcatDataset:
    """Create WindowsDatasets from mne.Epochs

    Parameters
    ----------
    list_of_epochs: array-like
        list of mne.Epochs
    window_size_samples: int
        window size
    window_stride_samples: int
        stride between windows
    drop_last_window: bool
        whether or not have a last overlapping window, when
        windows do not equally divide the continuous signal

    Returns
    -------
    windows_datasets: BaseConcatDataset
        X and y transformed to a dataset format that is compatible with skorch
        and braindecode
    """
    # Prevent circular import
    from ..preprocessing.windowers import _check_windowing_arguments

    _check_windowing_arguments(0, 0, window_size_samples, window_stride_samples)

    list_of_windows_ds = []
    for epochs in list_of_epochs:
        event_descriptions = epochs.events[:, 2]
        original_trial_starts = epochs.events[:, 0]
        stop = len(epochs.times) - window_size_samples

        # already includes last incomplete window start
        starts = np.arange(0, stop + 1, window_stride_samples)

        if not drop_last_window and starts[-1] < stop:
            # if last window does not end at trial stop, make it stop there
            starts = np.append(starts, stop)

        fake_events = [[start, window_size_samples, -1] for start in starts]

        for trial_i, trial in enumerate(epochs):
            metadata = pd.DataFrame(
                {
                    "i_window_in_trial": np.arange(len(fake_events)),
                    "i_start_in_trial": starts + original_trial_starts[trial_i],
                    "i_stop_in_trial": starts
                    + original_trial_starts[trial_i]
                    + window_size_samples,
                    "target": len(fake_events) * [event_descriptions[trial_i]],
                }
            )
            # window size - 1, since tmax is inclusive
            mne_epochs = mne.Epochs(
                mne.io.RawArray(trial, epochs.info),
                fake_events,
                baseline=None,
                tmin=0,
                tmax=(window_size_samples - 1) / epochs.info["sfreq"],
                metadata=metadata,
            )

            mne_epochs.drop_bad(reject=None, flat=None)

            windows_ds = WindowsDataset(mne_epochs)
            list_of_windows_ds.append(windows_ds)

    return BaseConcatDataset(list_of_windows_ds)
Create WindowsDatasets from mne.Epochs

    Parameters
    ----------
    list_of_epochs: array-like
        list of mne.Epochs
    window_size_samples: int
        window size
    window_stride_samples: int
        stride between windows
    drop_last_window: bool
        whether or not have a last overlapping window, when
        windows do not equally divide the continuous signal

    Returns
    -------
    windows_datasets: BaseConcatDataset
        X and y transformed to a dataset format that is compatible with skorch
        and braindecode
    
braindecode/datasets/mne.py