fix all flake8 issues and run pre-commit filters

Author: basnijholt

adaptive/_version.py

@@ -8,7 +8,7 @@
 
 from setuptools.command.sdist import sdist as sdist_orig
 
-Version = namedtuple('Version', ('release', 'dev', 'labels'))
+Version = namedtuple("Version", ("release", "dev", "labels"))
 
 # No public API
 __all__ = []
@@ -17,12 +17,12 @@
 package_name = os.path.basename(package_root)
 distr_root = os.path.dirname(package_root)
 
-STATIC_VERSION_FILE = '_static_version.py'
+STATIC_VERSION_FILE = "_static_version.py"
 
 
 def get_version(version_file=STATIC_VERSION_FILE):
     version_info = get_static_version_info(version_file)
-    version = version_info['version']
+    version = version_info["version"]
     if version == "__use_git__":
         version = get_version_from_git()
         if not version:
@@ -36,43 +36,45 @@ def get_version(version_file=STATIC_VERSION_FILE):
 
 def get_static_version_info(version_file=STATIC_VERSION_FILE):
     version_info = {}
-    with open(os.path.join(package_root, version_file), 'rb') as f:
+    with open(os.path.join(package_root, version_file), "rb") as f:
         exec(f.read(), {}, version_info)
     return version_info
 
 
 def version_is_from_git(version_file=STATIC_VERSION_FILE):
-    return get_static_version_info(version_file)['version'] == '__use_git__'
+    return get_static_version_info(version_file)["version"] == "__use_git__"
 
 
 def pep440_format(version_info):
     release, dev, labels = version_info
 
     version_parts = [release]
     if dev:
-        if release.endswith('-dev') or release.endswith('.dev'):
+        if release.endswith("-dev") or release.endswith(".dev"):
             version_parts.append(dev)
         else:  # prefer PEP440 over strict adhesion to semver
-            version_parts.append(f'.dev{dev}')
+            version_parts.append(f".dev{dev}")
 
     if labels:
-        version_parts.append('+')
+        version_parts.append("+")
         version_parts.append(".".join(labels))
 
     return "".join(version_parts)
 
 
 def get_version_from_git():
     try:
-        p = subprocess.Popen(['git', 'rev-parse', '--show-toplevel'],
-                             cwd=distr_root,
-                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p = subprocess.Popen(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=distr_root,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
     except OSError:
         return
     if p.wait() != 0:
         return
-    if not os.path.samefile(p.communicate()[0].decode().rstrip('\n'),
-                            distr_root):
+    if not os.path.samefile(p.communicate()[0].decode().rstrip("\n"), distr_root):
         # The top-level directory of the current Git repository is not the same
         # as the root directory of the distribution: do not extract the
         # version from Git.
@@ -81,12 +83,14 @@ def get_version_from_git():
     # git describe --first-parent does not take into account tags from branches
     # that were merged-in. The '--long' flag gets us the 'dev' version and
     # git hash, '--always' returns the git hash even if there are no tags.
-    for opts in [['--first-parent'], []]:
+    for opts in [["--first-parent"], []]:
         try:
             p = subprocess.Popen(
-                ['git', 'describe', '--long', '--always'] + opts,
+                ["git", "describe", "--long", "--always"] + opts,
                 cwd=distr_root,
-                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
         except OSError:
             return
         if p.wait() == 0:
@@ -97,17 +101,17 @@ def get_version_from_git():
     description = (
         p.communicate()[0]
         .decode()
-        .strip('v')  # Tags can have a leading 'v', but the version should not
-        .rstrip('\n')
-        .rsplit('-', 2)  # Split the latest tag, commits since tag, and hash
+        .strip("v")  # Tags can have a leading 'v', but the version should not
+        .rstrip("\n")
+        .rsplit("-", 2)  # Split the latest tag, commits since tag, and hash
     )
 
     try:
         release, dev, git = description
     except ValueError:  # No tags, only the git hash
         # prepend 'g' to match with format returned by 'git describe'
-        git = 'g{}'.format(*description)
-        release = 'unknown'
+        git = "g{}".format(*description)
+        release = "unknown"
         dev = None
 
     labels = []
@@ -117,12 +121,12 @@ def get_version_from_git():
         labels.append(git)
 
     try:
-        p = subprocess.Popen(['git', 'diff', '--quiet'], cwd=distr_root)
+        p = subprocess.Popen(["git", "diff", "--quiet"], cwd=distr_root)
     except OSError:
-        labels.append('confused')  # This should never happen.
+        labels.append("confused")  # This should never happen.
     else:
         if p.wait() == 1:
-            labels.append('dirty')
+            labels.append("dirty")
 
     return Version(release, dev, labels)
 
@@ -134,25 +138,25 @@ def get_version_from_git():
 #       if it is not tagged.
 def get_version_from_git_archive(version_info):
     try:
-        refnames = version_info['refnames']
-        git_hash = version_info['git_hash']
+        refnames = version_info["refnames"]
+        git_hash = version_info["git_hash"]
     except KeyError:
         # These fields are not present if we are running from an sdist.
         # Execution should never reach here, though
         return None
 
-    if git_hash.startswith('$Format') or refnames.startswith('$Format'):
+    if git_hash.startswith("$Format") or refnames.startswith("$Format"):
         # variables not expanded during 'git archive'
         return None
 
-    VTAG = 'tag: v'
+    VTAG = "tag: v"
     refs = {r.strip() for r in refnames.split(",")}
-    version_tags = {r[len(VTAG):] for r in refs if r.startswith(VTAG)}
+    version_tags = {r[len(VTAG) :] for r in refs if r.startswith(VTAG)}
     if version_tags:
         release, *_ = sorted(version_tags)  # prefer e.g. "2.0" over "2.0rc1"
         return Version(release, dev=None, labels=None)
     else:
-        return Version('unknown', dev=None, labels=[f'g{git_hash}'])
+        return Version("unknown", dev=None, labels=[f"g{git_hash}"])
 
 
 __version__ = get_version()
@@ -162,30 +166,31 @@ def get_version_from_git_archive(version_info):
 # which can be used from setup.py. The 'package_name' and
 # '__version__' module globals are used (but not modified).
 
+
 def _write_version(fname):
     # This could be a hard link, so try to delete it first.  Is there any way
     # to do this atomically together with opening?
     try:
         os.remove(fname)
     except OSError:
         pass
-    with open(fname, 'w') as f:
-        f.write("# This file has been created by setup.py.\n"
-                "version = '{}'\n".format(__version__))
+    with open(fname, "w") as f:
+        f.write(
+            "# This file has been created by setup.py.\n"
+            "version = '{}'\n".format(__version__)
+        )
 
 
 class _build_py(build_py_orig):
     def run(self):
         super().run()
-        _write_version(os.path.join(self.build_lib, package_name,
-                                    STATIC_VERSION_FILE))
+        _write_version(os.path.join(self.build_lib, package_name, STATIC_VERSION_FILE))
 
 
 class _sdist(sdist_orig):
     def make_release_tree(self, base_dir, files):
         super().make_release_tree(base_dir, files)
-        _write_version(os.path.join(base_dir, package_name,
-                                    STATIC_VERSION_FILE))
+        _write_version(os.path.join(base_dir, package_name, STATIC_VERSION_FILE))
 
 
 cmdclass = dict(sdist=_sdist, build_py=_build_py)

adaptive/learner/average_learner.py

@@ -34,7 +34,7 @@ class AverageLearner(BaseLearner):
 
     def __init__(self, function, atol=None, rtol=None):
         if atol is None and rtol is None:
-            raise Exception('At least one of `atol` and `rtol` should be set.')
+            raise Exception("At least one of `atol` and `rtol` should be set.")
         if atol is None:
             atol = np.inf
         if rtol is None:
@@ -58,9 +58,11 @@ def ask(self, n, tell_pending=True):
 
         if any(p in self.data or p in self.pending_points for p in points):
             # This means some of the points `< self.n_requested` do not exist.
-            points = list(set(range(self.n_requested + n))
-                          - set(self.data)
-                          - set(self.pending_points))[:n]
+            points = list(
+                set(range(self.n_requested + n))
+                - set(self.data)
+                - set(self.pending_points)
+            )[:n]
 
         loss_improvements = [self._loss_improvement(n) / n] * n
         if tell_pending:
@@ -76,7 +78,7 @@ def tell(self, n, value):
         self.data[n] = value
         self.pending_points.discard(n)
         self.sum_f += value
-        self.sum_f_sq += value**2
+        self.sum_f_sq += value ** 2
         self.npoints += 1
 
     def tell_pending(self, n):
@@ -94,7 +96,7 @@ def std(self):
         n = self.npoints
         if n < 2:
             return np.inf
-        numerator = self.sum_f_sq - n * self.mean**2
+        numerator = self.sum_f_sq - n * self.mean ** 2
         if numerator < 0:
             # in this case the numerator ~ -1e-15
             return 0
@@ -109,8 +111,9 @@ def loss(self, real=True, *, n=None):
         if n < 2:
             return np.inf
         standard_error = self.std / sqrt(n)
-        return max(standard_error / self.atol,
-                   standard_error / abs(self.mean) / self.rtol)
+        return max(
+            standard_error / self.atol, standard_error / abs(self.mean) / self.rtol
+        )
 
     def _loss_improvement(self, n):
         loss = self.loss()

adaptive/learner/balancing_learner.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 
-import os.path
 from collections import defaultdict
 from collections.abc import Iterable
 from contextlib import suppress
@@ -69,7 +68,7 @@ class BalancingLearner(BaseLearner):
     behave in an undefined way. Change the `strategy` in that case.
     """
 
-    def __init__(self, learners, *, cdims=None, strategy='loss_improvements'):
+    def __init__(self, learners, *, cdims=None, strategy="loss_improvements"):
         self.learners = learners
 
         # Naively we would make 'function' a method, but this causes problems
@@ -83,8 +82,9 @@ def __init__(self, learners, *, cdims=None, strategy='loss_improvements'):
         self._cdims_default = cdims
 
         if len({learner.__class__ for learner in self.learners}) > 1:
-            raise TypeError('A BalacingLearner can handle only one type'
-                            ' of learners.')
+            raise TypeError(
+                "A BalacingLearner can handle only one type" " of learners."
+            )
 
         self.strategy = strategy
 
@@ -101,16 +101,17 @@ def strategy(self):
     @strategy.setter
     def strategy(self, strategy):
         self._strategy = strategy
-        if strategy == 'loss_improvements':
+        if strategy == "loss_improvements":
             self._ask_and_tell = self._ask_and_tell_based_on_loss_improvements
-        elif strategy == 'loss':
+        elif strategy == "loss":
             self._ask_and_tell = self._ask_and_tell_based_on_loss
-        elif strategy == 'npoints':
+        elif strategy == "npoints":
             self._ask_and_tell = self._ask_and_tell_based_on_npoints
         else:
             raise ValueError(
                 'Only strategy="loss_improvements", strategy="loss", or'
-                ' strategy="npoints" is implemented.')
+                ' strategy="npoints" is implemented.'
+            )
 
     def _ask_and_tell_based_on_loss_improvements(self, n):
         selected = []  # tuples ((learner_index, point), loss_improvement)
@@ -120,17 +121,14 @@ def _ask_and_tell_based_on_loss_improvements(self, n):
             for index, learner in enumerate(self.learners):
                 # Take the points from the cache
                 if index not in self._ask_cache:
-                    self._ask_cache[index] = learner.ask(
-                        n=1, tell_pending=False)
+                    self._ask_cache[index] = learner.ask(n=1, tell_pending=False)
                 points, loss_improvements = self._ask_cache[index]
                 to_select.append(
-                    ((index, points[0]),
-                     (loss_improvements[0], -total_points[index]))
+                    ((index, points[0]), (loss_improvements[0], -total_points[index]))
                 )
 
             # Choose the optimal improvement.
-            (index, point), (loss_improvement, _) = max(
-                to_select, key=itemgetter(1))
+            (index, point), (loss_improvement, _) = max(to_select, key=itemgetter(1))
             total_points[index] += 1
             selected.append(((index, point), loss_improvement))
             self.tell_pending((index, point))
@@ -139,13 +137,12 @@ def _ask_and_tell_based_on_loss_improvements(self, n):
         return points, loss_improvements
 
     def _ask_and_tell_based_on_loss(self, n):
-        selected = []   # tuples ((learner_index, point), loss_improvement)
+        selected = []  # tuples ((learner_index, point), loss_improvement)
         total_points = [l.npoints + len(l.pending_points) for l in self.learners]
         for _ in range(n):
             losses = self._losses(real=False)
             index, _ = max(
-                enumerate(zip(losses, (-n for n in total_points))),
-                key=itemgetter(1)
+                enumerate(zip(losses, (-n for n in total_points))), key=itemgetter(1)
             )
             total_points[index] += 1
 
@@ -257,7 +254,7 @@ def plot(self, cdims=None, plotter=None, dynamic=True):
         cdims = cdims or self._cdims_default
 
         if cdims is None:
-            cdims = [{'i': i} for i in range(len(self.learners))]
+            cdims = [{"i": i} for i in range(len(self.learners))]
         elif not isinstance(cdims[0], dict):
             # Normalize the format
             keys, values_list = cdims

adaptive/learner/base_learner.py

@@ -53,9 +53,11 @@ def uses_nth_neighbors(n):
     ...
     ...     return loss
     """
+
     def _wrapped(loss_per_interval):
         loss_per_interval.nth_neighbors = n
         return loss_per_interval
+
     return _wrapped