pytest-ification

.gitignore

@@ -32,6 +32,7 @@ pip-log.txt
 .tox
 nosetests.xml
 .cache
+.ropeproject/
 
 # Translations
 *.mo
@@ -51,4 +52,7 @@ doc/_build
 doc/generated
 xarray/version.py
 
+# Sync tools
+Icon*
+
 .ipynb_checkpoints

xarray/conventions.py

@@ -355,7 +355,7 @@ def ensure_dtype_not_object(var, name=None):
                 fill_value = u''
             else:
                 # insist on using float for numeric values
-                if not np.issubdtype(inferred_dtype, float):
+                if not np.issubdtype(inferred_dtype, np.floating):
                     inferred_dtype = np.dtype(float)
                 fill_value = inferred_dtype.type(np.nan)
 

xarray/core/dataset.py

@@ -1573,7 +1573,8 @@ def relevant_keys(mapping):
             dim_name = dim
             dim_coord = None
 
-        reordered = self.transpose(*(list(indexer_dims) + list(non_indexed_dims)))
+        reordered = self.transpose(
+            *(list(indexer_dims) + list(non_indexed_dims)))
 
         variables = OrderedDict()
 
@@ -3383,7 +3384,8 @@ def rank(self, dim, pct=False, keep_attrs=False):
             Variables that do not depend on `dim` are dropped.
         """
         if dim not in self.dims:
-            raise ValueError('Dataset does not contain the dimension: %s' % dim)
+            raise ValueError(
+                'Dataset does not contain the dimension: %s' % dim)
 
         variables = OrderedDict()
         for name, var in iteritems(self.variables):

xarray/core/dtypes.py

@@ -20,13 +20,13 @@ def maybe_promote(dtype):
     fill_value : Valid missing value for the promoted dtype.
     """
     # N.B. these casting rules should match pandas
-    if np.issubdtype(dtype, float):
+    if np.issubdtype(dtype, np.floating):
         fill_value = np.nan
-    elif np.issubdtype(dtype, int):
+    elif np.issubdtype(dtype, np.signedinteger):
         # convert to floating point so NaN is valid
         dtype = float
         fill_value = np.nan
-    elif np.issubdtype(dtype, complex):
+    elif np.issubdtype(dtype, np.complexfloating):
         fill_value = np.nan + np.nan * 1j
     elif np.issubdtype(dtype, np.datetime64):
         fill_value = np.datetime64('NaT')

xarray/core/indexing.py

@@ -879,7 +879,7 @@ def __array__(self, dtype=None):
         if isinstance(array, pd.PeriodIndex):
             with suppress(AttributeError):
                 # this might not be public API
-                array = array.asobject
+                array = array.astype('object')
         return np.asarray(array.values, dtype=dtype)
 
     @property

xarray/core/missing.py

@@ -41,6 +41,7 @@ class NumpyInterpolator(BaseInterpolator):
     --------
     numpy.interp
     '''
+
     def __init__(self, xi, yi, method='linear', fill_value=None, **kwargs):
 
         if method != 'linear':
@@ -83,6 +84,7 @@ class ScipyInterpolator(BaseInterpolator):
     --------
     scipy.interpolate.interp1d
     '''
+
     def __init__(self, xi, yi, method=None, fill_value=None,
                  assume_sorted=True, copy=False, bounds_error=False, **kwargs):
         from scipy.interpolate import interp1d
@@ -118,6 +120,7 @@ class SplineInterpolator(BaseInterpolator):
     --------
     scipy.interpolate.UnivariateSpline
     '''
+
     def __init__(self, xi, yi, method='spline', fill_value=None, order=3,
                  **kwargs):
         from scipy.interpolate import UnivariateSpline

xarray/core/utils.py

@@ -542,6 +542,7 @@ class HiddenKeyDict(MutableMapping):
     Acts like a normal dictionary, but hides certain keys.
     '''
     # ``__init__`` method required to create instance from class.
+
     def __init__(self, data, hidden_keys):
         self._data = data
         if type(hidden_keys) not in (list, tuple):

xarray/tests/__init__.py

@@ -109,6 +109,9 @@ def _importorskip(modname, minversion=None):
 
 
 class TestCase(unittest.TestCase):
+    """
+    These functions are all deprecated. Instead, use functions in xr.testing
+    """
     if PY3:
         # Python 3 assertCountEqual is roughly equivalent to Python 2
         # assertItemsEqual

xarray/tests/test_accessors.py

@@ -6,7 +6,8 @@
 import numpy as np
 import pandas as pd
 
-from . import TestCase, requires_dask, raises_regex
+from . import (TestCase, requires_dask, raises_regex, assert_equal,
+               assert_array_equal)
 
 
 class TestDatetimeAccessor(TestCase):
@@ -17,29 +18,58 @@ def setUp(self):
         lats = np.linspace(0, 20, 10)
         self.times = pd.date_range(start="2000/01/01", freq='H', periods=nt)
 
-        self.data = xr.DataArray(data, coords=[lons, lats, self.times],
-                                 dims=['lon', 'lat', 'time'], name='data')
+        self.data = xr.DataArray(
+            data,
+            coords=[lons, lats, self.times],
+            dims=['lon', 'lat', 'time'],
+            name='data')
 
         self.times_arr = np.random.choice(self.times, size=(10, 10, nt))
-        self.times_data = xr.DataArray(self.times_arr,
-                                       coords=[lons, lats, self.times],
-                                       dims=['lon', 'lat', 'time'],
-                                       name='data')
+        self.times_data = xr.DataArray(
+            self.times_arr,
+            coords=[lons, lats, self.times],
+            dims=['lon', 'lat', 'time'],
+            name='data')
 
     def test_field_access(self):
