MNT Applies black formatting to most of the code base (scikit-learn#18948)

Author: thomasjpfan

.github/scripts/label_title_regex.py

@@ -15,15 +15,9 @@
 title = issue.title
 
 
-regex_to_labels = [
-    (r"\bDOC\b", "Documentation"),
-    (r"\bCI\b", "Build / CI")
-]
+regex_to_labels = [(r"\bDOC\b", "Documentation"), (r"\bCI\b", "Build / CI")]
 
-labels_to_add = [
-    label for regex, label in regex_to_labels
-    if re.search(regex, title)
-]
+labels_to_add = [label for regex, label in regex_to_labels if re.search(regex, title)]
 
 if labels_to_add:
     issue.add_to_labels(*labels_to_add)

asv_benchmarks/benchmarks/cluster.py

@@ -10,16 +10,16 @@ class KMeansBenchmark(Predictor, Transformer, Estimator, Benchmark):
     Benchmarks for KMeans.
     """
 
-    param_names = ['representation', 'algorithm', 'init']
-    params = (['dense', 'sparse'], ['full', 'elkan'], ['random', 'k-means++'])
+    param_names = ["representation", "algorithm", "init"]
+    params = (["dense", "sparse"], ["full", "elkan"], ["random", "k-means++"])
 
     def setup_cache(self):
         super().setup_cache()
 
     def make_data(self, params):
         representation, algorithm, init = params
 
-        if representation == 'sparse':
+        if representation == "sparse":
             data = _20newsgroups_highdim_dataset(n_samples=8000)
         else:
             data = _blobs_dataset(n_clusters=20)
@@ -29,44 +29,46 @@ def make_data(self, params):
     def make_estimator(self, params):
         representation, algorithm, init = params
 
-        max_iter = 30 if representation == 'sparse' else 100
+        max_iter = 30 if representation == "sparse" else 100
 
-        estimator = KMeans(n_clusters=20,
-                           algorithm=algorithm,
-                           init=init,
-                           n_init=1,
-                           max_iter=max_iter,
-                           tol=-1,
-                           random_state=0)
+        estimator = KMeans(
+            n_clusters=20,
+            algorithm=algorithm,
+            init=init,
+            n_init=1,
+            max_iter=max_iter,
+            tol=-1,
+            random_state=0,
+        )
 
         return estimator
 
     def make_scorers(self):
-        self.train_scorer = (
-            lambda _, __: neg_mean_inertia(self.X,
-                                           self.estimator.predict(self.X),
-                                           self.estimator.cluster_centers_))
-        self.test_scorer = (
-            lambda _, __: neg_mean_inertia(self.X_val,
-                                           self.estimator.predict(self.X_val),
-                                           self.estimator.cluster_centers_))
+        self.train_scorer = lambda _, __: neg_mean_inertia(
+            self.X, self.estimator.predict(self.X), self.estimator.cluster_centers_
+        )
+        self.test_scorer = lambda _, __: neg_mean_inertia(
+            self.X_val,
+            self.estimator.predict(self.X_val),
+            self.estimator.cluster_centers_,
+        )
 
 
 class MiniBatchKMeansBenchmark(Predictor, Transformer, Estimator, Benchmark):
     """
     Benchmarks for MiniBatchKMeans.
     """
 
-    param_names = ['representation', 'init']
-    params = (['dense', 'sparse'], ['random', 'k-means++'])
+    param_names = ["representation", "init"]
+    params = (["dense", "sparse"], ["random", "k-means++"])
 
     def setup_cache(self):
         super().setup_cache()
 
     def make_data(self, params):
         representation, init = params
 
-        if representation == 'sparse':
+        if representation == "sparse":
             data = _20newsgroups_highdim_dataset()
         else:
             data = _blobs_dataset(n_clusters=20)
@@ -76,25 +78,27 @@ def make_data(self, params):
     def make_estimator(self, params):
         representation, init = params
 
-        max_iter = 5 if representation == 'sparse' else 2
+        max_iter = 5 if representation == "sparse" else 2
 
-        estimator = MiniBatchKMeans(n_clusters=20,
-                                    init=init,
-                                    n_init=1,
-                                    max_iter=max_iter,
-                                    batch_size=1000,
-                                    max_no_improvement=None,
-                                    compute_labels=False,
-                                    random_state=0)
+        estimator = MiniBatchKMeans(
+            n_clusters=20,
+            init=init,
+            n_init=1,
+            max_iter=max_iter,
+            batch_size=1000,
+            max_no_improvement=None,
+            compute_labels=False,
+            random_state=0,
+        )
 
         return estimator
 
     def make_scorers(self):
-        self.train_scorer = (
-            lambda _, __: neg_mean_inertia(self.X,
-                                           self.estimator.predict(self.X),
-                                           self.estimator.cluster_centers_))
-        self.test_scorer = (
-            lambda _, __: neg_mean_inertia(self.X_val,
-                                           self.estimator.predict(self.X_val),
-                                           self.estimator.cluster_centers_))
+        self.train_scorer = lambda _, __: neg_mean_inertia(
+            self.X, self.estimator.predict(self.X), self.estimator.cluster_centers_
+        )
+        self.test_scorer = lambda _, __: neg_mean_inertia(
+            self.X_val,
+            self.estimator.predict(self.X_val),
+            self.estimator.cluster_centers_,
+        )

asv_benchmarks/benchmarks/common.py

@@ -14,86 +14,102 @@ def get_from_config():
     """Get benchmarks configuration from the config.json file"""
     current_path = Path(__file__).resolve().parent
 
-    config_path = current_path / 'config.json'
-    with open(config_path, 'r') as config_file:
-        config_file = ''.join(line for line in config_file
-                              if line and '//' not in line)
+    config_path = current_path / "config.json"
+    with open(config_path, "r") as config_file:
+        config_file = "".join(line for line in config_file if line and "//" not in line)
         config = json.loads(config_file)
 
-    profile = os.getenv('SKLBENCH_PROFILE', config['profile'])
+    profile = os.getenv("SKLBENCH_PROFILE", config["profile"])
 
-    n_jobs_vals_env = os.getenv('SKLBENCH_NJOBS')
+    n_jobs_vals_env = os.getenv("SKLBENCH_NJOBS")
     if n_jobs_vals_env:
         n_jobs_vals = eval(n_jobs_vals_env)
     else:
-        n_jobs_vals = config['n_jobs_vals']
+        n_jobs_vals = config["n_jobs_vals"]
     if not n_jobs_vals:
         n_jobs_vals = list(range(1, 1 + cpu_count()))
 
-    cache_path = current_path / 'cache'
+    cache_path = current_path / "cache"
     cache_path.mkdir(exist_ok=True)
-    (cache_path / 'estimators').mkdir(exist_ok=True)
-    (cache_path / 'tmp').mkdir(exist_ok=True)
+    (cache_path / "estimators").mkdir(exist_ok=True)
+    (cache_path / "tmp").mkdir(exist_ok=True)
 
-    save_estimators = os.getenv('SKLBENCH_SAVE_ESTIMATORS',
-                                config['save_estimators'])
-    save_dir = os.getenv('ASV_COMMIT', 'new')[:8]
+    save_estimators = os.getenv("SKLBENCH_SAVE_ESTIMATORS", config["save_estimators"])
+    save_dir = os.getenv("ASV_COMMIT", "new")[:8]
 
     if save_estimators:
-        (cache_path / 'estimators' / save_dir).mkdir(exist_ok=True)
+        (cache_path / "estimators" / save_dir).mkdir(exist_ok=True)
 
-    base_commit = os.getenv('SKLBENCH_BASE_COMMIT', config['base_commit'])
+    base_commit = os.getenv("SKLBENCH_BASE_COMMIT", config["base_commit"])
 
-    bench_predict = os.getenv('SKLBENCH_PREDICT', config['bench_predict'])
-    bench_transform = os.getenv('SKLBENCH_TRANSFORM',
-                                config['bench_transform'])
+    bench_predict = os.getenv("SKLBENCH_PREDICT", config["bench_predict"])
+    bench_transform = os.getenv("SKLBENCH_TRANSFORM", config["bench_transform"])
 
-    return (profile, n_jobs_vals, save_estimators, save_dir, base_commit,
-            bench_predict, bench_transform)
+    return (
+        profile,
+        n_jobs_vals,
+        save_estimators,
+        save_dir,
+        base_commit,
+        bench_predict,
+        bench_transform,
+    )
 
 
 def get_estimator_path(benchmark, directory, params, save=False):
     """Get path of pickled fitted estimator"""
-    path = Path(__file__).resolve().parent / 'cache'
-    path = (path / 'estimators' / directory) if save else (path / 'tmp')
+    path = Path(__file__).resolve().parent / "cache"
+    path = (path / "estimators" / directory) if save else (path / "tmp")
 
-    filename = (benchmark.__class__.__name__
-                + '_estimator_' + '_'.join(list(map(str, params))) + '.pkl')
+    filename = (
+        benchmark.__class__.__name__
+        + "_estimator_"
+        + "_".join(list(map(str, params)))
+        + ".pkl"
+    )
 
     return path / filename
 
 
 def clear_tmp():
     """Clean the tmp directory"""
-    path = Path(__file__).resolve().parent / 'cache' / 'tmp'
+    path = Path(__file__).resolve().parent / "cache" / "tmp"
     for child in path.iterdir():
         child.unlink()
 
 
 class Benchmark(ABC):
     """Abstract base class for all the benchmarks"""
+
     timer = timeit.default_timer  # wall time
     processes = 1
     timeout = 500
 
-    (profile, n_jobs_vals, save_estimators, save_dir, base_commit,
-     bench_predict, bench_transform) = get_from_config()
-
-    if profile == 'fast':
+    (
+        profile,
+        n_jobs_vals,
+        save_estimators,
+        save_dir,
+        base_commit,
+        bench_predict,
+        bench_transform,
+    ) = get_from_config()
+
+    if profile == "fast":
         warmup_time = 0
         repeat = 1
         number = 1
         min_run_count = 1
-        data_size = 'small'
-    elif profile == 'regular':
+        data_size = "small"
+    elif profile == "regular":
         warmup_time = 1
         repeat = (3, 100, 30)
-        data_size = 'small'
-    elif profile == 'large_scale':
+        data_size = "small"
+    elif profile == "large_scale":
         warmup_time = 1
         repeat = 3
         number = 1
-        data_size = 'large'
+        data_size = "large"
 
     @property
     @abstractmethod
@@ -103,6 +119,7 @@ def params(self):
 
 class Estimator(ABC):
     """Abstract base class for all benchmarks of estimators"""
+
     @abstractmethod
     def make_data(self, params):
         """Return the dataset for a combination of parameters"""
@@ -112,8 +129,7 @@ def make_data(self, params):
 
     @abstractmethod
     def make_estimator(self, params):
-        """Return an instance of the estimator for a combination of parameters
-        """
+        """Return an instance of the estimator for a combination of parameters"""
         pass
 
     def skip(self, params):
@@ -137,9 +153,10 @@ def setup_cache(self):
 
             estimator.fit(X, y)
 
-            est_path = get_estimator_path(self, Benchmark.save_dir,
-                                          params, Benchmark.save_estimators)
-            with est_path.open(mode='wb') as f:
+            est_path = get_estimator_path(
+                self, Benchmark.save_dir, params, Benchmark.save_estimators
+            )
+            with est_path.open(mode="wb") as f:
                 pickle.dump(estimator, f)
 
     def setup(self, *params):
@@ -152,9 +169,10 @@ def setup(self, *params):
 
         self.X, self.X_val, self.y, self.y_val = self.make_data(params)
 
-        est_path = get_estimator_path(self, Benchmark.save_dir,
-                                      params, Benchmark.save_estimators)
-        with est_path.open(mode='rb') as f:
+        est_path = get_estimator_path(
+            self, Benchmark.save_dir, params, Benchmark.save_estimators
+        )
+        with est_path.open(mode="rb") as f:
             self.estimator = pickle.load(f)
 
         self.make_scorers()
@@ -166,14 +184,14 @@ def peakmem_fit(self, *args):
         self.estimator.fit(self.X, self.y)
 
     def track_train_score(self, *args):
-        if hasattr(self.estimator, 'predict'):
+        if hasattr(self.estimator, "predict"):
             y_pred = self.estimator.predict(self.X)
         else:
             y_pred = None
         return float(self.train_scorer(self.y, y_pred))
 
     def track_test_score(self, *args):
-        if hasattr(self.estimator, 'predict'):
+        if hasattr(self.estimator, "predict"):
             y_val_pred = self.estimator.predict(self.X_val)
         else:
             y_val_pred = None
@@ -182,18 +200,20 @@ def track_test_score(self, *args):
 
 class Predictor(ABC):
     """Abstract base class for benchmarks of estimators implementing predict"""
+
     if Benchmark.bench_predict:
+
         def time_predict(self, *args):
             self.estimator.predict(self.X)
 
         def peakmem_predict(self, *args):
             self.estimator.predict(self.X)
 
         if Benchmark.base_commit is not None:
+
             def track_same_prediction(self, *args):
-                est_path = get_estimator_path(self, Benchmark.base_commit,
-                                              args, True)
-                with est_path.open(mode='rb') as f:
+                est_path = get_estimator_path(self, Benchmark.base_commit, args, True)
+                with est_path.open(mode="rb") as f:
                     estimator_base = pickle.load(f)
 
                 y_val_pred_base = estimator_base.predict(self.X_val)
@@ -208,20 +228,21 @@ def params(self):
 
 
 class Transformer(ABC):
-    """Abstract base class for benchmarks of estimators implementing transform
-    """
+    """Abstract base class for benchmarks of estimators implementing transform"""
+
     if Benchmark.bench_transform:
+
         def time_transform(self, *args):
             self.estimator.transform(self.X)
 
         def peakmem_transform(self, *args):
             self.estimator.transform(self.X)
 
         if Benchmark.base_commit is not None:
+
             def track_same_transform(self, *args):
-                est_path = get_estimator_path(self, Benchmark.base_commit,
-                                              args, True)
-                with est_path.open(mode='rb') as f:
+                est_path = get_estimator_path(self, Benchmark.base_commit, args, True)
+                with est_path.open(mode="rb") as f:
                     estimator_base = pickle.load(f)
 
                 X_val_t_base = estimator_base.transform(self.X_val)