merge the style changes from stable-0.8

Author: basnijholt

.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+-   repo: https://github.com/ambv/black
+    rev: 19.3b0
+    hooks:
+    - id: black
+      language_version: python3.7
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.1.0
+    hooks:
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://gitlab.com/pycqa/flake8
+    rev: 3.7.4
+    hooks:
+    -   id: flake8
+        args: ['--max-line-length=500', '--ignore=E203,E266,E501,W503', '--max-complexity=18', '--select=B,C,E,F,W,T4,B9']

README.rst

@@ -113,6 +113,14 @@ please setup the git filter by executing
 
 in the repository.
 
+We implement several other checks in order to maintain a consistent code style. We do this using [pre-commit`](https://pre-commit.com), execute
+
+.. code:: bash
+
+    pre-commit install
+
+in the repository.
+
 Credits
 -------
 

adaptive/__init__.py

@@ -4,17 +4,52 @@
 
 from adaptive import learner, runner, utils
 from adaptive._version import __version__
-from adaptive.learner import (AverageLearner, BalancingLearner, BaseLearner,
-                              DataSaver, IntegratorLearner, Learner1D,
-                              Learner2D, LearnerND, make_datasaver)
-from adaptive.notebook_integration import (active_plotting_tasks, live_plot,
-                                           notebook_extension)
+from adaptive.learner import (
+    AverageLearner,
+    BalancingLearner,
+    BaseLearner,
+    DataSaver,
+    IntegratorLearner,
+    Learner1D,
+    Learner2D,
+    LearnerND,
+    make_datasaver,
+)
+from adaptive.notebook_integration import (
+    active_plotting_tasks,
+    live_plot,
+    notebook_extension,
+)
 from adaptive.runner import AsyncRunner, BlockingRunner, Runner
 
+__all__ = [
+    "learner",
+    "runner",
+    "utils",
+    "__version__",
+    "AverageLearner",
+    "BalancingLearner",
+    "BaseLearner",
+    "DataSaver",
+    "IntegratorLearner",
+    "Learner1D",
+    "Learner2D",
+    "LearnerND",
+    "make_datasaver",
+    "active_plotting_tasks",
+    "live_plot",
+    "notebook_extension",
+    "AsyncRunner",
+    "BlockingRunner",
+    "Runner",
+]
+
 with suppress(ImportError):
     # Only available if 'scikit-optimize' is installed
-    from adaptive.learner import SKOptLearner
+    from adaptive.learner import SKOptLearner  # noqa: F401
 
+    __all__.append("SKOptLearner")
 
-del _version
-del notebook_integration  # to avoid confusion with `notebook_extension`
+# to avoid confusion with `notebook_extension` and `__version__`
+del _version  # noqa: F821
+del notebook_integration  # noqa: F821

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/__init__.py

@@ -11,6 +11,20 @@
 from adaptive.learner.learner2D import Learner2D
 from adaptive.learner.learnerND import LearnerND
 
+__all__ = [
+    "AverageLearner",
+    "BalancingLearner",
+    "BaseLearner",
+    "DataSaver",
+    "make_datasaver",
+    "IntegratorLearner",
+    "Learner1D",
+    "Learner2D",
+    "LearnerND",
+]
+
 with suppress(ImportError):
     # Only available if 'scikit-optimize' is installed
-    from adaptive.learner.skopt_learner import SKOptLearner
+    from adaptive.learner.skopt_learner import SKOptLearner  # noqa: F401
+
+    __all__.append("SKOptLearner")

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()