-        years = xr.DataArray(self.times.year, name='year',
-                             coords=[self.times, ], dims=['time', ])
-        months = xr.DataArray(self.times.month, name='month',
-                              coords=[self.times, ], dims=['time', ])
-        days = xr.DataArray(self.times.day, name='day',
-                            coords=[self.times, ], dims=['time', ])
-        hours = xr.DataArray(self.times.hour, name='hour',
-                             coords=[self.times, ], dims=['time', ])
-
-        self.assertDataArrayEqual(years, self.data.time.dt.year)
-        self.assertDataArrayEqual(months, self.data.time.dt.month)
-        self.assertDataArrayEqual(days, self.data.time.dt.day)
-        self.assertDataArrayEqual(hours, self.data.time.dt.hour)
+        years = xr.DataArray(
+            self.times.year,
+            name='year',
+            coords=[
+                self.times,
+            ],
+            dims=[
+                'time',
+            ])
+        months = xr.DataArray(
+            self.times.month,
+            name='month',
+            coords=[
+                self.times,
+            ],
+            dims=[
+                'time',
+            ])
+        days = xr.DataArray(
+            self.times.day, name='day', coords=[
+                self.times,
+            ], dims=[
+                'time',
+            ])
+        hours = xr.DataArray(
+            self.times.hour,
+            name='hour',
+            coords=[
+                self.times,
+            ],
+            dims=[
+                'time',
+            ])
+
+        assert_equal(years, self.data.time.dt.year)
+        assert_equal(months, self.data.time.dt.month)
+        assert_equal(days, self.data.time.dt.day)
+        assert_equal(hours, self.data.time.dt.hour)
 
     def test_not_datetime_type(self):
         nontime_data = self.data.copy()
@@ -58,10 +88,11 @@ def test_dask_field_access(self):
         days = self.times_data.dt.day
 
         dask_times_arr = da.from_array(self.times_arr, chunks=(5, 5, 50))
-        dask_times_2d = xr.DataArray(dask_times_arr,
-                                     coords=self.data.coords,
-                                     dims=self.data.dims,
-                                     name='data')
+        dask_times_2d = xr.DataArray(
+            dask_times_arr,
+            coords=self.data.coords,
+            dims=self.data.dims,
+            name='data')
         dask_year = dask_times_2d.dt.year
         dask_month = dask_times_2d.dt.month
         dask_day = dask_times_2d.dt.day
@@ -75,22 +106,24 @@ def test_dask_field_access(self):
 
         # Double check that outcome chunksize is unchanged
         dask_chunks = dask_times_2d.chunks
-        self.assertEqual(dask_year.data.chunks, dask_chunks)
-        self.assertEqual(dask_month.data.chunks, dask_chunks)
-        self.assertEqual(dask_day.data.chunks, dask_chunks)
-        self.assertEqual(dask_hour.data.chunks, dask_chunks)
+        assert dask_year.data.chunks == dask_chunks
+        assert dask_month.data.chunks == dask_chunks
+        assert dask_day.data.chunks == dask_chunks
+        assert dask_hour.data.chunks == dask_chunks
 
         # Check the actual output from the accessors
-        self.assertDataArrayEqual(years, dask_year.compute())
-        self.assertDataArrayEqual(months, dask_month.compute())
-        self.assertDataArrayEqual(days, dask_day.compute())
-        self.assertDataArrayEqual(hours, dask_hour.compute())
+        assert_equal(years, dask_year.compute())
+        assert_equal(months, dask_month.compute())
+        assert_equal(days, dask_day.compute())
+        assert_equal(hours, dask_hour.compute())
 
     def test_seasons(self):
         dates = pd.date_range(start="2000/01/01", freq="M", periods=12)
         dates = xr.DataArray(dates)
-        seasons = ["DJF", "DJF", "MAM", "MAM", "MAM", "JJA", "JJA", "JJA",
-                   "SON", "SON", "SON", "DJF"]
+        seasons = [
+            "DJF", "DJF", "MAM", "MAM", "MAM", "JJA", "JJA", "JJA", "SON",
+            "SON", "SON", "DJF"
+        ]
         seasons = xr.DataArray(seasons)
 
-        self.assertArrayEqual(seasons.values, dates.dt.season.values)
+        assert_array_equal(seasons.values, dates.dt.season.values)

xarray/tests/test_backends.py

@@ -2193,9 +2193,9 @@ def test_utm(self):
 
             # 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,
+                'band': [1, 2, 3],
+                'y': -np.arange(ny) * 2000 + 80000 + dy / 2,
+                'x': np.arange(nx) * 1000 + 5000 + dx / 2,
             })
             with xr.open_rasterio(tmp_file) as rioda:
                 assert_allclose(rioda, expected)
@@ -2362,9 +2362,9 @@ def test_caching(self):
             # ref
             expected = DataArray(
                 data, dims=('band', 'y', 'x'), coords={
-                     'x': (np.arange(nx) * 0.5 + 1) + dx / 2,
-                     'y': (-np.arange(ny) * 2 + 2) + dy / 2,
-                     'band': [1, 2, 3]})
+                    'x': (np.arange(nx) * 0.5 + 1) + dx / 2,
+                    'y': (-np.arange(ny) * 2 + 2) + dy / 2,
+                    'band': [1, 2, 3]})
 
             # Cache is the default
             with xr.open_rasterio(tmp_file) as actual: