Xarray is now flake8-clean with dask settings

Author: Zac-HD

xarray/backends/zarr.py

@@ -71,8 +71,8 @@ def _replace_slices_with_arrays(key, shape):
             slice_count += 1
         else:
             assert isinstance(k, np.ndarray)
-            k = k[(slice(None),) * array_subspace_size
-                  + (np.newaxis,) * num_slices]
+            k = k[(slice(None),) * array_subspace_size +
+                  (np.newaxis,) * num_slices]
         new_key.append(k)
     return tuple(new_key)
 

xarray/core/dataarray.py

@@ -19,7 +19,6 @@
 from .accessors import DatetimeAccessor
 from .alignment import align, reindex_like_indexers
 from .common import AbstractArray, BaseDataObject
-from .computation import apply_ufunc
 from .coordinates import (DataArrayCoordinates, LevelCoordinatesSource,
                           Indexes, assert_coordinate_consistent,
                           remap_label_indexers)

xarray/plot/plot.py

@@ -206,7 +206,7 @@ def line(darray, *args, **kwargs):
         xlabel, = darray.dims
         if x is not None and xlabel != x:
             raise ValueError('Input does not have specified dimension'
-                             + ' {!r}'.format(x))
+                             ' {!r}'.format(x))
 
         x = darray.coords[xlabel]
 

xarray/tests/test_backends.py

@@ -1195,8 +1195,8 @@ def test_hidden_zarr_keys(self):
             # JSON only has a single array type, which maps to list in Python.
             # In contrast, dims in xarray is always a tuple.
             for var in expected.variables.keys():
-                assert (zarr_group[var].attrs[self.DIMENSION_KEY]
-                        == list(expected[var].dims))
+                assert (zarr_group[var].attrs[self.DIMENSION_KEY] ==
+                        list(expected[var].dims))
 
             with xr.decode_cf(store) as actual:
                 # make sure it is hidden
@@ -2426,7 +2426,7 @@ def test_ENVI_tags(self):
         with create_tmp_file(suffix='.dat') as tmp_file:
             # data
             nx, ny, nz = 4, 3, 3
-            data = np.arange(nx*ny*nz,
+            data = np.arange(nx * ny * nz,
                              dtype=rasterio.float32).reshape(nz, ny, nx)
             transform = from_origin(5000, 80000, 1000, 2000.)
             with rasterio.open(
@@ -2437,25 +2437,22 @@ def test_ENVI_tags(self):
                     transform=transform,
                     dtype=rasterio.float32) as s:
                 s.update_tags(
-                        ns='ENVI',
-                        description='{Tagged file}',
-                        wavelength='{123.000000, 234.234000, 345.345678}',
-                        fwhm='{1.000000, 0.234000, 0.000345}')
+                    ns='ENVI',
+                    description='{Tagged file}',
+                    wavelength='{123.000000, 234.234000, 345.345678}',
+                    fwhm='{1.000000, 0.234000, 0.000345}')
                 s.write(data)
                 dx, dy = s.res[0], -s.res[1]
 
             # Tests
-            expected = DataArray(data, dims=('band', 'y', 'x'),
-                                 coords={
-                                     'band': [1, 2, 3],
-                                     'y': -np.arange(ny) * 2000 + 80000 + dy/2,
-                                     'x': np.arange(nx) * 1000 + 5000 + dx/2,
-                                     'wavelength': (
-                                         'band',
-                                         np.array([123, 234.234, 345.345678])),
-                                     'fwhm': (
-                                         'band',
-                                         np.array([1, 0.234, 0.000345]))})
+            coords = {
+                'band': [1, 2, 3],
+                'y': -np.arange(ny) * 2000 + 80000 + dy / 2,
+                'x': np.arange(nx) * 1000 + 5000 + dx / 2,
+                'wavelength': ('band', np.array([123, 234.234, 345.345678])),
+                'fwhm': ('band', np.array([1, 0.234, 0.000345])),
+            }
+            expected = DataArray(data, dims=('band', 'y', 'x'), coords=coords)
 
             with xr.open_rasterio(tmp_file) as rioda:
                 assert_allclose(rioda, expected)

xarray/tests/test_coding.py

@@ -1,11 +1,10 @@
 import numpy as np
-import pytest
 
 import xarray as xr
 from xarray.core.pycompat import suppress
 from xarray.coding import variables
 
-from . import requires_dask, raises_regex, assert_identical
+from . import requires_dask, assert_identical
 
 with suppress(ImportError):
     import dask.array as da

xarray/tests/test_coding_times.py

@@ -24,29 +24,29 @@ class TestDatetime(TestCase):
     def test_cf_datetime(self):
         import netCDF4 as nc4
         for num_dates, units in [
-                (np.arange(10), 'days since 2000-01-01'),
-                (np.arange(10).reshape(2, 5), 'days since 2000-01-01'),
-                (12300 + np.arange(5), 'hours since 1680-01-01 00:00:00'),
-                # here we add a couple minor formatting errors to test
-                # the robustness of the parsing algorithm.
-                (12300 + np.arange(5), 'hour since 1680-01-01  00:00:00'),
-                (12300 + np.arange(5), u'Hour  since 1680-01-01 00:00:00'),
-                (12300 + np.arange(5), ' Hour  since  1680-01-01 00:00:00 '),
-                (10, 'days since 2000-01-01'),
-                ([10], 'daYs  since 2000-01-01'),
-                ([[10]], 'days since 2000-01-01'),
-                ([10, 10], 'days since 2000-01-01'),
-                (np.array(10), 'days since 2000-01-01'),
-                (0, 'days since 1000-01-01'),
-                ([0], 'days since 1000-01-01'),
-                ([[0]], 'days since 1000-01-01'),
-                (np.arange(2), 'days since 1000-01-01'),
-                (np.arange(0, 100000, 20000), 'days since 1900-01-01'),
-                (17093352.0, 'hours since 1-1-1 00:00:0.0'),
-                ([0.5, 1.5], 'hours since 1900-01-01T00:00:00'),
-                (0, 'milliseconds since 2000-01-01T00:00:00'),
-                (0, 'microseconds since 2000-01-01T00:00:00'),
-                ]:
+            (np.arange(10), 'days since 2000-01-01'),
+            (np.arange(10).reshape(2, 5), 'days since 2000-01-01'),
+            (12300 + np.arange(5), 'hours since 1680-01-01 00:00:00'),
+            # here we add a couple minor formatting errors to test
+            # the robustness of the parsing algorithm.
+            (12300 + np.arange(5), 'hour since 1680-01-01  00:00:00'),
+            (12300 + np.arange(5), u'Hour  since 1680-01-01 00:00:00'),
+            (12300 + np.arange(5), ' Hour  since  1680-01-01 00:00:00 '),
+            (10, 'days since 2000-01-01'),
+            ([10], 'daYs  since 2000-01-01'),
+            ([[10]], 'days since 2000-01-01'),
+            ([10, 10], 'days since 2000-01-01'),
+            (np.array(10), 'days since 2000-01-01'),
+            (0, 'days since 1000-01-01'),
+            ([0], 'days since 1000-01-01'),
+            ([[0]], 'days since 1000-01-01'),
+            (np.arange(2), 'days since 1000-01-01'),
+            (np.arange(0, 100000, 20000), 'days since 1900-01-01'),
+            (17093352.0, 'hours since 1-1-1 00:00:0.0'),
+            ([0.5, 1.5], 'hours since 1900-01-01T00:00:00'),
+            (0, 'milliseconds since 2000-01-01T00:00:00'),
+            (0, 'microseconds since 2000-01-01T00:00:00'),
+        ]:
             for calendar in ['standard', 'gregorian', 'proleptic_gregorian']:
                 expected = _ensure_naive_tz(
                     nc4.num2date(num_dates, units, calendar))
@@ -224,12 +224,12 @@ def test_decode_non_standard_calendar_fallback(self):
     @requires_netCDF4
     def test_cf_datetime_nan(self):
         for num_dates, units, expected_list in [
-                ([np.nan], 'days since 2000-01-01', ['NaT']),
-                ([np.nan, 0], 'days since 2000-01-01',
-                 ['NaT', '2000-01-01T00:00:00Z']),
-                ([np.nan, 0, 1], 'days since 2000-01-01',
-                 ['NaT', '2000-01-01T00:00:00Z', '2000-01-02T00:00:00Z']),
-                ]:
+            ([np.nan], 'days since 2000-01-01', ['NaT']),
+            ([np.nan, 0], 'days since 2000-01-01',
+             ['NaT', '2000-01-01T00:00:00Z']),
+            ([np.nan, 0, 1], 'days since 2000-01-01',
+             ['NaT', '2000-01-01T00:00:00Z', '2000-01-02T00:00:00Z']),
+        ]:
             with warnings.catch_warnings():
                 warnings.filterwarnings('ignore', 'All-NaN')
                 actual = coding.times.decode_cf_datetime(num_dates, units)

xarray/tests/test_dataarray.py

