Black

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,4 +2,5 @@
 
  - [ ] Closes #xxxx
  - [ ] Tests added
+ - [ ] Passes `black .` & `flake8`
  - [ ] Fully documented, including `whats-new.rst` for all changes and `api.rst` for new API

.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+# https://pre-commit.com/
+# https://github.com/python/black#version-control-integration
+repos:
+  - repo: https://github.com/python/black
+    rev: stable
+    hooks:
+      - id: black
+        language_version: python3.7
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.2.3
+    hooks:
+      - id: flake8

README.rst

@@ -11,6 +11,9 @@ xarray: N-D labeled arrays and datasets
   :target: https://pandas.pydata.org/speed/xarray/
 .. image:: https://img.shields.io/pypi/v/xarray.svg
    :target: https://pypi.python.org/pypi/xarray/
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/python/black
+
 
 **xarray** (formerly **xray**) is an open source project and Python package
 that makes working with labelled multi-dimensional arrays simple,

asv_bench/benchmarks/__init__.py

@@ -12,6 +12,7 @@ def decorator(func):
         func.param_names = names
         func.params = params
         return func
+
     return decorator
 
 
@@ -28,6 +29,7 @@ def randn(shape, frac_nan=None, chunks=None, seed=0):
         x = rng.standard_normal(shape)
     else:
         import dask.array as da
+
         rng = da.random.RandomState(seed)
         x = rng.standard_normal(shape, chunks=chunks)
 

asv_bench/benchmarks/combine.py

@@ -13,22 +13,22 @@ def setup(self):
         data = np.random.randn(t_size, x_size, y_size)
 
         self.dsA0 = xr.Dataset(
-            {'A': xr.DataArray(data, coords={'T': t},
-                               dims=('T', 'X', 'Y'))})
+            {"A": xr.DataArray(data, coords={"T": t}, dims=("T", "X", "Y"))}
+        )
         self.dsA1 = xr.Dataset(
-            {'A': xr.DataArray(data, coords={'T': t + t_size},
-                               dims=('T', 'X', 'Y'))})
+            {"A": xr.DataArray(data, coords={"T": t + t_size}, dims=("T", "X", "Y"))}
+        )
         self.dsB0 = xr.Dataset(
-            {'B': xr.DataArray(data, coords={'T': t},
-                               dims=('T', 'X', 'Y'))})
+            {"B": xr.DataArray(data, coords={"T": t}, dims=("T", "X", "Y"))}
+        )
         self.dsB1 = xr.Dataset(
-            {'B': xr.DataArray(data, coords={'T': t + t_size},
-                               dims=('T', 'X', 'Y'))})
+            {"B": xr.DataArray(data, coords={"T": t + t_size}, dims=("T", "X", "Y"))}
+        )
 
     def time_combine_manual(self):
         datasets = [[self.dsA0, self.dsA1], [self.dsB0, self.dsB1]]
 
-        xr.combine_manual(datasets, concat_dim=[None, 't'])
+        xr.combine_manual(datasets, concat_dim=[None, "t"])
 
     def time_auto_combine(self):
         """Also has to load and arrange t coordinate"""

asv_bench/benchmarks/dataarray_missing.py

@@ -14,9 +14,8 @@
 
 def make_bench_data(shape, frac_nan, chunks):
     vals = randn(shape, frac_nan)
-    coords = {'time': pd.date_range('2000-01-01', freq='D',
-                                    periods=shape[0])}
-    da = xr.DataArray(vals, dims=('time', 'x', 'y'), coords=coords)
+    coords = {"time": pd.date_range("2000-01-01", freq="D", periods=shape[0])}
+    da = xr.DataArray(vals, dims=("time", "x", "y"), coords=coords)
 
     if chunks is not None:
         da = da.chunk(chunks)
@@ -28,44 +27,50 @@ def time_interpolate_na(shape, chunks, method, limit):
     if chunks is not None:
         requires_dask()
     da = make_bench_data(shape, 0.1, chunks=chunks)
-    actual = da.interpolate_na(dim='time', method='linear', limit=limit)
+    actual = da.interpolate_na(dim="time", method="linear", limit=limit)
 
     if chunks is not None:
         actual = actual.compute()
 
 
-time_interpolate_na.param_names = ['shape', 'chunks', 'method', 'limit']
-time_interpolate_na.params = ([(3650, 200, 400), (100, 25, 25)],
-                              [None, {'x': 25, 'y': 25}],
-                              ['linear', 'spline', 'quadratic', 'cubic'],
-                              [None, 3])
+time_interpolate_na.param_names = ["shape", "chunks", "method", "limit"]
+time_interpolate_na.params = (
+    [(3650, 200, 400), (100, 25, 25)],
+    [None, {"x": 25, "y": 25}],
+    ["linear", "spline", "quadratic", "cubic"],
+    [None, 3],
+)
 
 
 def time_ffill(shape, chunks, limit):
 
     da = make_bench_data(shape, 0.1, chunks=chunks)
-    actual = da.ffill(dim='time', limit=limit)
+    actual = da.ffill(dim="time", limit=limit)
 
     if chunks is not None:
         actual = actual.compute()
 
 
-time_ffill.param_names = ['shape', 'chunks', 'limit']
-time_ffill.params = ([(3650, 200, 400), (100, 25, 25)],
-                     [None, {'x': 25, 'y': 25}],
-                     [None, 3])
+time_ffill.param_names = ["shape", "chunks", "limit"]
+time_ffill.params = (
+    [(3650, 200, 400), (100, 25, 25)],
+    [None, {"x": 25, "y": 25}],
+    [None, 3],
+)
 
 
 def time_bfill(shape, chunks, limit):
 
     da = make_bench_data(shape, 0.1, chunks=chunks)
-    actual = da.bfill(dim='time', limit=limit)
+    actual = da.bfill(dim="time", limit=limit)
 
     if chunks is not None:
         actual = actual.compute()
 
 
-time_bfill.param_names = ['shape', 'chunks', 'limit']
-time_bfill.params = ([(3650, 200, 400), (100, 25, 25)],
-                     [None, {'x': 25, 'y': 25}],
-                     [None, 3])
+time_bfill.param_names = ["shape", "chunks", "limit"]
+time_bfill.params = (
+    [(3650, 200, 400), (100, 25, 25)],
+    [None, {"x": 25, "y": 25}],
+    [None, 3],
+)