braindecode 0.4.83__tar.gz → 0.4.85__tar.gz

{Braindecode-0.4.83 → Braindecode-0.4.85}/Braindecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.4.83
+Version: 0.4.85
 Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister

{Braindecode-0.4.83 → Braindecode-0.4.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.4.83
+Version: 0.4.85
 Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datasets/bbci.py

@@ -28,7 +28,9 @@ class BBCIDataset(object):
         Translational NeuroTechnology Lab, AG Ball, Freiburg, Germany.
     """
 
-    def __init__(self, filename, load_sensor_names=None, check_class_names=False):
+    def __init__(
+        self, filename, load_sensor_names=None, check_class_names=False
+    ):
         self.__dict__.update(locals())
         del self.self
 
@@ -43,7 +45,9 @@ class BBCIDataset(object):
         with h5py.File(self.filename, "r") as h5file:
             samples = int(h5file["nfo"]["T"][0, 0])
             cnt_signal_shape = (samples, len(wanted_chan_inds))
-            continuous_signal = np.ones(cnt_signal_shape, dtype=np.float32) * np.nan
+            continuous_signal = (
+                np.ones(cnt_signal_shape, dtype=np.float32) * np.nan
+            )
             for chan_ind_arr, chan_ind_set in enumerate(wanted_chan_inds):
                 # + 1 because matlab/this hdf5-naming logic
                 # has 1-based indexing
@@ -54,7 +58,9 @@ class BBCIDataset(object):
                     :
                 ].squeeze()  # already load into memory
                 continuous_signal[:, chan_ind_arr] = chan_signal
-            assert not np.any(np.isnan(continuous_signal)), "No NaNs expected in signal"
+            assert not np.any(
+                np.isnan(continuous_signal)
+            ), "No NaNs expected in signal"
 
         if self.load_sensor_names is None:
             ch_types = ["EEG"] * len(wanted_chan_inds)
@@ -77,7 +83,9 @@ class BBCIDataset(object):
             eeg_sensor_names = filter(
                 lambda s: not s.startswith("BIP"), eeg_sensor_names
             )
-            eeg_sensor_names = filter(lambda s: not s.startswith("E"), eeg_sensor_names)
+            eeg_sensor_names = filter(
+                lambda s: not s.startswith("E"), eeg_sensor_names
+            )
             eeg_sensor_names = filter(
                 lambda s: not s.startswith("Microphone"), eeg_sensor_names
             )
@@ -95,7 +103,9 @@ class BBCIDataset(object):
                 or len(eeg_sensor_names) == 16
             ), "Recheck this code if you have different sensors..."
             self.load_sensor_names = eeg_sensor_names
-        chan_inds = self._determine_chan_inds(all_sensor_names, self.load_sensor_names)
+        chan_inds = self._determine_chan_inds(
+            all_sensor_names, self.load_sensor_names
+        )
         return chan_inds, self.load_sensor_names
 
     def _determine_samplingrate(self):
@@ -109,8 +119,12 @@ class BBCIDataset(object):
     def _determine_chan_inds(all_sensor_names, sensor_names):
         assert sensor_names is not None
         chan_inds = [all_sensor_names.index(s) for s in sensor_names]
-        assert len(chan_inds) == len(sensor_names), "All" "sensors should be there."
-        assert len(set(chan_inds)) == len(chan_inds), "No" "duplicated sensors wanted."
+        assert len(chan_inds) == len(sensor_names), (
+            "All" "sensors should be there."
+        )
+        assert len(set(chan_inds)) == len(chan_inds), (
+            "No" "duplicated sensors wanted."
+        )
         return chan_inds
 
     @staticmethod
@@ -143,16 +157,21 @@ class BBCIDataset(object):
     def _add_markers(self, cnt):
         with h5py.File(self.filename, "r") as h5file:
             event_times_in_ms = h5file["mrk"]["time"][:].squeeze()
-            event_classes = h5file["mrk"]["event"]["desc"][:].squeeze().astype(np.int64)
+            event_classes = (
+                h5file["mrk"]["event"]["desc"][:].squeeze().astype(np.int64)
+            )
 
             # Check whether class names known and correct order
             class_name_set = h5file["nfo"]["className"][:].squeeze()
             all_class_names = [
-                "".join(chr(c) for c in h5file[obj_ref]) for obj_ref in class_name_set
+                "".join(chr(c) for c in h5file[obj_ref])
+                for obj_ref in class_name_set
             ]
 
             if self.check_class_names:
-                _check_class_names(all_class_names, event_times_in_ms, event_classes)
+                _check_class_names(
+                    all_class_names, event_times_in_ms, event_classes
+                )
 
         event_times_in_samples = event_times_in_ms * cnt.info["sfreq"] / 1000.0
         event_times_in_samples = np.uint32(np.round(event_times_in_samples))
@@ -166,7 +185,9 @@ class BBCIDataset(object):
                 log.warning(
                     "Same sample has at least two markers.\n"
                     "{:d}: ({:.0f} and {:.0f}).\n".format(
-                        i_sample, event_classes[i_event - 1], event_classes[i_event]
+                        i_sample,
+                        event_classes[i_event - 1],
+                        event_classes[i_event],
                     )
                     + "Marker codes will be summed."
                 )
@@ -434,7 +455,15 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
         "__",
     ]:
         pass
-    elif all_class_names == ["0004", "0056", "0080", "0088", "0096", "0120", "__"]:
+    elif all_class_names == [
+        "0004",
+        "0056",
+        "0080",
+        "0088",
+        "0096",
+        "0120",
+        "__",
+    ]:
         pass
     elif all_class_names == [
         "0004",
@@ -494,7 +523,18 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
         pass
     elif all_class_names == ["0", "4", "16", "56", "88", "120"]:
         pass
-    elif all_class_names == ["0", "4", "32", "48", "56", "64", "80", "88", "95", "120"]:
+    elif all_class_names == [
+        "0",
+        "4",
+        "32",
+        "48",
+        "56",
+        "64",
+        "80",
+        "88",
+        "95",
+        "120",
+    ]:
         pass
     elif all_class_names == ["0", "4", "56", "80", "88", "96", "120"]:
         pass
@@ -502,11 +542,44 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
         pass
     elif all_class_names == ["One", "Two", "Three", "Four"]:
         pass
-    elif all_class_names == ["1", "10", "11", "12", "2", "20", "3", "30", "4", "40"]:
+    elif all_class_names == [
+        "1",
+        "10",
+        "11",
+        "12",
+        "2",
+        "20",
+        "3",
+        "30",
+        "4",
+        "40",
+    ]:
         pass
-    elif all_class_names == ["1", "10", "12", "13", "2", "20", "3", "30", "4", "40"]:
+    elif all_class_names == [
+        "1",
+        "10",
+        "12",
+        "13",
+        "2",
+        "20",
+        "3",
+        "30",
+        "4",
+        "40",
+    ]:
         pass
-    elif all_class_names == ["1", "10", "13", "2", "20", "3", "30", "4", "40", "99"]:
+    elif all_class_names == [
+        "1",
+        "10",
+        "13",
+        "2",
+        "20",
+        "3",
+        "30",
+        "4",
+        "40",
+        "99",
+    ]:
         pass
     elif all_class_names == [
         "1",

Braindecode-0.4.85/braindecode/datasets/bcic_iv_2a.py

@@ -0,0 +1,89 @@
+import numpy as np
+import mne
+from scipy.io import loadmat
+
+
+class BCICompetition4Set2A(object):
+    def __init__(self, filename, load_sensor_names=None, labels_filename=None):
+        assert load_sensor_names is None
+        self.__dict__.update(locals())
+        del self.self
+
+    def load(self):
+        cnt = self.extract_data()
+        events, artifact_trial_mask = self.extract_events(cnt)
+        cnt.info["events"] = events
+        cnt.info["artifact_trial_mask"] = artifact_trial_mask
+        return cnt
+
+    def extract_data(self):
+        raw_gdf = mne.io.read_raw_gdf(self.filename, stim_channel="auto")
+        raw_gdf.load_data()
+        # correct nan values
+
+        data = raw_gdf.get_data()
+
+        for i_chan in range(data.shape[0]):
+            # first set to nan, than replace nans by nanmean.
+            this_chan = data[i_chan]
+            data[i_chan] = np.where(
+                this_chan == np.min(this_chan), np.nan, this_chan
+            )
+            mask = np.isnan(data[i_chan])
+            chan_mean = np.nanmean(data[i_chan])
+            data[i_chan, mask] = chan_mean
+
+        gdf_events = mne.events_from_annotations(raw_gdf)
+        raw_gdf = mne.io.RawArray(data, raw_gdf.info, verbose="WARNING")
+        # remember gdf events
+        raw_gdf.info["gdf_events"] = gdf_events
+        return raw_gdf
+
+    def extract_events(self, raw_gdf):
+        # all events
+        events, name_to_code = raw_gdf.info["gdf_events"]
+
+        if "class1, Left hand - cue onset (BCI experiment)" in name_to_code:
+            train_set = True
+        else:
+            train_set = False
+            assert (
+                "cue unknown/undefined (used for BCI competition) "
+                in name_to_code
+            )
+
+        if train_set:
+            trial_codes = [4, 5, 6, 7]  # the 4 classes
+        else:
+            trial_codes = [4]  # "unknown" class
+
+        trial_mask = [ev_code in trial_codes for ev_code in events[:, 2]]
+        trial_events = events[trial_mask]
+        assert len(trial_events) == 288, "Got {:d} markers".format(
+            len(trial_events)
+        )
+        trial_events[:, 2] = trial_events[:, 2] - 3
+        # possibly overwrite with markers from labels file
+        if self.labels_filename is not None:
+            classes = loadmat(self.labels_filename)["classlabel"].squeeze()
+            if train_set:
+                np.testing.assert_array_equal(trial_events[:, 2], classes)
+            trial_events[:, 2] = classes
+        unique_classes = np.unique(trial_events[:, 2])
+        assert np.array_equal(
+            [1, 2, 3, 4], unique_classes
+        ), "Expect 1,2,3,4 as class labels, got {:s}".format(
+            str(unique_classes)
+        )
+
+        # now also create 0-1 vector for rejected trials
+        trial_start_events = events[events[:, 2] == 2]
+        assert len(trial_start_events) == len(trial_events)
+        artifact_trial_mask = np.zeros(len(trial_events), dtype=np.uint8)
+        artifact_events = events[events[:, 2] == 1]
+
+        for artifact_time in artifact_events[:, 0]:
+            i_trial = trial_start_events[:, 0].tolist().index(artifact_time)
+            artifact_trial_mask[i_trial] = 1
+
+        return trial_events, artifact_trial_mask

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datasets/multiple.py

@@ -1,6 +1,9 @@
 import logging
 
-from braindecode.mne_ext.signalproc import resample_cnt, concatenate_raws_with_events
+from braindecode.mne_ext.signalproc import (
+    resample_cnt,
+    concatenate_raws_with_events,
+)
 
 log = logging.getLogger(__name__)
 

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datautil/iterators.py

@@ -2,7 +2,9 @@ import numpy as np
 from numpy.random import RandomState
 
 
-def get_balanced_batches(n_trials, rng, shuffle, n_batches=None, batch_size=None):
+def get_balanced_batches(
+    n_trials, rng, shuffle, n_batches=None, batch_size=None
+):
     """Create indices for batches balanced in size 
     (batches will have maximum size difference of 1).
     Supply either batch size or number of batches. Resulting batches
@@ -73,7 +75,7 @@ class BalancedBatchSizeIterator(object):
         self.rng = RandomState(self.seed)
 
     def get_batches(self, dataset, shuffle):
-        n_trials = dataset.X.shape[0]
+        n_trials = len(dataset.X)
         batches = get_balanced_batches(
             n_trials, batch_size=self.batch_size, rng=self.rng, shuffle=shuffle
         )
@@ -113,7 +115,7 @@ class ClassBalancedBatchSizeIterator(object):
         self.rng = RandomState(self.seed)
 
     def get_batches(self, dataset, shuffle):
-        n_trials = dataset.X.shape[0]
+        n_trials = len(dataset.X)
         batches = get_balanced_batches(
             n_trials, batch_size=self.batch_size, rng=self.rng, shuffle=shuffle
         )
@@ -124,7 +126,9 @@ class ClassBalancedBatchSizeIterator(object):
             ]
             class_probabilities = np.array(class_probabilities)
             # choose trials in inverse probability of class
