Run pre-commit hooks for the first time

Author: lpsinger

astropy_healpix/__init__.py

@@ -7,7 +7,7 @@
 # Packages may add whatever they like to this file, but
 # should keep this content at the top.
 # ----------------------------------------------------------------------------
-from ._astropy_init import *   # noqa
+from ._astropy_init import *  # noqa
 # ----------------------------------------------------------------------------
 
 from .high_level import *  # noqa

astropy_healpix/_astropy_init.py

@@ -1,13 +1,14 @@
 # Licensed under a 3-clause BSD style license - see LICENSE.rst
 import os
 
-__all__ = ['__version__', 'test']
+__all__ = ["__version__", "test"]
 
 try:
     from .version import version as __version__
 except ImportError:
-    __version__ = ''
+    __version__ = ""
 
 # Create the test function for self test
 from astropy.tests.runner import TestRunner
+
 test = TestRunner.make_test_runner_in(os.path.dirname(__file__))

astropy_healpix/bench.py

@@ -32,7 +32,7 @@
 
 
 # Copied from https://github.com/kwgoodman/bottleneck/blob/master/bottleneck/benchmark/autotimeit.py
-def autotimeit(stmt, setup='pass', repeat=3, mintime=0.2):
+def autotimeit(stmt, setup="pass", repeat=3, mintime=0.2):
     timer = timeit.Timer(stmt, setup)
     number, time1 = autoscaler(timer, mintime)
     time2 = timer.repeat(repeat=repeat - 1, number=number)
@@ -47,89 +47,105 @@ def autoscaler(timer, mintime):
         if time > mintime:
             return number, time
         number *= 10
-    raise RuntimeError('function is too fast to test')
+    raise RuntimeError("function is too fast to test")
 
 
 def get_import(package, function):
-    if package == 'astropy_healpix':
-        return f'from astropy_healpix.healpy import {function}'
+    if package == "astropy_healpix":
+        return f"from astropy_healpix.healpy import {function}"
     else:
-        return f'from healpy import {function}'
+        return f"from healpy import {function}"
 
 
 def bench_pix2ang(size=None, nside=None, nest=None, package=None, fast=False):
-    setup = '\n'.join([
-        get_import(package, 'pix2ang'),
-        'import numpy as np',
-        f'nside={nside}',
-        f'ipix=(np.random.random({size}) * 12 * nside ** 2).astype(np.int64)',
-        f'nest={nest}'])
-
-    stmt = 'pix2ang(nside, ipix, nest)'
+    setup = "\n".join(
+        [
+            get_import(package, "pix2ang"),
+            "import numpy as np",
+            f"nside={nside}",
+            f"ipix=(np.random.random({size}) * 12 * nside ** 2).astype(np.int64)",
+            f"nest={nest}",
+        ]
+    )
+
+    stmt = "pix2ang(nside, ipix, nest)"
 
     return autotimeit(stmt=stmt, setup=setup, repeat=1, mintime=0 if fast else 0.1)
 
 
 def bench_ang2pix(size=None, nside=None, nest=None, package=None, fast=False):
-    setup = '\n'.join([
-        get_import(package, 'ang2pix'),
-        'import numpy as np',
-        f'nside={nside}',
-        f'lon=360 * np.random.random({size})',
-        f'lat=180 * np.random.random({size}) - 90',
-        f'nest={nest}'])
-
-    stmt = 'ang2pix(nside, lon, lat, nest, lonlat=True)'
+    setup = "\n".join(
+        [
+            get_import(package, "ang2pix"),
+            "import numpy as np",
+            f"nside={nside}",
+            f"lon=360 * np.random.random({size})",
+            f"lat=180 * np.random.random({size}) - 90",
+            f"nest={nest}",
+        ]
+    )
+
+    stmt = "ang2pix(nside, lon, lat, nest, lonlat=True)"
 
     return autotimeit(stmt=stmt, setup=setup, repeat=1, mintime=0 if fast else 0.1)
 
 
 def bench_nest2ring(size=None, nside=None, package=None, fast=False):