@@ -2930,13 +2930,14 @@ def test_to_and_from_iris_dask(self):
         coord_dict['distance2'] = ('distance', [0, 1], {'foo': 'bar'})
         coord_dict['time2'] = (('distance', 'time'), [[0, 1, 2], [2, 3, 4]])
 
-        original = DataArray(da.from_array(
-            np.arange(-1, 5, dtype='float').reshape(2, 3), 3), coord_dict,
-                             name='Temperature',
-                             attrs={'baz': 123, 'units': 'Kelvin',
-                                    'standard_name': 'fire_temperature',
-                                    'long_name': 'Fire Temperature'},
-                             dims=('distance', 'time'))
+        original = DataArray(
+            da.from_array(np.arange(-1, 5, dtype='float').reshape(2, 3), 3),
+            coord_dict,
+            name='Temperature',
+            attrs=dict(baz=123, units='Kelvin',
+                       standard_name='fire_temperature',
+                       long_name='Fire Temperature'),
+            dims=('distance', 'time'))
 
         # Set a bad value to test the masking logic
         original.data = da.ma.masked_less(original.data, 0)
@@ -3257,10 +3258,10 @@ def test_rank(self):
         self.assertDataArrayEqual(ar.rank('dim_0'), expect_0)
         self.assertDataArrayEqual(ar.rank('dim_1'), expect_1)
         # int
-        x = DataArray([3,2,1])
+        x = DataArray([3, 2, 1])
         self.assertDataArrayEqual(x.rank('dim_0'), x)
         # str
-        y =  DataArray(['c', 'b', 'a'])
+        y = DataArray(['c', 'b', 'a'])
         self.assertDataArrayEqual(y.rank('dim_0'), x)
 
         x = DataArray([3.0, 1.0, np.nan, 2.0, 4.0], dims=('z',))

xarray/tests/test_plot.py

@@ -110,8 +110,8 @@ def test_2d_line_accepts_legend_kw(self):
         self.darray[:, :, 0].plot.line(x='dim_0', add_legend=True)
         self.assertTrue(plt.gca().get_legend())
         # check whether legend title is set
-        self.assertTrue(plt.gca().get_legend().get_title().get_text()
-                        == 'dim_1')
+        self.assertEqual(plt.gca().get_legend().get_title().get_text(),
+                         'dim_1')
 
     def test_2d_line_accepts_x_kw(self):
         self.darray[:, :, 0].plot.line(x='dim_0')
@@ -122,12 +122,12 @@ def test_2d_line_accepts_x_kw(self):
 
     def test_2d_line_accepts_hue_kw(self):
         self.darray[:, :, 0].plot.line(hue='dim_0')
-        self.assertTrue(plt.gca().get_legend().get_title().get_text()
-                        == 'dim_0')
+        self.assertEqual(plt.gca().get_legend().get_title().get_text(),
+                         'dim_0')
         plt.cla()
         self.darray[:, :, 0].plot.line(hue='dim_1')
-        self.assertTrue(plt.gca().get_legend().get_title().get_text()
-                        == 'dim_1')
+        self.assertEqual(plt.gca().get_legend().get_title().get_text(),
+                         'dim_1')
 
     def test_2d_before_squeeze(self):
         a = DataArray(easy_array((1, 5)))

xarray/tests/test_variable.py

@@ -1404,7 +1404,7 @@ def test_rank(self):
         expect = bn.rankdata(v.data, axis=0)
         np.testing.assert_allclose(v.rank('x').values, expect)
         # str
-        v =  Variable(['x'], ['c', 'b', 'a'])
+        v = Variable(['x'], ['c', 'b', 'a'])
         expect = bn.rankdata(v.data, axis=0)
         np.testing.assert_allclose(v.rank('x').values, expect)
         # pct

xarray/util/print_versions.py

@@ -25,7 +25,7 @@ def get_sys_info():
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE)
             so, serr = pipe.communicate()
-        except:
+        except Exception:
             pass
         else:
             if pipe.returncode == 0:
@@ -55,7 +55,7 @@ def get_sys_info():
             ("LOCALE", "%s.%s" % locale.getlocale()),
 
         ])
-    except:
+    except Exception:
         pass
 
     return blob
@@ -102,13 +102,13 @@ def show_versions(as_json=False):
                 mod = importlib.import_module(modname)
             ver = ver_f(mod)
             deps_blob.append((modname, ver))
-        except:
+        except Exception:
             deps_blob.append((modname, None))
 
     if (as_json):
         try:
             import json
-        except:
+        except Exception:
             import simplejson as json
 
         j = dict(system=dict(sys_info), dependencies=dict(deps_blob))