-            trial_probabilities = [1.0 / class_probabilities[y] for y in dataset.y]
+            trial_probabilities = [
+                1.0 / class_probabilities[y] for y in dataset.y
+            ]
             trial_probabilities = np.array(trial_probabilities) / np.sum(
                 trial_probabilities
             )
@@ -134,7 +138,9 @@ class ClassBalancedBatchSizeIterator(object):
 
         for batch_inds in batches:
             if shuffle:
-                batch_inds = [i_trial_to_balanced[i_trial] for i_trial in batch_inds]
+                batch_inds = [
+                    i_trial_to_balanced[i_trial] for i_trial in batch_inds
+                ]
             batch_X = dataset.X[batch_inds]
             batch_y = dataset.y[batch_inds]
 
@@ -178,7 +184,11 @@ class CropsFromTrialsIterator(object):
     """
 
     def __init__(
-        self, batch_size, input_time_length, n_preds_per_input, seed=(2017, 6, 28)
+        self,
+        batch_size,
+        input_time_length,
+        n_preds_per_input,
+        seed=(2017, 6, 28),
     ):
         self.batch_size = batch_size
         self.input_time_length = input_time_length
@@ -283,7 +293,8 @@ def _compute_start_stop_block_inds(
             # check that block is correct, all predicted samples together
             # should be the trial samples
             all_predicted_samples = [
-                range(stop - n_preds_per_input, stop) for _, stop in start_stop_blocks
+                range(stop - n_preds_per_input, stop)
+                for _, stop in start_stop_blocks
             ]
             # this check takes about 50 ms in performance test
             # whereas loop itself takes only 5 ms.. deactivate it if not necessary

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datautil/lazy_iterators.py

@@ -92,7 +92,9 @@ class LazyCropsFromTrialsIterator(object):
             collate_fn = partial(self.collate_fn, rng_state=random_state)
         else:
             collate_fn = partial(self.collate_fn, rng_state=None)
-        batch_indeces = self._get_batch_indeces(dataset=dataset, shuffle=shuffle)
+        batch_indeces = self._get_batch_indeces(
+            dataset=dataset, shuffle=shuffle
+        )
         data_loader = DataLoader(
             dataset=dataset,
             batch_sampler=batch_indeces,

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datautil/signalproc.py

@@ -47,11 +47,15 @@ def exponential_running_standardize(
     standardized = np.array(standardized)
     if init_block_size is not None:
         other_axis = tuple(range(1, len(data.shape)))
-        init_mean = np.mean(data[0:init_block_size], axis=other_axis, keepdims=True)
-        init_std = np.std(data[0:init_block_size], axis=other_axis, keepdims=True)
-        init_block_standardized = (data[0:init_block_size] - init_mean) / np.maximum(
-            eps, init_std
+        init_mean = np.mean(
+            data[0:init_block_size], axis=other_axis, keepdims=True
         )
+        init_std = np.std(
+            data[0:init_block_size], axis=other_axis, keepdims=True
+        )
+        init_block_standardized = (
+            data[0:init_block_size] - init_mean
+        ) / np.maximum(eps, init_std)
         standardized[0:init_block_size] = init_block_standardized
     return standardized
 
@@ -85,7 +89,9 @@ def exponential_running_demean(data, factor_new=0.001, init_block_size=None):
     demeaned = np.array(demeaned)
     if init_block_size is not None:
         other_axis = tuple(range(1, len(data.shape)))
-        init_mean = np.mean(data[0:init_block_size], axis=other_axis, keepdims=True)
+        init_mean = np.mean(
+            data[0:init_block_size], axis=other_axis, keepdims=True
+        )
         demeaned[0:init_block_size] = data[0:init_block_size] - init_mean
     return demeaned
 
@@ -110,7 +116,9 @@ def highpass_cnt(data, low_cut_hz, fs, filt_order=3, axis=0):
     if (low_cut_hz is None) or (low_cut_hz == 0):
         log.info("Not doing any highpass, since low 0 or None")
         return data.copy()
-    b, a = scipy.signal.butter(filt_order, low_cut_hz / (fs / 2.0), btype="highpass")
+    b, a = scipy.signal.butter(
+        filt_order, low_cut_hz / (fs / 2.0), btype="highpass"
+    )
     assert filter_is_stable(a)
     data_highpassed = scipy.signal.lfilter(b, a, data, axis=axis)
     return data_highpassed
@@ -134,9 +142,13 @@ def lowpass_cnt(data, high_cut_hz, fs, filt_order=3, axis=0):
         Data after applying lowpass filter.
     """
     if (high_cut_hz is None) or (high_cut_hz == fs / 2.0):