-    setup = '\n'.join([
-        get_import(package, 'nest2ring'),
-        'import numpy as np',
-        f'nside={nside}',
-        f'ipix=(np.random.random({size}) * 12 * nside ** 2).astype(np.int64)'])
+    setup = "\n".join(
+        [
+            get_import(package, "nest2ring"),
+            "import numpy as np",
+            f"nside={nside}",
+            f"ipix=(np.random.random({size}) * 12 * nside ** 2).astype(np.int64)",
+        ]
+    )
 
-    stmt = 'nest2ring(nside, ipix)'
+    stmt = "nest2ring(nside, ipix)"
 
     return autotimeit(stmt=stmt, setup=setup, repeat=1, mintime=0 if fast else 0.1)
 
 
 def bench_ring2nest(size=None, nside=None, package=None, fast=False):
-    setup = '\n'.join([
-        get_import(package, 'ring2nest'),
-        'import numpy as np',
-        f'nside={nside}',
-        f'ipix=(np.random.random({size}) * 12 * nside ** 2).astype(np.int64)'])
+    setup = "\n".join(
+        [
+            get_import(package, "ring2nest"),
+            "import numpy as np",
+            f"nside={nside}",
+            f"ipix=(np.random.random({size}) * 12 * nside ** 2).astype(np.int64)",
+        ]
+    )
 
-    stmt = 'ring2nest(nside, ipix)'
+    stmt = "ring2nest(nside, ipix)"
 
     return autotimeit(stmt=stmt, setup=setup, repeat=1, mintime=0 if fast else 0.1)
 
 
-def bench_get_interp_weights(size=None, nside=None, nest=None, package=None, fast=False):
-    setup = '\n'.join([
-        get_import(package, 'get_interp_weights'),
-        'import numpy as np',
-        f'nside={nside}',
-        f'lon=360 * np.random.random({size})',
-        f'lat=180 * np.random.random({size}) - 90',
-        f'nest={nest}'])
+def bench_get_interp_weights(
+    size=None, nside=None, nest=None, package=None, fast=False
+):
+    setup = "\n".join(
+        [
+            get_import(package, "get_interp_weights"),
+            "import numpy as np",
+            f"nside={nside}",
+            f"lon=360 * np.random.random({size})",
+            f"lat=180 * np.random.random({size}) - 90",
+            f"nest={nest}",
+        ]
+    )
 
-    stmt = 'get_interp_weights(nside, lon, lat, nest=nest, lonlat=True)'
+    stmt = "get_interp_weights(nside, lon, lat, nest=nest, lonlat=True)"
 
     return autotimeit(stmt=stmt, setup=setup, repeat=1, mintime=0 if fast else 0.1)
 
 
 def run_single(name, benchmark, fast=False, **kwargs):
-
-    time_self = benchmark(package='astropy_healpix', fast=fast, **kwargs)
+    time_self = benchmark(package="astropy_healpix", fast=fast, **kwargs)
     results_single = dict(function=name, time_self=time_self, **kwargs)
 
     if HEALPY_INSTALLED:
-        time_healpy = bench_ang2pix(package='healpy', fast=fast, **kwargs)
-        results_single['time_healpy'] = time_healpy
+        time_healpy = bench_ang2pix(package="healpy", fast=fast, **kwargs)
+        results_single["time_healpy"] = time_healpy
 
     return results_single
 
@@ -146,60 +162,99 @@ def bench_run(fast=False):
     for nest in [True, False]:
         for size in SIZES:
             for nside in [1, 128]:
-                results.append(run_single('pix2ang', bench_pix2ang, fast=fast,
-                                          size=size, nside=nside, nest=nest))
+                results.append(
+                    run_single(
+                        "pix2ang",
+                        bench_pix2ang,
+                        fast=fast,
+                        size=size,
+                        nside=nside,
+                        nest=nest,
+                    )
+                )
 
     for nest in [True, False]:
         for size in SIZES:
             for nside in [1, 128]:
-                results.append(run_single('ang2pix', bench_ang2pix, fast=fast,
-                                          size=size, nside=nside, nest=nest))
+                results.append(
+                    run_single(
+                        "ang2pix",
+                        bench_ang2pix,
+                        fast=fast,
+                        size=size,
+                        nside=nside,
+                        nest=nest,
+                    )
+                )
 
     for size in SIZES:
         for nside in [1, 128]:
-            results.append(run_single('nest2ring', bench_nest2ring, fast=fast,
-                                      size=size, nside=nside))
+            results.append(
+                run_single(
+                    "nest2ring", bench_nest2ring, fast=fast, size=size, nside=nside
+                )
+            )
 
     for size in SIZES:
         for nside in [1, 128]:
-            results.append(run_single('ring2nest', bench_ring2nest, fast=fast,
-                                      size=size, nside=nside))
+            results.append(
+                run_single(
+                    "ring2nest", bench_ring2nest, fast=fast, size=size, nside=nside
+                )
+            )
 
     for nest in [True, False]:
         for size in SIZES:
             for nside in [1, 128]:
-                results.append(run_single('get_interp_weights', bench_get_interp_weights,
-                                          fast=fast, size=size,
-                                          nside=nside, nest=nest))
+                results.append(
+                    run_single(
+                        "get_interp_weights",
+                        bench_get_interp_weights,
+                        fast=fast,
+                        size=size,
+                        nside=nside,
+                        nest=nest,
+                    )
+                )
 
     return results
 
 
 def bench_report(results):
     """Print a report for given benchmark results to the console."""
 
-    table = Table(names=['function', 'nest', 'nside', 'size',
-                         'time_healpy', 'time_self', 'ratio'],
-                  dtype=['S20', bool, int, int, float, float, float], masked=True)
+    table = Table(
+        names=[
+            "function",
+            "nest",
+            "nside",
+            "size",
+            "time_healpy",
+            "time_self",
+            "ratio",
+        ],
+        dtype=["S20", bool, int, int, float, float, float],
+        masked=True,
+    )
     for row in results:
         table.add_row(row)
 
-    table['time_self'].format = '10.7f'
+    table["time_self"].format = "10.7f"
 
     if HEALPY_INSTALLED:
-        table['ratio'] = table['time_self'] / table['time_healpy']
-        table['time_healpy'].format = '10.7f'
-        table['ratio'].format = '7.2f'
+        table["ratio"] = table["time_self"] / table["time_healpy"]
+        table["time_healpy"].format = "10.7f"
+        table["ratio"].format = "7.2f"
 
     table.pprint(max_lines=-1)
 
 
 def main(fast=False):
     """Run all benchmarks and print report to the console."""
-    print('Running benchmarks...\n')
+    print("Running benchmarks...\n")
     results = bench_run(fast=fast)
     bench_report(results)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

astropy_healpix/conftest.py

@@ -13,6 +13,7 @@
 
 try:
     from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS
+
     ASTROPY_HEADER = True
 except ImportError:
     ASTROPY_HEADER = False
@@ -27,24 +28,24 @@ def pytest_configure(config):
 
     """
     if ASTROPY_HEADER:
-
         config.option.astropy_header = True
 
         # Customize the following lines to add/remove entries from the list of
         # packages for which version numbers are displayed when running the tests.
-        PYTEST_HEADER_MODULES.pop('h5py', None)
-        PYTEST_HEADER_MODULES.pop('Pandas', None)
-        PYTEST_HEADER_MODULES['Astropy'] = 'astropy'
-        PYTEST_HEADER_MODULES['healpy'] = 'healpy'
+        PYTEST_HEADER_MODULES.pop("h5py", None)
+        PYTEST_HEADER_MODULES.pop("Pandas", None)
+        PYTEST_HEADER_MODULES["Astropy"] = "astropy"
+        PYTEST_HEADER_MODULES["healpy"] = "healpy"
 
         from . import __version__
+
         packagename = os.path.basename(os.path.dirname(__file__))
         TESTED_VERSIONS[packagename] = __version__
 
     # Set the Numpy print style to a fixed version to make doctest outputs
     # reproducible.
     try:
-        np.set_printoptions(legacy='1.13')
+        np.set_printoptions(legacy="1.13")
     except TypeError:
         # On older versions of Numpy, the unrecognized 'legacy' option will
         # raise a TypeError.