RUFF: ruff check --fix; ruff format

Author: sappelhoff

docs/conf.py

@@ -1,4 +1,5 @@
 """Configure sphinx."""
+
 import os
 import sys
 from datetime import datetime
@@ -17,7 +18,7 @@
 # -- Project information -----------------------------------------------------
 project = "pyprep"
 author = "PyPREP developers"
-copyright = f"2018, {author}. Last updated {datetime.now().isoformat()}"
+copyright = f"2018, {author}. Last updated {datetime.now().isoformat()}"  # noqa: A001
 
 # The short X.Y version
 version = pyprep.__version__

docs/sphinxext/gh_substitutions.py

@@ -6,6 +6,7 @@
 https://doughellmann.com/blog/2010/05/09/defining-custom-roles-in-sphinx/
 
 """
+
 from docutils.nodes import reference
 from docutils.parsers.rst.roles import set_classes
 

examples/run_full_prep.py

@@ -31,10 +31,10 @@
 # First we import what we need for this example.
 from pathlib import Path
 
+import matplotlib.pyplot as plt
 import mne
 import numpy as np
 import scipy.io as sio
-import matplotlib.pyplot as plt
 
 from pyprep.prep_pipeline import PrepPipeline
 
@@ -103,9 +103,9 @@
 #
 # You can check the detected bad channels in each step of PREP.
 
-print("Bad channels: {}".format(prep.interpolated_channels))
-print("Bad channels original: {}".format(prep.noisy_channels_original["bad_all"]))
-print("Bad channels after interpolation: {}".format(prep.still_noisy_channels))
+print(f"Bad channels: {prep.interpolated_channels}")
+print(f"Bad channels original: {prep.noisy_channels_original['bad_all']}")
+print(f"Bad channels after interpolation: {prep.still_noisy_channels}")
 
 # Matlab's results
 # ----------------
@@ -164,7 +164,7 @@
 axs[0, 1].set_title("Original EEG", fontsize=14)
 # axs[0, 0].set_ylabel('Channel Number', fontsize=14)
 cb = fig.colorbar(im, ax=axs, fraction=0.05, pad=0.04)
-cb.set_label("\u03BCVolt", fontsize=14)
+cb.set_label("\u03bcVolt", fontsize=14)
 
 EEG_new_matlab = sio.loadmat(fname_mat2)
 EEG_new_matlab = EEG_new_matlab["save_data"]
@@ -307,11 +307,11 @@
 ###############################################################################
 # Mean square error of each step:
 
-print("Raw data MSE: {}".format(EEG_raw_mse))
-print("Filtered data MSE: {}".format(EEG_new_mse))
-print("Line-noise removed data MSE: {}".format(EEG_mse))
-print("Referenced data MSE: {}".format(EEG_ref_mse))
-print("Interpolated data MSE: {}".format(EEG_final_mse))
+print(f"Raw data MSE: {EEG_raw_mse}")
+print(f"Filtered data MSE: {EEG_new_mse}")
+print(f"Line-noise removed data MSE: {EEG_mse}")
+print(f"Referenced data MSE: {EEG_ref_mse}")
+print(f"Interpolated data MSE: {EEG_final_mse}")
 
 ###############################################################################
 # Discussion

examples/run_ransac.py

@@ -16,10 +16,11 @@
 
 ###############################################################################
 # First we import what we need for this example.
-import numpy as np
+from time import perf_counter
+
 import mne
+import numpy as np
 from scipy import signal as signal
-from time import perf_counter
 
 from pyprep.find_noisy_channels import NoisyChannels
 

pyprep/__init__.py

@@ -1,4 +1,5 @@
 """Initialize PyPREP."""
+
 import pyprep.ransac as ransac  # noqa: F401
 from pyprep.find_noisy_channels import NoisyChannels  # noqa: F401
 from pyprep.prep_pipeline import PrepPipeline  # noqa: F401

pyprep/find_noisy_channels.py

@@ -1,4 +1,5 @@
 """finds bad channels."""
+
 import mne
 import numpy as np
 from mne.utils import check_random_state, logger

pyprep/prep_pipeline.py

@@ -1,4 +1,5 @@
 """Module for PREP pipeline."""
+
 import mne
 from mne.utils import check_random_state
 

pyprep/ransac.py

@@ -1,4 +1,5 @@
 """RANSAC bad channel identification."""
+
 import mne
 import numpy as np
 from mne.channels.interpolation import _make_interpolation_matrix
@@ -125,8 +126,9 @@ def find_bad_by_ransac(
 
     # First, check that the argument types are valid
     if not isinstance(n_samples, int):
-        err = "Argument 'n_samples' must be an int (got {0})"
-        raise TypeError(err.format(type(n_samples).__name__))
+        raise TypeError(
+            f"Argument 'n_samples' must be an int (got {type(n_samples).__name__})"
+        )
 
     complete_chn_labs = np.asarray(complete_chn_labs)
 
@@ -144,13 +146,17 @@ def find_bad_by_ransac(
 
     if n_pred_chns <= 3:
         sample_pct = int(sample_prop * 100)
-        e = "Too few channels in the original data to reliably perform RANSAC "
-        e += "(minimum {0} for a sample size of {1}%)."
-        raise IOError(e.format(int(np.floor(4.0 / sample_prop)), sample_pct))
+        raise OSError(
+            "Too few channels in the original data to reliably perform RANSAC"
+            f"(minimum {int(np.floor(4.0 / sample_prop))} for a sample size "
+            f"of {sample_pct}%)."
+        )
     elif n_chans_good < (n_pred_chns + 1):
-        e = "Too many noisy channels in the data to reliably perform RANSAC "
-        e += "(only {0} good channels remaining, need at least {1})."
-        raise IOError(e.format(n_chans_good, n_pred_chns + 1))
+        raise OSError(
+            "Too many noisy channels in the data to reliably perform RANSAC "
+            f"(only {n_chans_good} good channels remaining, "
+            f"need at least {n_pred_chns + 1})."
+        )
 
     # Before running, make sure we have enough memory when using the
     # smallest possible chunk size

pyprep/reference.py

@@ -1,4 +1,5 @@
 """functions of referencing part of PREP."""
+
 import logging
 
 import numpy as np
@@ -214,7 +215,7 @@ def robust_reference(self, max_iterations=4):
         noisy_detector.find_all_bads(**self.ransac_settings)
         self.noisy_channels_original = noisy_detector.get_bads(as_dict=True)
         self._extra_info["initial_bad"] = noisy_detector._extra_info
-        logger.info("Bad channels: {}".format(self.noisy_channels_original))
+        logger.info(f"Bad channels: {self.noisy_channels_original}")
 
         # Determine channels to use/exclude from initial reference estimation
         self.unusable_channels = _union(
@@ -279,7 +280,7 @@ def robust_reference(self, max_iterations=4):
                 if bad_type not in ignore:
                     bad_chans.update(noisy[bad_type])
             noisy["bad_all"] = list(bad_chans)
-            logger.info("Bad channels: {}".format(noisy))
+            logger.info(f"Bad channels: {noisy}")
 
             if (
                 iterations > 1
@@ -313,7 +314,7 @@ def robust_reference(self, max_iterations=4):
                 signal, self.reference_signal, reference_index
             )
             iterations = iterations + 1
-            logger.info("Iterations: {}".format(iterations))
+            logger.info(f"Iterations: {iterations}")
 
         return self.noisy_channels, self.reference_signal
 
@@ -356,9 +357,7 @@ def remove_reference(signal, reference, index=None):
         else:
             if not isinstance(index, list):
                 raise TypeError(
-                    "RemoveReference: Expected type list, got {} instead".format(
-                        type(index)
-                    )
+                    f"RemoveReference: Expected type list, got {type(index)} instead"
                 )
             signal_referenced = signal.copy()
             signal_referenced[np.asarray(index), :] = (

pyprep/removeTrend.py

@@ -1,4 +1,5 @@
 """High-pass filter and locally detrend the EEG signal."""
+
 import logging
 
 import mne