-        log.info("Not doing any lowpass, since high cut hz is None or nyquist freq.")
+        log.info(
+            "Not doing any lowpass, since high cut hz is None or nyquist freq."
+        )
         return data.copy()
-    b, a = scipy.signal.butter(filt_order, high_cut_hz / (fs / 2.0), btype="lowpass")
+    b, a = scipy.signal.butter(
+        filt_order, high_cut_hz / (fs / 2.0), btype="lowpass"
+    )
     assert filter_is_stable(a)
     data_lowpassed = scipy.signal.lfilter(b, a, data, axis=axis)
     return data_lowpassed
@@ -174,10 +186,16 @@ def bandpass_cnt(
         return data.copy()
     if low_cut_hz == 0 or low_cut_hz == None:
         log.info("Using lowpass filter since low cut hz is 0 or None")
-        return lowpass_cnt(data, high_cut_hz, fs, filt_order=filt_order, axis=axis)
+        return lowpass_cnt(
+            data, high_cut_hz, fs, filt_order=filt_order, axis=axis
+        )
     if high_cut_hz == None or high_cut_hz == (fs / 2.0):
-        log.info("Using highpass filter since high cut hz is None or nyquist freq")
-        return highpass_cnt(data, low_cut_hz, fs, filt_order=filt_order, axis=axis)
+        log.info(
+            "Using highpass filter since high cut hz is None or nyquist freq"
+        )
+        return highpass_cnt(
+            data, low_cut_hz, fs, filt_order=filt_order, axis=axis
+        )
 
     nyq_freq = 0.5 * fs
     low = low_cut_hz / nyq_freq

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datautil/splitters.py

@@ -128,7 +128,9 @@ def split_into_train_valid_test(dataset, n_folds, i_test_fold, rng=None):
     """
     n_trials = len(dataset.X)
     if n_trials < n_folds:
-        raise ValueError("Less Trials: {:d} than folds: {:d}".format(n_trials, n_folds))
+        raise ValueError(
+            "Less Trials: {:d} than folds: {:d}".format(n_trials, n_folds)
+        )
     shuffle = rng is not None
     folds = get_balanced_batches(n_trials, rng, shuffle, n_batches=n_folds)
     test_inds = folds[i_test_fold]
@@ -139,7 +141,8 @@ def split_into_train_valid_test(dataset, n_folds, i_test_fold, rng=None):
     assert np.intersect1d(train_inds, test_inds).size == 0
     assert np.intersect1d(valid_inds, test_inds).size == 0
     assert np.array_equal(
-        np.sort(np.union1d(train_inds, np.union1d(valid_inds, test_inds))), all_inds
+        np.sort(np.union1d(train_inds, np.union1d(valid_inds, test_inds))),
+        all_inds,
     )
 
     train_set = select_examples(dataset, train_inds)
@@ -170,7 +173,9 @@ def split_into_train_test(dataset, n_folds, i_test_fold, rng=None):
     """
     n_trials = len(dataset.X)
     if n_trials < n_folds:
-        raise ValueError("Less Trials: {:d} than folds: {:d}".format(n_trials, n_folds))
+        raise ValueError(
+            "Less Trials: {:d} than folds: {:d}".format(n_trials, n_folds)
+        )
     shuffle = rng is not None
     folds = get_balanced_batches(n_trials, rng, shuffle, n_batches=n_folds)
     test_inds = folds[i_test_fold]

{Braindecode-0.4.83 → Braindecode-0.4.85}/braindecode/datautil/trial_segment.py

@@ -161,7 +161,13 @@ def _to_mrk_code_to_name_and_y(name_to_codes):
 
 
 def _create_signal_target_from_start_and_ival(
-    data, events, fs, name_to_codes, epoch_ival_ms, one_hot_labels, one_label_per_trial
+    data,
+    events,
+    fs,
+    name_to_codes,
+    epoch_ival_ms,
+    one_hot_labels,
+    one_label_per_trial,
 ):
     cnt_y, i_start_stops = _create_cnt_y_and_trial_bounds_from_start_and_ival(
         data.shape[1], events, fs, name_to_codes, epoch_ival_ms
@@ -253,7 +259,12 @@ def _create_signal_target_from_start_and_stop(
 
 
 def _create_cnt_y_and_trial_bounds_from_start_stop(
-    n_samples, events, fs, name_to_start_codes, epoch_ival_ms, name_to_stop_codes
+    n_samples,
+    events,
+    fs,
+    name_to_start_codes,
+    epoch_ival_ms,
+    name_to_stop_codes,
 ):
     """
     Create a one-hot-encoded continuous marker array (cnt_y).
@@ -305,7 +316,9 @@ def _create_cnt_y_and_trial_bounds_from_start_stop(
         codes = name_to_stop_codes[name]
         if not hasattr(codes, "__len__"):
             name_to_stop_codes[name] = [codes]
-    all_stop_codes = np.concatenate(list(name_to_stop_codes.values())).astype(np.int64)
+    all_stop_codes = np.concatenate(list(name_to_stop_codes.values())).astype(
+        np.int64
+    )
     class_to_n_trials = Counter()
     n_classes = len(name_to_start_codes)
     cnt_y = np.zeros((n_samples, n_classes), dtype=np.int64)
@@ -387,7 +400,9 @@ def _create_signal_target_from_cnt_y_start_stops(
             if (i_stop - i_start) > prepad_trials_to_n_samples:
                 new_i_start_stops.append((i_start, i_stop))
             elif i_stop >= prepad_trials_to_n_samples:
-                new_i_start_stops.append((i_stop - prepad_trials_to_n_samples, i_stop))
+                new_i_start_stops.append(
+                    (i_stop - prepad_trials_to_n_samples, i_stop)
+                )
             else:
                 log.warning(
                     "Could not pad trial enough, therefore not "
@@ -423,7 +438,9 @@ def _create_signal_target_from_cnt_y_start_stops(
         new_y = []
         for this_y in y:
             # if destroying one hot later, just set most occuring class to 1
-            unique_labels, counts = np.unique(this_y, axis=0, return_counts=True)
+            unique_labels, counts = np.unique(
+                this_y, axis=0, return_counts=True
+            )
             if not one_hot_labels:
                 meaned_y = np.mean(this_y, axis=0)
                 this_new_y = np.zeros_like(meaned_y)
@@ -620,10 +637,14 @@ def add_breaks(
         Events with break start and stop markers.
     """
     min_samples = (
-        None if min_break_length_ms is None else ms_to_samples(min_break_length_ms, fs)
+        None
+        if min_break_length_ms is None
+        else ms_to_samples(min_break_length_ms, fs)
     )
     max_samples = (
-        None if max_break_length_ms is None else ms_to_samples(max_break_length_ms, fs)
+        None
+        if max_break_length_ms is None
+        else ms_to_samples(max_break_length_ms, fs)
     )
     orig_events = events
     break_starts, break_stops = _extract_break_start_stop_ms(
@@ -657,7 +678,9 @@ def add_breaks(
     return new_events
 
 
-def _extract_break_start_stop_ms(events, name_to_start_codes, name_to_stop_codes):
+def _extract_break_start_stop_ms(
+    events, name_to_start_codes, name_to_stop_codes
+):
     assert len(events[0]) == 2, "expect only 2dimensional event array here"
     start_code_to_name_and_y = _to_mrk_code_to_name_and_y(name_to_start_codes)
     # Ensure all stop marker codes are iterables
@@ -665,7 +688,9 @@ def _extract_break_start_stop_ms(events, name_to_start_codes, name_to_stop_codes
         codes = name_to_stop_codes[name]
         if not hasattr(codes, "__len__"):
             name_to_stop_codes[name] = [codes]
-    all_stop_codes = np.concatenate(list(name_to_stop_codes.values())).astype(np.int32)
+    all_stop_codes = np.concatenate(list(name_to_stop_codes.values())).astype(
+        np.int32
+    )
     event_samples = events[:, 0]
     event_codes = events[:, 1]
 
@@ -673,7 +698,9 @@ def _extract_break_start_stop_ms(events, name_to_start_codes, name_to_stop_codes
     break_stops = []
     i_event = 0
     while i_event < len(events):
-        while (i_event < len(events)) and (event_codes[i_event] not in all_stop_codes):
+        while (i_event < len(events)) and (
+            event_codes[i_event] not in all_stop_codes
+        ):
             i_event += 1
         if i_event < len(events):
             # one sample after start