From 70e9eb8fc834e4aeff42c221c04c9713eb465b8a Mon Sep 17 00:00:00 2001 From: Gerrit Holl Date: Fri, 16 Nov 2018 16:40:02 +0000 Subject: [PATCH 001/108] add missing , and article in error message (#2557) Add missing , and article in error message when attribute values have the wrong type. --- xarray/backends/api.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/xarray/backends/api.py b/xarray/backends/api.py index ca440872d73..c1ace7774f9 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -113,7 +113,7 @@ def check_name(name): def _validate_attrs(dataset): - """`attrs` must have a string key and a value which is either: a number + """`attrs` must have a string key and a value which is either: a number, a string, an ndarray or a list/tuple of numbers/strings. """ def check_attr(name, value): @@ -128,8 +128,8 @@ def check_attr(name, value): if not isinstance(value, (basestring, Number, np.ndarray, np.number, list, tuple)): - raise TypeError('Invalid value for attr: {} must be a number ' - 'string, ndarray or a list/tuple of ' + raise TypeError('Invalid value for attr: {} must be a number, ' + 'a string, an ndarray or a list/tuple of ' 'numbers/strings for serialization to netCDF ' 'files'.format(value)) From 57fdcc52471b42ffba3269407329c7bd6694c0c1 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sat, 24 Nov 2018 15:25:57 -0500 Subject: [PATCH 002/108] DOC: fix computation.rst (#2567) --- doc/computation.rst | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/doc/computation.rst b/doc/computation.rst index 759c87a6cc7..3eec891494b 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -164,9 +164,8 @@ Note that rolling window aggregations are faster when bottleneck_ is installed. We can also manually iterate through ``Rolling`` objects: -.. ipython:: python +.. code:: python - @verbatim for label, arr_window in r: # arr_window is a view of x @@ -298,9 +297,9 @@ operations. The default result of a binary operation is by the *intersection* If coordinate values for a dimension are missing on either argument, all matching dimensions must have the same size: -.. ipython:: python +.. ipython:: + :verbatim: - @verbatim In [1]: arr + xr.DataArray([1, 2], dims='x') ValueError: arguments without labels along dimension 'x' cannot be aligned because they have different dimension size(s) {2} than the size of the aligned dimension labels: 3 From 9d572a5aa93aedc2cfdabcde575162cfb1372d41 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sat, 24 Nov 2018 15:26:15 -0500 Subject: [PATCH 003/108] Return slices when possible from CFTimeIndex.get_loc() (#2569) This makes string indexing usable in a pandas.MultiIndex. --- doc/whats-new.rst | 4 ++++ xarray/coding/cftimeindex.py | 27 ++++++++++++++++++++++----- xarray/tests/test_cftimeindex.py | 23 +++++++++++++++-------- 3 files changed, 41 insertions(+), 13 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 1da1da700e7..b1d5b92da4d 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -36,6 +36,10 @@ Breaking changes Enhancements ~~~~~~~~~~~~ +- :py:class:`CFTimeIndex` uses slicing for string indexing when possible (like + :py:class:`pandas.DatetimeIndex`), which avoids unnecessary copies. + By `Stephan Hoyer `_ + Bug fixes ~~~~~~~~~ diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 2ce996b2bd2..71fa7f2fa6b 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -263,14 +263,31 @@ def _partial_date_slice(self, resolution, parsed): """ start, end = _parsed_string_to_bounds(self.date_type, resolution, parsed) - lhs_mask = (self._data >= start) - rhs_mask = (self._data <= end) - return (lhs_mask & rhs_mask).nonzero()[0] + + times = self._data + + if self.is_monotonic: + if (len(times) and ((start < times[0] and end < times[0]) or + (start > times[-1] and end > times[-1]))): + # we are out of range + raise KeyError + + # a monotonic (sorted) series can be sliced + left = times.searchsorted(start, side='left') + right = times.searchsorted(end, side='right') + return slice(left, right) + + lhs_mask = times >= start + rhs_mask = times <= end + return np.flatnonzero(lhs_mask & rhs_mask) def _get_string_slice(self, key): """Adapted from pandas.tseries.index.DatetimeIndex._get_string_slice""" parsed, resolution = _parse_iso8601_with_reso(self.date_type, key) - loc = self._partial_date_slice(resolution, parsed) + try: + loc = self._partial_date_slice(resolution, parsed) + except KeyError: + raise KeyError(key) return loc def get_loc(self, key, method=None, tolerance=None): @@ -431,7 +448,7 @@ def to_datetimeindex(self, unsafe=False): 'calendar, {!r}, to a pandas.DatetimeIndex, which uses dates ' 'from the standard calendar. This may lead to subtle errors ' 'in operations that depend on the length of time between ' - 'dates.'.format(calendar), RuntimeWarning) + 'dates.'.format(calendar), RuntimeWarning, stacklevel=2) return pd.DatetimeIndex(nptimes) diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 5e710827ff8..b9006774c30 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -12,7 +12,7 @@ _parsed_string_to_bounds, assert_all_valid_date_type, parse_iso8601) from xarray.tests import assert_array_equal, assert_identical -from . import has_cftime, has_cftime_or_netCDF4, requires_cftime +from . import has_cftime, has_cftime_or_netCDF4, requires_cftime, raises_regex from .test_coding_times import (_all_cftime_date_types, _ALL_CALENDARS, _NON_STANDARD_CALENDARS) @@ -251,16 +251,16 @@ def test_parsed_string_to_bounds_raises(date_type): @pytest.mark.skipif(not has_cftime, reason='cftime not installed') def test_get_loc(date_type, index): result = index.get_loc('0001') - expected = [0, 1] - assert_array_equal(result, expected) + assert result == slice(0, 2) result = index.get_loc(date_type(1, 2, 1)) - expected = 1 - assert result == expected + assert result == 1 result = index.get_loc('0001-02-01') - expected = 1 - assert result == expected + assert result == slice(1, 2) + + with raises_regex(KeyError, '1234'): + index.get_loc('1234') @pytest.mark.skipif(not has_cftime, reason='cftime not installed') @@ -758,7 +758,7 @@ def test_to_datetimeindex(calendar, unsafe): with pytest.warns(RuntimeWarning, match='non-standard'): result = index.to_datetimeindex() else: - result = index.to_datetimeindex() + result = index.to_datetimeindex(unsafe=unsafe) assert result.equals(expected) np.testing.assert_array_equal(result, expected) @@ -779,3 +779,10 @@ def test_to_datetimeindex_feb_29(calendar): index = xr.cftime_range('2001-02-28', periods=2, calendar=calendar) with pytest.raises(ValueError, match='29'): index.to_datetimeindex() + + +@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +def test_multiindex(): + index = xr.cftime_range('2001-01-01', periods=100, calendar='360_day') + mindex = pd.MultiIndex.from_arrays([index]) + assert mindex.get_loc('2001-01') == slice(0, 30) From ecbf91fcb6b83bbd955b476367e1daff09e5631a Mon Sep 17 00:00:00 2001 From: Danilo Horta Date: Sun, 25 Nov 2018 19:59:56 +0000 Subject: [PATCH 004/108] python setup.py test now works by default (#2573) --- setup.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/setup.py b/setup.py index 3b56d9265af..eaf57dff81d 100644 --- a/setup.py +++ b/setup.py @@ -25,6 +25,7 @@ ] INSTALL_REQUIRES = ['numpy >= 1.12', 'pandas >= 0.19.2'] +SETUP_REQUIRES = ['pytest-runner >= 4.2'] TESTS_REQUIRE = ['pytest >= 2.7.1'] if sys.version_info[0] < 3: TESTS_REQUIRE.append('mock') @@ -66,6 +67,7 @@ description=DESCRIPTION, long_description=LONG_DESCRIPTION, install_requires=INSTALL_REQUIRES, + setup_requires=SETUP_REQUIRES, tests_require=TESTS_REQUIRE, url=URL, python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*', From a2a448dff8c053b1a3a137c64aedde520ac6de2a Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Mon, 26 Nov 2018 10:39:25 -0800 Subject: [PATCH 005/108] DOC: remove example using Dataset.T (#2572) * DOC: remove example using Dataset.T * Update reshaping.rst * Update reshaping.rst --- doc/reshaping.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/reshaping.rst b/doc/reshaping.rst index 4a24dc474b7..67d9e198e8a 100644 --- a/doc/reshaping.rst +++ b/doc/reshaping.rst @@ -18,14 +18,13 @@ Reordering dimensions --------------------- To reorder dimensions on a :py:class:`~xarray.DataArray` or across all variables -on a :py:class:`~xarray.Dataset`, use :py:meth:`~xarray.DataArray.transpose` or the -``.T`` property: +on a :py:class:`~xarray.Dataset`, use :py:meth:`~xarray.DataArray.transpose`: .. ipython:: python ds = xr.Dataset({'foo': (('x', 'y', 'z'), [[[42]]]), 'bar': (('y', 'z'), [[24]])}) ds.transpose('y', 'z', 'x') - ds.T + ds.transpose() # reverses all dimensions Expand and squeeze dimensions ----------------------------- From 483b8a0a89ea4be862488e51af8a1b3bc7f40356 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Tue, 27 Nov 2018 01:46:54 -0500 Subject: [PATCH 006/108] Concat docstring typo (#2577) --- xarray/core/combine.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xarray/core/combine.py b/xarray/core/combine.py index 6853939c02d..ea156667430 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -43,7 +43,7 @@ def concat(objs, dim=None, data_vars='all', coords='different', * list of str: The listed data variables will be concatenated, in addition to the 'minimal' data variables. If objects are DataArrays, data_vars must be 'all'. - coords : {'minimal', 'different', 'all' o list of str}, optional + coords : {'minimal', 'different', 'all' or list of str}, optional These coordinate variables will be concatenated together: * 'minimal': Only coordinates in which the dimension already appears are included. From 22a5763e0cafd360011e222a7f3138434e4f6ba0 Mon Sep 17 00:00:00 2001 From: David Brochart Date: Wed, 28 Nov 2018 20:26:54 +0100 Subject: [PATCH 007/108] Fix typo (#2578) --- doc/dask.rst | 149 ++++++++++++++++++++++++++------------------------- 1 file changed, 75 insertions(+), 74 deletions(-) diff --git a/doc/dask.rst b/doc/dask.rst index 672450065cb..975111cba33 100644 --- a/doc/dask.rst +++ b/doc/dask.rst @@ -1,49 +1,49 @@ .. _dask: -Parallel computing with dask +Parallel computing with Dask ============================ -xarray integrates with `dask `__ to support parallel +xarray integrates with `Dask `__ to support parallel computations and streaming computation on datasets that don't fit into memory. -Currently, dask is an entirely optional feature for xarray. However, the -benefits of using dask are sufficiently strong that dask may become a required +Currently, Dask is an entirely optional feature for xarray. However, the +benefits of using Dask are sufficiently strong that Dask may become a required dependency in a future version of xarray. -For a full example of how to use xarray's dask integration, read the -`blog post introducing xarray and dask`_. +For a full example of how to use xarray's Dask integration, read the +`blog post introducing xarray and Dask`_. -.. _blog post introducing xarray and dask: http://stephanhoyer.com/2015/06/11/xray-dask-out-of-core-labeled-arrays/ +.. _blog post introducing xarray and Dask: http://stephanhoyer.com/2015/06/11/xray-dask-out-of-core-labeled-arrays/ -What is a dask array? +What is a Dask array? --------------------- .. image:: _static/dask_array.png :width: 40 % :align: right - :alt: A dask array + :alt: A Dask array Dask divides arrays into many small pieces, called *chunks*, each of which is presumed to be small enough to fit into memory. -Unlike NumPy, which has eager evaluation, operations on dask arrays are lazy. +Unlike NumPy, which has eager evaluation, operations on Dask arrays are lazy. Operations queue up a series of tasks mapped over blocks, and no computation is performed until you actually ask values to be computed (e.g., to print results to your screen or write to disk). At that point, data is loaded into memory and computation proceeds in a streaming fashion, block-by-block. The actual computation is controlled by a multi-processing or thread pool, -which allows dask to take full advantage of multiple processors available on +which allows Dask to take full advantage of multiple processors available on most modern computers. -For more details on dask, read `its documentation `__. +For more details on Dask, read `its documentation `__. .. _dask.io: Reading and writing data ------------------------ -The usual way to create a dataset filled with dask arrays is to load the +The usual way to create a dataset filled with Dask arrays is to load the data from a netCDF file or files. You can do this by supplying a ``chunks`` argument to :py:func:`~xarray.open_dataset` or using the :py:func:`~xarray.open_mfdataset` function. @@ -69,10 +69,10 @@ argument to :py:func:`~xarray.open_dataset` or using the ds = xr.open_dataset('example-data.nc', chunks={'time': 10}) ds -In this example ``latitude`` and ``longitude`` do not appear in the -``chunks`` dict, so only one chunk will be used along those dimensions. It -is also entirely equivalent to open a dataset using ``open_dataset`` and -then chunk the data use the ``chunk`` method, e.g., +In this example ``latitude`` and ``longitude`` do not appear in the ``chunks`` +dict, so only one chunk will be used along those dimensions. It is also +entirely equivalent to opening a dataset using ``open_dataset`` and then +chunking the data using the ``chunk`` method, e.g., ``xr.open_dataset('example-data.nc').chunk({'time': 10})``. To open multiple files simultaneously, use :py:func:`~xarray.open_mfdataset`:: @@ -82,21 +82,21 @@ To open multiple files simultaneously, use :py:func:`~xarray.open_mfdataset`:: This function will automatically concatenate and merge dataset into one in the simple cases that it understands (see :py:func:`~xarray.auto_combine` for the full disclaimer). By default, ``open_mfdataset`` will chunk each -netCDF file into a single dask array; again, supply the ``chunks`` argument to -control the size of the resulting dask arrays. In more complex cases, you can +netCDF file into a single Dask array; again, supply the ``chunks`` argument to +control the size of the resulting Dask arrays. In more complex cases, you can open each file individually using ``open_dataset`` and merge the result, as described in :ref:`combining data`. You'll notice that printing a dataset still shows a preview of array values, -even if they are actually dask arrays. We can do this quickly -with dask because we only need to the compute the first few values (typically -from the first block). To reveal the true nature of an array, print a DataArray: +even if they are actually Dask arrays. We can do this quickly with Dask because +we only need to compute the first few values (typically from the first block). +To reveal the true nature of an array, print a DataArray: .. ipython:: python ds.temperature -Once you've manipulated a dask array, you can still write a dataset too big to +Once you've manipulated a Dask array, you can still write a dataset too big to fit into memory back to disk by using :py:meth:`~xarray.Dataset.to_netcdf` in the usual way. @@ -105,7 +105,7 @@ usual way. ds.to_netcdf('manipulated-example-data.nc') By setting the ``compute`` argument to ``False``, :py:meth:`~xarray.Dataset.to_netcdf` -will return a dask delayed object that can be computed later. +will return a Dask delayed object that can be computed later. .. ipython:: python @@ -117,43 +117,43 @@ will return a dask delayed object that can be computed later. .. note:: - When using dask's distributed scheduler to write NETCDF4 files, + When using Dask's distributed scheduler to write NETCDF4 files, it may be necessary to set the environment variable `HDF5_USE_FILE_LOCKING=FALSE` to avoid competing locks within the HDF5 SWMR file locking scheme. Note that - writing netCDF files with dask's distributed scheduler is only supported for + writing netCDF files with Dask's distributed scheduler is only supported for the `netcdf4` backend. -A dataset can also be converted to a dask DataFrame using :py:meth:`~xarray.Dataset.to_dask_dataframe`. +A dataset can also be converted to a Dask DataFrame using :py:meth:`~xarray.Dataset.to_dask_dataframe`. .. ipython:: python df = ds.to_dask_dataframe() df -Dask DataFrames do not support multi-indexes so the coordinate variables from the dataset are included as columns in the dask DataFrame. +Dask DataFrames do not support multi-indexes so the coordinate variables from the dataset are included as columns in the Dask DataFrame. -Using dask with xarray +Using Dask with xarray ---------------------- Nearly all existing xarray methods (including those for indexing, computation, concatenating and grouped operations) have been extended to work automatically -with dask arrays. When you load data as a dask array in an xarray data -structure, almost all xarray operations will keep it as a dask array; when this +with Dask arrays. When you load data as a Dask array in an xarray data +structure, almost all xarray operations will keep it as a Dask array; when this is not possible, they will raise an exception rather than unexpectedly loading -data into memory. Converting a dask array into memory generally requires an -explicit conversion step. One noteable exception is indexing operations: to +data into memory. Converting a Dask array into memory generally requires an +explicit conversion step. One notable exception is indexing operations: to enable label based indexing, xarray will automatically load coordinate labels into memory. -The easiest way to convert an xarray data structure from lazy dask arrays into -eager, in-memory numpy arrays is to use the :py:meth:`~xarray.Dataset.load` method: +The easiest way to convert an xarray data structure from lazy Dask arrays into +eager, in-memory NumPy arrays is to use the :py:meth:`~xarray.Dataset.load` method: .. ipython:: python ds.load() You can also access :py:attr:`~xarray.DataArray.values`, which will always be a -numpy array: +NumPy array: .. ipython:: :verbatim: @@ -177,7 +177,7 @@ Explicit conversion by wrapping a DataArray with ``np.asarray`` also works: ... Alternatively you can load the data into memory but keep the arrays as -dask arrays using the :py:meth:`~xarray.Dataset.persist` method: +Dask arrays using the :py:meth:`~xarray.Dataset.persist` method: .. ipython:: @@ -191,8 +191,8 @@ sure that your dataset is not larger than available memory. For performance you may wish to consider chunk sizes. The correct choice of chunk size depends both on your data and on the operations you want to perform. -With xarray, both converting data to a dask arrays and converting the chunk -sizes of dask arrays is done with the :py:meth:`~xarray.Dataset.chunk` method: +With xarray, both converting data to a Dask arrays and converting the chunk +sizes of Dask arrays is done with the :py:meth:`~xarray.Dataset.chunk` method: .. ipython:: python :suppress: @@ -216,7 +216,7 @@ along a particular dimension, an exception is raised when you try to access .. note:: - In the future, we would like to enable automatic alignment of dask + In the future, we would like to enable automatic alignment of Dask chunksizes (but not the other way around). We might also require that all arrays in a dataset share the same chunking alignment. Neither of these are currently done. @@ -224,17 +224,17 @@ along a particular dimension, an exception is raised when you try to access NumPy ufuncs like ``np.sin`` currently only work on eagerly evaluated arrays (this will change with the next major NumPy release). We have provided replacements that also work on all xarray objects, including those that store -lazy dask arrays, in the :ref:`xarray.ufuncs ` module: +lazy Dask arrays, in the :ref:`xarray.ufuncs ` module: .. ipython:: python import xarray.ufuncs as xu xu.sin(rechunked) -To access dask arrays directly, use the new +To access Dask arrays directly, use the new :py:attr:`DataArray.data ` attribute. This attribute exposes -array data either as a dask array or as a numpy array, depending on whether it has been -loaded into dask or not: +array data either as a Dask array or as a NumPy array, depending on whether it has been +loaded into Dask or not: .. ipython:: python @@ -243,25 +243,26 @@ loaded into dask or not: .. note:: In the future, we may extend ``.data`` to support other "computable" array - backends beyond dask and numpy (e.g., to support sparse arrays). + backends beyond Dask and NumPy (e.g., to support sparse arrays). .. _dask.automatic-parallelization: Automatic parallelization ------------------------- -Almost all of xarray's built-in operations work on dask arrays. If you want to -use a function that isn't wrapped by xarray, one option is to extract dask -arrays from xarray objects (``.data``) and use dask directly. +Almost all of xarray's built-in operations work on Dask arrays. If you want to +use a function that isn't wrapped by xarray, one option is to extract Dask +arrays from xarray objects (``.data``) and use Dask directly. Another option is to use xarray's :py:func:`~xarray.apply_ufunc`, which can -automate `embarrassingly parallel `__ -"map" type operations where a functions written for processing NumPy arrays -should be repeatedly applied to xarray objects containing dask arrays. It works -similarly to :py:func:`dask.array.map_blocks` and :py:func:`dask.array.atop`, -but without requiring an intermediate layer of abstraction. - -For the best performance when using dask's multi-threaded scheduler, wrap a +automate `embarrassingly parallel +`__ "map" type operations +where a function written for processing NumPy arrays should be repeatedly +applied to xarray objects containing Dask arrays. It works similarly to +:py:func:`dask.array.map_blocks` and :py:func:`dask.array.atop`, but without +requiring an intermediate layer of abstraction. + +For the best performance when using Dask's multi-threaded scheduler, wrap a function that already releases the global interpreter lock, which fortunately already includes most NumPy and Scipy functions. Here we show an example using NumPy operations and a fast function from @@ -311,7 +312,7 @@ work as a streaming operation, when run on arrays loaded from disk: In [58]: array2 = array1 + 0.5 * rs.randn(1000, 100000) - # using one core, on numpy arrays + # using one core, on NumPy arrays In [61]: %time _ = spearman_correlation(array1, array2, 'time') CPU times: user 21.6 s, sys: 2.84 s, total: 24.5 s Wall time: 24.9 s @@ -320,7 +321,7 @@ work as a streaming operation, when run on arrays loaded from disk: In [9]: chunked2 = array2.chunk({'place': 10}) - # using all my laptop's cores, with dask + # using all my laptop's cores, with Dask In [63]: r = spearman_correlation(chunked1, chunked2, 'time').compute() In [64]: %time _ = r.compute() @@ -336,17 +337,17 @@ multiple chunks along a core dimension: In [63]: spearman_correlation(chunked1, chunked2, 'place') ValueError: dimension 'place' on 0th function argument to apply_ufunc with dask='parallelized' consists of multiple chunks, but is also a core - dimension. To fix, rechunk into a single dask array chunk along this + dimension. To fix, rechunk into a single Dask array chunk along this dimension, i.e., ``.rechunk({'place': -1})``, but beware that this may significantly increase memory usage. -The reflects the nature of core dimensions, in contrast to broadcast -(non-core) dimensions that allow operations to be split into arbitrary chunks -for application. +This reflects the nature of core dimensions, in contrast to broadcast (non-core) +dimensions that allow operations to be split into arbitrary chunks for +application. .. tip:: - For the majority of NumPy functions that are already wrapped by dask, it's + For the majority of NumPy functions that are already wrapped by Dask, it's usually a better idea to use the pre-existing ``dask.array`` function, by using either a pre-existing xarray methods or :py:func:`~xarray.apply_ufunc()` with ``dask='allowed'``. Dask can often @@ -357,19 +358,19 @@ for application. Chunking and performance ------------------------ -The ``chunks`` parameter has critical performance implications when using dask +The ``chunks`` parameter has critical performance implications when using Dask arrays. If your chunks are too small, queueing up operations will be extremely -slow, because dask will translates each operation into a huge number of -operations mapped across chunks. Computation on dask arrays with small chunks -can also be slow, because each operation on a chunk has some fixed overhead -from the Python interpreter and the dask task executor. +slow, because Dask will translate each operation into a huge number of +operations mapped across chunks. Computation on Dask arrays with small chunks +can also be slow, because each operation on a chunk has some fixed overhead from +the Python interpreter and the Dask task executor. Conversely, if your chunks are too big, some of your computation may be wasted, -because dask only computes results one chunk at a time. +because Dask only computes results one chunk at a time. -A good rule of thumb to create arrays with a minimum chunksize of at least one -million elements (e.g., a 1000x1000 matrix). With large arrays (10+ GB), the -cost of queueing up dask operations can be noticeable, and you may need even +A good rule of thumb is to create arrays with a minimum chunksize of at least +one million elements (e.g., a 1000x1000 matrix). With large arrays (10+ GB), the +cost of queueing up Dask operations can be noticeable, and you may need even larger chunksizes. .. ipython:: python @@ -381,10 +382,10 @@ larger chunksizes. Optimization Tips ----------------- -With analysis pipelines involving both spatial subsetting and temporal resampling, dask performance can become very slow in certain cases. Here are some optimization tips we have found through experience: +With analysis pipelines involving both spatial subsetting and temporal resampling, Dask performance can become very slow in certain cases. Here are some optimization tips we have found through experience: -1. Do your spatial and temporal indexing (e.g. ``.sel()`` or ``.isel()``) early in the pipeline, especially before calling ``resample()`` or ``groupby()``. Grouping and rasampling triggers some computation on all the blocks, which in theory should commute with indexing, but this optimization hasn't been implemented in dask yet. (See `dask issue #746 `_). +1. Do your spatial and temporal indexing (e.g. ``.sel()`` or ``.isel()``) early in the pipeline, especially before calling ``resample()`` or ``groupby()``. Grouping and resampling triggers some computation on all the blocks, which in theory should commute with indexing, but this optimization hasn't been implemented in Dask yet. (See `Dask issue #746 `_). -2. Save intermediate results to disk as a netCDF files (using ``to_netcdf()``) and then load them again with ``open_dataset()`` for further computations. For example, if subtracting temporal mean from a dataset, save the temporal mean to disk before subtracting. Again, in theory, dask should be able to do the computation in a streaming fashion, but in practice this is a fail case for the dask scheduler, because it tries to keep every chunk of an array that it computes in memory. (See `dask issue #874 `_) +2. Save intermediate results to disk as a netCDF files (using ``to_netcdf()``) and then load them again with ``open_dataset()`` for further computations. For example, if subtracting temporal mean from a dataset, save the temporal mean to disk before subtracting. Again, in theory, Dask should be able to do the computation in a streaming fashion, but in practice this is a fail case for the Dask scheduler, because it tries to keep every chunk of an array that it computes in memory. (See `Dask issue #874 `_) 3. Specify smaller chunks across space when using ``open_mfdataset()`` (e.g., ``chunks={'latitude': 10, 'longitude': 10}``). This makes spatial subsetting easier, because there's no risk you will load chunks of data referring to different chunks (probably not necessary if you follow suggestion 1). From 0d6056e8816e3d367a64f36c7f1a5c4e1ce4ed4e Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Wed, 28 Nov 2018 15:30:36 -0700 Subject: [PATCH 008/108] fix examples (#2581) * Fix multidimensional co-ordinate example. * Use open_dataset().load() in other example --- examples/xarray_multidimensional_coords.ipynb | 181 +++++++++++------- examples/xarray_seasonal_means.ipynb | 151 ++++++++++----- 2 files changed, 216 insertions(+), 116 deletions(-) diff --git a/examples/xarray_multidimensional_coords.ipynb b/examples/xarray_multidimensional_coords.ipynb index 6bd942c5ba2..e0bee5ab495 100644 --- a/examples/xarray_multidimensional_coords.ipynb +++ b/examples/xarray_multidimensional_coords.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "

Table of Contents

\n", + "
" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -15,16 +25,19 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:49:56.068395Z", + "start_time": "2018-11-28T20:49:56.035349Z" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "('numpy version : ', '1.11.0')\n", - "('pandas version : ', u'0.18.0')\n", - "('xarray version : ', '0.7.2-32-gf957eb8')\n" + "numpy version : 1.14.3\n", + "pandas version : 0.23.4\n", + "xarray version : 0.11.0+9.g22a5763e\n" ] } ], @@ -38,7 +51,7 @@ "\n", "print(\"numpy version : \", np.__version__)\n", "print(\"pandas version : \", pd.__version__)\n", - "print(\"xarray version : \", xr.version.version)" + "print(\"xarray version : \", xr.__version__)" ] }, { @@ -50,9 +63,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:50:13.629720Z", + "start_time": "2018-11-28T20:50:13.484542Z" + } }, "outputs": [ { @@ -61,34 +77,33 @@ "\n", "Dimensions: (time: 36, x: 275, y: 205)\n", "Coordinates:\n", - " * time (time) datetime64[ns] 1980-09-16T12:00:00 1980-10-17 ...\n", - " yc (y, x) float64 16.53 16.78 17.02 17.27 17.51 17.76 18.0 18.25 ...\n", - " xc (y, x) float64 189.2 189.4 189.6 189.7 189.9 190.1 190.2 190.4 ...\n", - " * x (x) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...\n", - " * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...\n", + " * time (time) object 1980-09-16 12:00:00 ... 1983-08-17 00:00:00\n", + " xc (y, x) float64 189.2 189.4 189.6 189.7 ... 17.65 17.4 17.15 16.91\n", + " yc (y, x) float64 16.53 16.78 17.02 17.27 ... 28.26 28.01 27.76 27.51\n", + "Dimensions without coordinates: x, y\n", "Data variables:\n", - " Tair (time, y, x) float64 nan nan nan nan nan nan nan nan nan nan ...\n", + " Tair (time, y, x) float64 nan nan nan nan nan ... 29.8 28.66 28.19 28.21\n", "Attributes:\n", - " title: /workspace/jhamman/processed/R1002RBRxaaa01a/lnd/temp/R1002RBRxaaa01a.vic.ha.1979-09-01.nc\n", - " institution: U.W.\n", - " source: RACM R1002RBRxaaa01a\n", - " output_frequency: daily\n", - " output_mode: averaged\n", - " convention: CF-1.4\n", - " references: Based on the initial model of Liang et al., 1994, JGR, 99, 14,415- 14,429.\n", - " comment: Output from the Variable Infiltration Capacity (VIC) model.\n", - " nco_openmp_thread_number: 1\n", - " NCO: 4.3.7\n", - " history: history deleted for brevity" + " title: /workspace/jhamman/processed/R1002RBRxaaa01a/l...\n", + " institution: U.W.\n", + " source: RACM R1002RBRxaaa01a\n", + " output_frequency: daily\n", + " output_mode: averaged\n", + " convention: CF-1.4\n", + " references: Based on the initial model of Liang et al., 19...\n", + " comment: Output from the Variable Infiltration Capacity...\n", + " nco_openmp_thread_number: 1\n", + " NCO: \"4.6.0\"\n", + " history: Tue Dec 27 14:15:22 2016: ncatted -a dimension..." ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ds = xr.tutorial.load_dataset('rasm')\n", + "ds = xr.tutorial.open_dataset('rasm').load()\n", "ds" ] }, @@ -101,17 +116,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:50:15.836061Z", + "start_time": "2018-11-28T20:50:15.768376Z" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "OrderedDict([(u'long_name', u'longitude of grid cell center'), (u'units', u'degrees_east'), (u'bounds', u'xv')])\n", - "OrderedDict([(u'long_name', u'latitude of grid cell center'), (u'units', u'degrees_north'), (u'bounds', u'yv')])\n" + "OrderedDict([('long_name', 'longitude of grid cell center'), ('units', 'degrees_east'), ('bounds', 'xv')])\n", + "OrderedDict([('long_name', 'latitude of grid cell center'), ('units', 'degrees_north'), ('bounds', 'yv')])\n" ] } ], @@ -131,37 +149,34 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:50:17.928556Z", + "start_time": "2018-11-28T20:50:17.031211Z" + } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rpa/anaconda/lib/python2.7/site-packages/matplotlib/collections.py:590: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n", - " if self._edgecolors == str('face'):\n" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzQAAAEPCAYAAACUUIEwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEnVsqCRJEmSVK3/A9RZgXADtU/XAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -182,29 +197,34 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:50:20.567749Z", + "start_time": "2018-11-28T20:50:19.999393Z" + } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEZCAYAAABxbJkKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -221,19 +241,24 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:50:31.131708Z", + "start_time": "2018-11-28T20:50:30.444697Z" + } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAADgCAYAAABrY3uOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -257,29 +282,34 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:50:43.670463Z", + "start_time": "2018-11-28T20:50:43.245501Z" + } }, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEQCAYAAAC9VHPBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5DtUUetqbwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -289,7 +319,7 @@ "# define a label for each bin corresponding to the central latitude\n", "lat_center = np.arange(1,90,2)\n", "# group according to those bins and take the mean\n", - "Tair_lat_mean = ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center).mean()\n", + "Tair_lat_mean = ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center).mean(dim=xr.ALL_DIMS)\n", "# plot the result\n", "Tair_lat_mean.plot()" ] @@ -305,9 +335,9 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python [Root]", + "display_name": "Python 3", "language": "python", - "name": "Python [Root]" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -319,9 +349,22 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/examples/xarray_seasonal_means.ipynb b/examples/xarray_seasonal_means.ipynb index e3a77ebc1ae..ec58c4fa31f 100644 --- a/examples/xarray_seasonal_means.ipynb +++ b/examples/xarray_seasonal_means.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "

Table of Contents

\n", + "
" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -20,16 +30,19 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:35.958210Z", + "start_time": "2018-11-28T20:51:35.936966Z" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "numpy version : 1.11.1\n", - "pandas version : 0.18.1\n", - "xarray version : 0.8.2\n" + "numpy version : 1.14.3\n", + "pandas version : 0.23.4\n", + "xarray version : 0.11.0+10.gc01767ce\n" ] } ], @@ -57,7 +70,10 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:35.991620Z", + "start_time": "2018-11-28T20:51:35.960336Z" + } }, "outputs": [], "source": [ @@ -83,7 +99,10 @@ "cell_type": "code", "execution_count": 3, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.015151Z", + "start_time": "2018-11-28T20:51:35.994079Z" + } }, "outputs": [], "source": [ @@ -130,7 +149,10 @@ "cell_type": "code", "execution_count": 4, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.072316Z", + "start_time": "2018-11-28T20:51:36.016594Z" + } }, "outputs": [ { @@ -140,30 +162,29 @@ "\n", "Dimensions: (time: 36, x: 275, y: 205)\n", "Coordinates:\n", - " * time (time) datetime64[ns] 1980-09-16T12:00:00 1980-10-17 ...\n", - " * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...\n", - " * x (x) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...\n", + " * time (time) object 1980-09-16 12:00:00 ... 1983-08-17 00:00:00\n", + " xc (y, x) float64 189.2 189.4 189.6 189.7 ... 17.65 17.4 17.15 16.91\n", + " yc (y, x) float64 16.53 16.78 17.02 17.27 ... 28.26 28.01 27.76 27.51\n", + "Dimensions without coordinates: x, y\n", "Data variables:\n", - " Tair (time, y, x) float64 nan nan nan nan nan nan nan nan nan nan ...\n", - " yc (y, x) float64 16.53 16.78 17.02 17.27 17.51 17.76 18.0 18.25 ...\n", - " xc (y, x) float64 189.2 189.4 189.6 189.7 189.9 190.1 190.2 190.4 ...\n", + " Tair (time, y, x) float64 nan nan nan nan nan ... 29.8 28.66 28.19 28.21\n", "Attributes:\n", - " title: /workspace/jhamman/processed/R1002RBRxaaa01a/lnd/temp/R1002RBRxaaa01a.vic.ha.1979-09-01.nc\n", - " institution: U.W.\n", - " source: RACM R1002RBRxaaa01a\n", - " output_frequency: daily\n", - " output_mode: averaged\n", - " convention: CF-1.4\n", - " references: Based on the initial model of Liang et al., 1994, JGR, 99, 14,415- 14,429.\n", - " comment: Output from the Variable Infiltration Capacity (VIC) model.\n", - " nco_openmp_thread_number: 1\n", - " NCO: 4.3.7\n", - " history: history deleted for brevity\n" + " title: /workspace/jhamman/processed/R1002RBRxaaa01a/l...\n", + " institution: U.W.\n", + " source: RACM R1002RBRxaaa01a\n", + " output_frequency: daily\n", + " output_mode: averaged\n", + " convention: CF-1.4\n", + " references: Based on the initial model of Liang et al., 19...\n", + " comment: Output from the Variable Infiltration Capacity...\n", + " nco_openmp_thread_number: 1\n", + " NCO: \"4.6.0\"\n", + " history: Tue Dec 27 14:15:22 2016: ncatted -a dimension...\n" ] } ], "source": [ - "ds = xr.tutorial.load_dataset('rasm')\n", + "ds = xr.tutorial.open_dataset('rasm').load()\n", "print(ds)" ] }, @@ -183,7 +204,10 @@ "cell_type": "code", "execution_count": 5, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.132413Z", + "start_time": "2018-11-28T20:51:36.073708Z" + } }, "outputs": [], "source": [ @@ -206,7 +230,10 @@ "cell_type": "code", "execution_count": 6, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.152913Z", + "start_time": "2018-11-28T20:51:36.133997Z" + } }, "outputs": [ { @@ -216,13 +243,12 @@ "\n", "Dimensions: (season: 4, x: 275, y: 205)\n", "Coordinates:\n", - " * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...\n", - " * x (x) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...\n", + " xc (y, x) float64 189.2 189.4 189.6 189.7 ... 17.65 17.4 17.15 16.91\n", + " yc (y, x) float64 16.53 16.78 17.02 17.27 ... 28.26 28.01 27.76 27.51\n", " * season (season) object 'DJF' 'JJA' 'MAM' 'SON'\n", + "Dimensions without coordinates: x, y\n", "Data variables:\n", - " Tair (season, y, x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ...\n", - " xc (season, y, x) float64 189.2 189.4 189.6 189.7 189.9 190.1 ...\n", - " yc (season, y, x) float64 16.53 16.78 17.02 17.27 17.51 17.76 18.0 ...\n" + " Tair (season, y, x) float64 0.0 0.0 0.0 0.0 ... 23.15 22.08 21.73 21.96\n" ] } ], @@ -234,9 +260,21 @@ "cell_type": "code", "execution_count": 7, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:36.190765Z", + "start_time": "2018-11-28T20:51:36.154416Z" + } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/deepak/work/python/xarray/xarray/core/nanops.py:161: RuntimeWarning: Mean of empty slice\n", + " return np.nanmean(a, axis=axis, dtype=dtype)\n" + ] + } + ], "source": [ "# only used for comparisons\n", "ds_unweighted = ds.groupby('time.season').mean('time')\n", @@ -247,13 +285,16 @@ "cell_type": "code", "execution_count": 8, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:40.264871Z", + "start_time": "2018-11-28T20:51:36.192467Z" + } }, "outputs": [ { "data": { "text/plain": [ - "" + "Text(0.5, 1.02, 'Seasonal Surface Air Temperature')" ] }, "execution_count": 8, @@ -262,12 +303,14 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+IAAAN0CAYAAAAwJZIVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngoI7iP8P2XQXZRGqJyoAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -312,7 +355,10 @@ "cell_type": "code", "execution_count": 9, "metadata": { - "collapsed": false + "ExecuteTime": { + "end_time": "2018-11-28T20:51:40.284898Z", + "start_time": "2018-11-28T20:51:40.266406Z" + } }, "outputs": [], "source": [ @@ -338,9 +384,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } @@ -348,9 +392,9 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python [Root]", + "display_name": "Python 3", "language": "python", - "name": "Python [Root]" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -362,9 +406,22 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } From 3ae93ac31ce122fc10b089f3b92b8c20e8b218c9 Mon Sep 17 00:00:00 2001 From: Ryan Abernathey Date: Tue, 4 Dec 2018 18:51:00 -0500 Subject: [PATCH 009/108] Zarr consolidated (#2559) * wip: getting started * preliminary support for zarr consolidated metadata * update zarr dev repo * add consolidate to close * doc updates * skip tests based on zarr version * fix doc typos * fix PEP8 issues * fix test skipping * fixed integration test * update version check * rename keyword arg * Update whats-new.rst * instructions for consolidating existing stores --- ci/requirements-py36-zarr-dev.yml | 2 +- doc/io.rst | 31 +++++++++++++++++++++++++- doc/whats-new.rst | 14 +++++++----- xarray/backends/api.py | 20 ++++++++++------- xarray/backends/zarr.py | 37 ++++++++++++++++++++++++------- xarray/core/dataset.py | 20 ++++++++++++----- xarray/tests/test_backends.py | 9 ++++++++ xarray/tests/test_distributed.py | 20 +++++++++++++---- 8 files changed, 119 insertions(+), 34 deletions(-) diff --git a/ci/requirements-py36-zarr-dev.yml b/ci/requirements-py36-zarr-dev.yml index 7fbce63aa81..6ed466ba5cb 100644 --- a/ci/requirements-py36-zarr-dev.yml +++ b/ci/requirements-py36-zarr-dev.yml @@ -18,4 +18,4 @@ dependencies: - pip: - coveralls - pytest-cov - - git+https://github.com/alimanfoo/zarr.git + - git+https://github.com/zarr-developers/zarr.git diff --git a/doc/io.rst b/doc/io.rst index e841e665308..682fbf5202e 100644 --- a/doc/io.rst +++ b/doc/io.rst @@ -635,6 +635,35 @@ For example: Not all native zarr compression and filtering options have been tested with xarray. +Consolidated Metadata +~~~~~~~~~~~~~~~~~~~~~ + +Xarray needs to read all of the zarr metadata when it opens a dataset. +In some storage mediums, such as with cloud object storage (e.g. amazon S3), +this can introduce significant overhead, because two separate HTTP calls to the +object store must be made for each variable in the dataset. +With version 2.3, zarr will support a feature called *consolidated metadata*, +which allows all metadata for the entire dataset to be stored with a single +key (by default called ``.zmetadata``). This can drastically speed up +opening the store. (For more information on this feature, consult the +`zarr docs `_.) + +If you have zarr version 2.3 or greater, xarray can write and read stores +with consolidated metadata. To write consolidated metadata, pass the +``consolidated=True`` option to the +:py:attr:`Dataset.to_zarr ` method:: + + ds.to_zarr('foo.zarr', consolidated=True) + +To read a consolidated store, pass the ``consolidated=True`` option to +:py:func:`~xarray.open_zarr`:: + + ds = xr.open_zarr('foo.zarr', consolidated=True) + +Xarray can't perform consolidation on pre-existing zarr datasets. This should +be done directly from zarr, as described in the +`zarr docs `_. + .. _io.cfgrib: GRIB format via cfgrib @@ -678,7 +707,7 @@ Formats supported by PseudoNetCDF --------------------------------- xarray can also read CAMx, BPCH, ARL PACKED BIT, and many other file -formats supported by PseudoNetCDF_, if PseudoNetCDF is installed. +formats supported by PseudoNetCDF_, if PseudoNetCDF is installed. PseudoNetCDF can also provide Climate Forecasting Conventions to CMAQ files. In addition, PseudoNetCDF can automatically register custom readers that subclass PseudoNetCDF.PseudoNetCDFFile. PseudoNetCDF can diff --git a/doc/whats-new.rst b/doc/whats-new.rst index b1d5b92da4d..040f72acb56 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -36,6 +36,8 @@ Breaking changes Enhancements ~~~~~~~~~~~~ +- Ability to read and write consolidated metadata in zarr stores (:issue:`2558`). + By `Ryan Abernathey `_. - :py:class:`CFTimeIndex` uses slicing for string indexing when possible (like :py:class:`pandas.DatetimeIndex`), which avoids unnecessary copies. By `Stephan Hoyer `_ @@ -56,15 +58,15 @@ Breaking changes - ``Dataset.T`` has been removed as a shortcut for :py:meth:`Dataset.transpose`. Call :py:meth:`Dataset.transpose` directly instead. - Iterating over a ``Dataset`` now includes only data variables, not coordinates. - Similarily, calling ``len`` and ``bool`` on a ``Dataset`` now + Similarily, calling ``len`` and ``bool`` on a ``Dataset`` now includes only data variables. - ``DataArray.__contains__`` (used by Python's ``in`` operator) now checks - array data, not coordinates. + array data, not coordinates. - The old resample syntax from before xarray 0.10, e.g., ``data.resample('1D', dim='time', how='mean')``, is no longer supported will raise an error in most cases. You need to use the new resample syntax instead, e.g., ``data.resample(time='1D').mean()`` or - ``data.resample({'time': '1D'}).mean()``. + ``data.resample({'time': '1D'}).mean()``. - New deprecations (behavior will be changed in xarray 0.12): @@ -101,13 +103,13 @@ Breaking changes than by default trying to coerce them into ``np.datetime64[ns]`` objects. A :py:class:`~xarray.CFTimeIndex` will be used for indexing along time coordinates in these cases. - - A new method :py:meth:`~xarray.CFTimeIndex.to_datetimeindex` has been added + - A new method :py:meth:`~xarray.CFTimeIndex.to_datetimeindex` has been added to aid in converting from a :py:class:`~xarray.CFTimeIndex` to a :py:class:`pandas.DatetimeIndex` for the remaining use-cases where using a :py:class:`~xarray.CFTimeIndex` is still a limitation (e.g. for resample or plotting). - Setting the ``enable_cftimeindex`` option is now a no-op and emits a - ``FutureWarning``. + ``FutureWarning``. Enhancements ~~~~~~~~~~~~ @@ -194,7 +196,7 @@ Bug fixes the dates must be encoded using cftime rather than NumPy (:issue:`2272`). By `Spencer Clark `_. -- Chunked datasets can now roundtrip to Zarr storage continually +- Chunked datasets can now roundtrip to Zarr storage continually with `to_zarr` and ``open_zarr`` (:issue:`2300`). By `Lily Wang `_. diff --git a/xarray/backends/api.py b/xarray/backends/api.py index c1ace7774f9..f2b6bc196a0 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -861,7 +861,7 @@ def save_mfdataset(datasets, paths, mode='w', format=None, groups=None, def to_zarr(dataset, store=None, mode='w-', synchronizer=None, group=None, - encoding=None, compute=True): + encoding=None, compute=True, consolidated=False): """This function creates an appropriate datastore for writing a dataset to a zarr ztore @@ -876,16 +876,20 @@ def to_zarr(dataset, store=None, mode='w-', synchronizer=None, group=None, _validate_dataset_names(dataset) _validate_attrs(dataset) - store = backends.ZarrStore.open_group(store=store, mode=mode, - synchronizer=synchronizer, - group=group) + zstore = backends.ZarrStore.open_group(store=store, mode=mode, + synchronizer=synchronizer, + group=group, + consolidate_on_close=consolidated) writer = ArrayWriter() # TODO: figure out how to properly handle unlimited_dims - dump_to_store(dataset, store, writer, encoding=encoding) + dump_to_store(dataset, zstore, writer, encoding=encoding) writes = writer.sync(compute=compute) - if not compute: + if compute: + _finalize_store(writes, zstore) + else: import dask - return dask.delayed(_finalize_store)(writes, store) - return store + return dask.delayed(_finalize_store)(writes, zstore) + + return zstore diff --git a/xarray/backends/zarr.py b/xarray/backends/zarr.py index 06fe7f04e4f..05e445a1e88 100644 --- a/xarray/backends/zarr.py +++ b/xarray/backends/zarr.py @@ -224,7 +224,8 @@ class ZarrStore(AbstractWritableDataStore): """ @classmethod - def open_group(cls, store, mode='r', synchronizer=None, group=None): + def open_group(cls, store, mode='r', synchronizer=None, group=None, + consolidated=False, consolidate_on_close=False): import zarr min_zarr = '2.2' @@ -234,15 +235,27 @@ def open_group(cls, store, mode='r', synchronizer=None, group=None): "installation " "http://zarr.readthedocs.io/en/stable/" "#installation" % min_zarr) - zarr_group = zarr.open_group(store=store, mode=mode, - synchronizer=synchronizer, path=group) - return cls(zarr_group) - def __init__(self, zarr_group): + if consolidated or consolidate_on_close: + if LooseVersion(zarr.__version__) <= '2.2.1.dev2': # pragma: no cover + raise NotImplementedError("Zarr version 2.2.1.dev2 or greater " + "is required by for consolidated " + "metadata.") + + open_kwargs = dict(mode=mode, synchronizer=synchronizer, path=group) + if consolidated: + # TODO: an option to pass the metadata_key keyword + zarr_group = zarr.open_consolidated(store, **open_kwargs) + else: + zarr_group = zarr.open_group(store, **open_kwargs) + return cls(zarr_group, consolidate_on_close) + + def __init__(self, zarr_group, consolidate_on_close=False): self.ds = zarr_group self._read_only = self.ds.read_only self._synchronizer = self.ds.synchronizer self._group = self.ds.path + self._consolidate_on_close = consolidate_on_close def open_store_variable(self, name, zarr_array): data = indexing.LazilyOuterIndexedArray(ZarrArrayWrapper(name, self)) @@ -333,11 +346,16 @@ def store(self, variables, attributes, *args, **kwargs): def sync(self): pass + def close(self): + if self._consolidate_on_close: + import zarr + zarr.consolidate_metadata(self.ds.store) + def open_zarr(store, group=None, synchronizer=None, auto_chunk=True, decode_cf=True, mask_and_scale=True, decode_times=True, concat_characters=True, decode_coords=True, - drop_variables=None): + drop_variables=None, consolidated=False): """Load and decode a dataset from a Zarr store. .. note:: Experimental @@ -383,10 +401,13 @@ def open_zarr(store, group=None, synchronizer=None, auto_chunk=True, decode_coords : bool, optional If True, decode the 'coordinates' attribute to identify coordinates in the resulting dataset. - drop_variables: string or iterable, optional + drop_variables : string or iterable, optional A variable or list of variables to exclude from being parsed from the dataset. This may be useful to drop variables with problems or inconsistent values. + consolidated : bool, optional + Whether to open the store using zarr's consolidated metadata + capability. Only works for stores that have already been consolidated. Returns ------- @@ -423,7 +444,7 @@ def maybe_decode_store(store, lock=False): mode = 'r' zarr_store = ZarrStore.open_group(store, mode=mode, synchronizer=synchronizer, - group=group) + group=group, consolidated=consolidated) ds = maybe_decode_store(zarr_store) # auto chunking needs to be here and not in ZarrStore because variable diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 4f9c61b3269..c289703875d 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -1222,7 +1222,7 @@ def to_netcdf(self, path=None, mode='w', format=None, group=None, compute=compute) def to_zarr(self, store=None, mode='w-', synchronizer=None, group=None, - encoding=None, compute=True): + encoding=None, compute=True, consolidated=False): """Write dataset contents to a zarr group. .. note:: Experimental @@ -1244,9 +1244,16 @@ def to_zarr(self, store=None, mode='w-', synchronizer=None, group=None, Nested dictionary with variable names as keys and dictionaries of variable specific encodings as values, e.g., ``{'my_variable': {'dtype': 'int16', 'scale_factor': 0.1,}, ...}`` - compute: boolean - If true compute immediately, otherwise return a + compute: bool, optional + If True compute immediately, otherwise return a ``dask.delayed.Delayed`` object that can be computed later. + consolidated: bool, optional + If True, apply zarr's `consolidate_metadata` function to the store + after writing. + + References + ---------- + https://zarr.readthedocs.io/ """ if encoding is None: encoding = {} @@ -1256,7 +1263,8 @@ def to_zarr(self, store=None, mode='w-', synchronizer=None, group=None, "and 'w-'.") from ..backends.api import to_zarr return to_zarr(self, store=store, mode=mode, synchronizer=synchronizer, - group=group, encoding=encoding, compute=compute) + group=group, encoding=encoding, compute=compute, + consolidated=consolidated) def __unicode__(self): return formatting.dataset_repr(self) @@ -1380,7 +1388,7 @@ def _validate_indexers(self, indexers): """ Here we make sure + indexer has a valid keys + indexer is in a valid data type - + string indexers are cast to the appropriate date type if the + + string indexers are cast to the appropriate date type if the associated index is a DatetimeIndex or CFTimeIndex """ from .dataarray import DataArray @@ -1963,7 +1971,7 @@ def _validate_interp_indexer(x, new_x): 'Instead got\n{}'.format(new_x)) else: return (x, new_x) - + variables = OrderedDict() for name, var in iteritems(obj._variables): if name not in indexers: diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index fb9c43c0165..2361b8c2236 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -1320,6 +1320,15 @@ def roundtrip_append(self, data, save_kwargs={}, open_kwargs={}, allow_cleanup_failure=False): pytest.skip("zarr backend does not support appending") + def test_roundtrip_consolidated(self): + zarr = pytest.importorskip('zarr', minversion="2.2.1.dev2") + expected = create_test_data() + with self.roundtrip(expected, + save_kwargs={'consolidated': True}, + open_kwargs={'consolidated': True}) as actual: + self.check_dtypes_roundtripped(expected, actual) + assert_identical(expected, actual) + def test_auto_chunk(self): original = create_test_data().chunk() diff --git a/xarray/tests/test_distributed.py b/xarray/tests/test_distributed.py index 1837a0fe4ef..bd62b8d906d 100644 --- a/xarray/tests/test_distributed.py +++ b/xarray/tests/test_distributed.py @@ -1,5 +1,6 @@ """ isort:skip_file """ from __future__ import absolute_import, division, print_function +from distutils.version import LooseVersion import os import sys import pickle @@ -118,15 +119,26 @@ def test_dask_distributed_read_netcdf_integration_test( @requires_zarr -def test_dask_distributed_zarr_integration_test(loop): +@pytest.mark.parametrize('consolidated', [True, False]) +@pytest.mark.parametrize('compute', [True, False]) +def test_dask_distributed_zarr_integration_test(loop, consolidated, compute): + if consolidated: + zarr = pytest.importorskip('zarr', minversion="2.2.1.dev2") + write_kwargs = dict(consolidated=True) + read_kwargs = dict(consolidated=True) + else: + write_kwargs = read_kwargs = {} chunks = {'dim1': 4, 'dim2': 3, 'dim3': 5} with cluster() as (s, [a, b]): with Client(s['address'], loop=loop) as c: original = create_test_data().chunk(chunks) with create_tmp_file(allow_cleanup_failure=ON_WINDOWS, - suffix='.zarr') as filename: - original.to_zarr(filename) - with xr.open_zarr(filename) as restored: + suffix='.zarrc') as filename: + maybe_futures = original.to_zarr(filename, compute=compute, + **write_kwargs) + if not compute: + maybe_futures.compute() + with xr.open_zarr(filename, **read_kwargs) as restored: assert isinstance(restored.var1.data, da.Array) computed = restored.compute() assert_allclose(original, computed) From 77634d451ff57b95f33d76da73020df4a68eeed9 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sun, 9 Dec 2018 11:18:24 -0800 Subject: [PATCH 010/108] Minor update to PR template (#2596) This version should be a little less noisy, since instructions only for authors are put in commented out HTML. --- .github/PULL_REQUEST_TEMPLATE.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index d1c79953a9b..9d4024a69f6 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -1,3 +1,5 @@ - - [ ] Closes #xxxx (remove if there is no corresponding issue, which should only be the case for minor changes) - - [ ] Tests added (for all bug fixes or enhancements) - - [ ] Fully documented, including `whats-new.rst` for all changes and `api.rst` for new API (remove if this change should not be visible to users, e.g., if it is an internal clean-up, or if this is part of a larger project that will be documented later) + + + - [ ] Closes #xxxx + - [ ] Tests added + - [ ] Fully documented, including `whats-new.rst` for all changes and `api.rst` for new API From 53746c962701a864255f15e69e5ab5fec4cf908c Mon Sep 17 00:00:00 2001 From: Martin Raspaud Date: Tue, 11 Dec 2018 08:24:35 +0100 Subject: [PATCH 011/108] Fix h5netcdf saving scalars with filters or chunks (#2591) * Fix h5netcdf saving scalars with filters or chunks * Revert adding scalar dataset to central test function * Add fix description to what's new. --- doc/whats-new.rst | 3 +++ xarray/backends/h5netcdf_.py | 10 ++++++---- xarray/tests/test_backends.py | 2 ++ 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 040f72acb56..e4d204497ef 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -45,6 +45,9 @@ Enhancements Bug fixes ~~~~~~~~~ +- Fix h5netcdf saving scalars with filters or chunks (:issue:`2563`). + By `Martin Raspaud `_. + .. _whats-new.0.11.0: v0.11.0 (7 November 2018) diff --git a/xarray/backends/h5netcdf_.py b/xarray/backends/h5netcdf_.py index 59cd4e84793..90f63e88cde 100644 --- a/xarray/backends/h5netcdf_.py +++ b/xarray/backends/h5netcdf_.py @@ -208,10 +208,12 @@ def prepare_variable(self, name, variable, check_encoding=False, encoding['chunks'] = encoding.pop('chunksizes', None) - for key in ['compression', 'compression_opts', 'shuffle', - 'chunks', 'fletcher32']: - if key in encoding: - kwargs[key] = encoding[key] + # Do not apply compression, filters or chunking to scalars. + if variable.shape: + for key in ['compression', 'compression_opts', 'shuffle', + 'chunks', 'fletcher32']: + if key in encoding: + kwargs[key] = encoding[key] if name not in self.ds: nc4_var = self.ds.create_variable( name, dtype=dtype, dimensions=variable.dims, diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 2361b8c2236..0ce3bd7290d 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -1840,6 +1840,8 @@ def test_compression_encoding_h5py(self): data['var2'].encoding.update(compr_in) data['var2'].encoding.update(compr_common) compr_out.update(compr_common) + data['scalar'] = ('scalar_dim', np.array([2.0])) + data['scalar'] = data['scalar'][0] with self.roundtrip(data) as actual: for k, v in compr_out.items(): assert v == actual['var2'].encoding[k] From 5d8ef5f885f7dc1cff5a34ab0e0aec1b4c2e3798 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Tue, 11 Dec 2018 14:28:30 -0500 Subject: [PATCH 012/108] Add dayofyear and dayofweek accessors (#2599) --- doc/time-series.rst | 6 ++++-- doc/whats-new.rst | 3 +++ xarray/coding/cftimeindex.py | 3 +++ xarray/tests/test_accessors.py | 9 ++++++--- xarray/tests/test_cftimeindex.py | 14 ++++++++++++++ 5 files changed, 30 insertions(+), 5 deletions(-) diff --git a/doc/time-series.rst b/doc/time-series.rst index c225c246a8c..7f5389d3ae1 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -263,14 +263,16 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: da.sel(time=slice('0001-05', '0002-02')) - Access of basic datetime components via the ``dt`` accessor (in this case - just "year", "month", "day", "hour", "minute", "second", "microsecond", and - "season"): + just "year", "month", "day", "hour", "minute", "second", "microsecond", + "season", "dayofyear", and "dayofweek"): .. ipython:: python da.time.dt.year da.time.dt.month da.time.dt.season + da.time.dt.dayofyear + da.time.dt.dayofweek - Group-by operations based on datetime accessor attributes (e.g. by month of the year): diff --git a/doc/whats-new.rst b/doc/whats-new.rst index e4d204497ef..0fb8013d30f 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -41,6 +41,9 @@ Enhancements - :py:class:`CFTimeIndex` uses slicing for string indexing when possible (like :py:class:`pandas.DatetimeIndex`), which avoids unnecessary copies. By `Stephan Hoyer `_ +- Like :py:class:`pandas.DatetimeIndex`, :py:class:`CFTimeIndex` now supports + "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark + `_. Bug fixes ~~~~~~~~~ diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 71fa7f2fa6b..98954e9af0c 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -207,6 +207,9 @@ class CFTimeIndex(pd.Index): second = _field_accessor('second', 'The seconds of the datetime') microsecond = _field_accessor('microsecond', 'The microseconds of the datetime') + dayofyear = _field_accessor('dayofyr', + 'The ordinal day of year of the datetime') + dayofweek = _field_accessor('dayofwk', 'The day of week of the datetime') date_type = property(get_date_type) def __new__(cls, data, name=None): diff --git a/xarray/tests/test_accessors.py b/xarray/tests/test_accessors.py index 38038fc8f65..37b9c272e6e 100644 --- a/xarray/tests/test_accessors.py +++ b/xarray/tests/test_accessors.py @@ -158,7 +158,8 @@ def times_3d(times): @pytest.mark.skipif(not has_cftime, reason='cftime not installed') -@pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour']) +@pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour', + 'dayofyear', 'dayofweek']) def test_field_access(data, field): result = getattr(data.time.dt, field) expected = xr.DataArray( @@ -170,7 +171,8 @@ def test_field_access(data, field): @pytest.mark.skipif(not has_dask, reason='dask not installed') @pytest.mark.skipif(not has_cftime, reason='cftime not installed') -@pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour']) +@pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour', + 'dayofyear', 'dayofweek']) def test_dask_field_access_1d(data, field): import dask.array as da @@ -186,7 +188,8 @@ def test_dask_field_access_1d(data, field): @pytest.mark.skipif(not has_dask, reason='dask not installed') @pytest.mark.skipif(not has_cftime, reason='cftime not installed') -@pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour']) +@pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour', 'dayofyear', + 'dayofweek']) def test_dask_field_access(times_3d, data, field): import dask.array as da diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index b9006774c30..ea41115937b 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -175,6 +175,20 @@ def test_cftimeindex_field_accessors(index, field, expected): assert_array_equal(result, expected) +@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +def test_cftimeindex_dayofyear_accessor(index): + result = index.dayofyear + expected = [date.dayofyr for date in index] + assert_array_equal(result, expected) + + +@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +def test_cftimeindex_dayofweek_accessor(index): + result = index.dayofweek + expected = [date.dayofwk for date in index] + assert_array_equal(result, expected) + + @pytest.mark.skipif(not has_cftime, reason='cftime not installed') @pytest.mark.parametrize(('string', 'date_args', 'reso'), [ ('1999', (1999, 1, 1), 'year'), From 688150309c78eaf09e4ae8662ec615cac7ca843b Mon Sep 17 00:00:00 2001 From: lumbric Date: Tue, 11 Dec 2018 20:29:03 +0100 Subject: [PATCH 013/108] Fix wrong error message in interp() (#2598) --- xarray/core/dataset.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index c289703875d..888d2566f21 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -1946,7 +1946,7 @@ def interp(self, coords=None, method='linear', assume_sorted=False, """ from . import missing - coords = either_dict_or_kwargs(coords, coords_kwargs, 'rename') + coords = either_dict_or_kwargs(coords, coords_kwargs, 'interp') indexers = OrderedDict(self._validate_indexers(coords)) obj = self if assume_sorted else self.sortby([k for k in coords]) From 23483adfce9cccae5d85ae3e9fa2ca6b721c6815 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Tue, 11 Dec 2018 19:13:29 -0800 Subject: [PATCH 014/108] Temporarily mark dask-dev build as an allowed failure (#2602) --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index defb37ec8aa..4ebd4f392a9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -44,6 +44,7 @@ matrix: - libhdf5-serial-dev - netcdf-bin - libnetcdf-dev + - env: CONDA_ENV=py36-dask-dev - env: CONDA_ENV=py36-pandas-dev - env: CONDA_ENV=py36-bottleneck-dev - env: CONDA_ENV=py36-condaforge-rc From 82789bc6f72a76d69ace4bbabd00601e28e808da Mon Sep 17 00:00:00 2001 From: MBlaschek Date: Wed, 12 Dec 2018 18:11:21 +0100 Subject: [PATCH 015/108] use keep_attrs in binary operations II (#2590) * Add keep_attrs to binary_op * added test for binary_ops keep_attrs=True * PEP8 issues + blank lines removed * whitespace removed * keep_attrs in DataArray * enhancement * simpler testing --- doc/whats-new.rst | 5 ++++- xarray/core/variable.py | 4 +++- xarray/tests/test_variable.py | 14 ++++++++++++++ 3 files changed, 21 insertions(+), 2 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 0fb8013d30f..87a0e425693 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -45,6 +45,7 @@ Enhancements "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark `_. + Bug fixes ~~~~~~~~~ @@ -158,7 +159,9 @@ Enhancements to returning (and is now deprecated). This was changed in order to facilitate using tutorial datasets with dask. By `Joe Hamman `_. - +- ``DataArray`` can now use ``xr.set_option(keep_attrs=True)`` and retain attributes in binary operations, + such as (``+, -, * ,/``). Default behaviour is unchanged (*Attributes will be dismissed*). By `Michael Blaschek `_ + Bug fixes ~~~~~~~~~ diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 0bff06e7546..7a921805258 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -1658,11 +1658,13 @@ def func(self, other): if isinstance(other, (xr.DataArray, xr.Dataset)): return NotImplemented self_data, other_data, dims = _broadcast_compat_data(self, other) + keep_attrs = _get_keep_attrs(default=False) + attrs = self._attrs if keep_attrs else None with np.errstate(all='ignore'): new_data = (f(self_data, other_data) if not reflexive else f(other_data, self_data)) - result = Variable(dims, new_data) + result = Variable(dims, new_data, attrs=attrs) return result return func diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 0bd440781ac..84813f6c918 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -28,6 +28,8 @@ assert_allclose, assert_array_equal, assert_equal, assert_identical, raises_regex, requires_dask, source_ndarray) +from xarray import set_options + class VariableSubclassobjects(object): def test_properties(self): @@ -1545,6 +1547,18 @@ def test_reduce_keep_attrs(self): assert len(vm.attrs) == len(_attrs) assert vm.attrs == _attrs + def test_binary_ops_keep_attrs(self): + _attrs = {'units': 'test', 'long_name': 'testing'} + a = Variable(['x', 'y'], np.random.randn(3, 3), _attrs) + b = Variable(['x', 'y'], np.random.randn(3, 3), _attrs) + # Test dropped attrs + d = a - b # just one operation + assert d.attrs == OrderedDict() + # Test kept attrs + with set_options(keep_attrs=True): + d = a - b + assert d.attrs == _attrs + def test_count(self): expected = Variable([], 3) actual = Variable(['x'], [1, 2, 3, np.nan]).count() From cbb32e16079ad56555ffa816cd880fb2ef803315 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Thu, 13 Dec 2018 12:12:37 -0500 Subject: [PATCH 016/108] Bump cftime version in doc environment (#2604) --- doc/environment.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/environment.yml b/doc/environment.yml index bd134a7656f..ca4f622cd38 100644 --- a/doc/environment.yml +++ b/doc/environment.yml @@ -16,7 +16,7 @@ dependencies: - zarr=2.2.0 - iris=2.1.0 - flake8=3.5.0 - - cftime=1.0.0 + - cftime=1.0.3.4 - bottleneck=1.2 - sphinx=1.7.6 - numpydoc=0.8.0 From 2223445905705162053756323dfd6e6f4527b270 Mon Sep 17 00:00:00 2001 From: Matthew Rocklin Date: Thu, 13 Dec 2018 12:12:59 -0500 Subject: [PATCH 017/108] Support HighLevelGraphs (#2603) * Support HighLevelGraphs Fixes #4291 * test __dask_layers__ * Skip dependnecies test with old dask * Reenable dask-dev test on Travis-CI --- .travis.yml | 1 - doc/whats-new.rst | 7 ++++--- xarray/core/dataarray.py | 3 +++ xarray/core/dataset.py | 14 ++++++++++++-- xarray/core/variable.py | 3 +++ xarray/tests/test_dask.py | 13 +++++++++++++ 6 files changed, 35 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 4ebd4f392a9..defb37ec8aa 100644 --- a/.travis.yml +++ b/.travis.yml @@ -44,7 +44,6 @@ matrix: - libhdf5-serial-dev - netcdf-bin - libnetcdf-dev - - env: CONDA_ENV=py36-dask-dev - env: CONDA_ENV=py36-pandas-dev - env: CONDA_ENV=py36-bottleneck-dev - env: CONDA_ENV=py36-condaforge-rc diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 87a0e425693..9273292255b 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -43,7 +43,8 @@ Enhancements By `Stephan Hoyer `_ - Like :py:class:`pandas.DatetimeIndex`, :py:class:`CFTimeIndex` now supports "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark - `_. + `_. +- Support Dask ``HighLevelGraphs`` by `Matthew Rocklin `_. Bug fixes @@ -159,9 +160,9 @@ Enhancements to returning (and is now deprecated). This was changed in order to facilitate using tutorial datasets with dask. By `Joe Hamman `_. -- ``DataArray`` can now use ``xr.set_option(keep_attrs=True)`` and retain attributes in binary operations, +- ``DataArray`` can now use ``xr.set_option(keep_attrs=True)`` and retain attributes in binary operations, such as (``+, -, * ,/``). Default behaviour is unchanged (*Attributes will be dismissed*). By `Michael Blaschek `_ - + Bug fixes ~~~~~~~~~ diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 17af3cf2cd1..938b05f963b 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -587,6 +587,9 @@ def __dask_graph__(self): def __dask_keys__(self): return self._to_temp_dataset().__dask_keys__() + def __dask_layers__(self): + return self._to_temp_dataset().__dask_layers__() + @property def __dask_optimize__(self): return self._to_temp_dataset().__dask_optimize__ diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 888d2566f21..8f28798a8a9 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -509,14 +509,24 @@ def __dask_graph__(self): if not graphs: return None else: - from dask import sharedict - return sharedict.merge(*graphs.values()) + try: + from dask.highlevelgraph import HighLevelGraph + return HighLevelGraph.merge(*graphs.values()) + except ImportError: + from dask import sharedict + return sharedict.merge(*graphs.values()) + def __dask_keys__(self): import dask return [v.__dask_keys__() for v in self.variables.values() if dask.is_dask_collection(v)] + def __dask_layers__(self): + import dask + return sum([v.__dask_layers__() for v in self.variables.values() if + dask.is_dask_collection(v)], ()) + @property def __dask_optimize__(self): import dask.array as da diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 7a921805258..469e8741a29 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -352,6 +352,9 @@ def __dask_graph__(self): def __dask_keys__(self): return self._data.__dask_keys__() + def __dask_layers__(self): + return self._data.__dask_layers__() + @property def __dask_optimize__(self): return self._data.__dask_optimize__ diff --git a/xarray/tests/test_dask.py b/xarray/tests/test_dask.py index 62ce7d074fa..c77384c5733 100644 --- a/xarray/tests/test_dask.py +++ b/xarray/tests/test_dask.py @@ -843,3 +843,16 @@ def test_basic_compute(): ds.compute() ds.foo.compute() ds.foo.variable.compute() + + +@pytest.mark.skipif(LooseVersion(dask.__version__) < LooseVersion('0.20.0'), + reason='needs newer dask') +def test_dask_layers_and_dependencies(): + ds = Dataset({'foo': ('x', range(5)), + 'bar': ('x', range(5))}).chunk() + + x = dask.delayed(ds) + assert set(x.__dask_graph__().dependencies).issuperset( + ds.__dask_graph__().dependencies) + assert set(x.foo.__dask_graph__().dependencies).issuperset( + ds.__dask_graph__().dependencies) From 9e8707d2041cfa038c31fc2284c1fe40bc3368e9 Mon Sep 17 00:00:00 2001 From: Tom Nicholas <35968931+TomNicholas@users.noreply.github.com> Date: Thu, 13 Dec 2018 17:15:56 +0000 Subject: [PATCH 018/108] Feature: N-dimensional auto_combine (#2553) * concatenates along a single dimension * Wrote function to find correct tile_IDs from nested list of datasets * Wrote function to check that combined_tile_ids structure is valid * Added test of 2d-concatenation * Tests now check that dataset ordering is correct * Test concatentation along a new dimension * Started generalising auto_combine to N-D by integrating the N-D concatentation algorithm * All unit tests now passing * Fixed a failing test which I didn't notice because I don't have pseudoNetCDF * Began updating open_mfdataset to handle N-D input * Refactored to remove duplicate logic in open_mfdataset & auto_combine * Implemented Shoyers suggestion in #2553 to rewrite the recursive nested list traverser as an iterator * --amend * Now raises ValueError if input not ordered correctly before concatenation * Added some more prototype tests defining desired behaviour more clearly * Now raises informative errors on invalid forms of input * Refactoring to alos merge along each dimension * Refactored to literally just apply the old auto_combine along each dimension * Added unit tests for open_mfdatset * Removed TODOs * Removed format strings * test_get_new_tile_ids now doesn't assume dicts are ordered * Fixed failing tests on python3.5 caused by accidentally assuming dict was ordered * Test for getting new tile id * Fixed itertoolz import so that it's compatible with older versions * Increased test coverage * Added toolz as an explicit dependency to pass tests on python2.7 * Updated 'what's new' * No longer attempts to shortcut all concatenation at once if concat_dims=None * Rewrote using itertools.groupby instead of toolz.itertoolz.groupby to remove hidden dependency on toolz * Fixed erroneous removal of utils import * Updated docstrings to include an example of multidimensional concatenation * Clarified auto_combine docstring for N-D behaviour * Added unit test for nested list of Datasets with different variables * Minor spelling and pep8 fixes * Reverted API so that N-D generalisation is hidden * Removed infer_order_from_coords argument --- doc/whats-new.rst | 2 +- xarray/backends/api.py | 43 +++-- xarray/core/combine.py | 222 ++++++++++++++++++++--- xarray/testing.py | 8 + xarray/tests/__init__.py | 2 +- xarray/tests/test_backends.py | 71 +++++++- xarray/tests/test_combine.py | 323 ++++++++++++++++++++++++++++++++-- 7 files changed, 623 insertions(+), 48 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 9273292255b..91ee0d75aaa 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -21,7 +21,7 @@ What's New always be available to python 2.7 users. For more information see the following references - - `Xarray Github issue discussing dropping Python 2 `__ + - `Xarray Github issue discussing dropping Python 2 `__ - `Python 3 Statement `__ - `Tips on porting to Python 3 `__ diff --git a/xarray/backends/api.py b/xarray/backends/api.py index f2b6bc196a0..aa1439d2510 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -10,7 +10,7 @@ from .. import Dataset, backends, conventions from ..core import indexing -from ..core.combine import auto_combine +from ..core.combine import _infer_concat_order_from_positions, _auto_combine from ..core.pycompat import basestring, path_type from ..core.utils import close_on_error, is_remote_uri, is_grib_path from .common import ArrayWriter @@ -485,10 +485,8 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, lock=None, data_vars='all', coords='different', autoclose=None, parallel=False, **kwargs): """Open multiple files as a single dataset. - Requires dask to be installed. See documentation for details on dask [1]. Attributes from the first dataset file are used for the combined dataset. - Parameters ---------- paths : str or sequence @@ -515,7 +513,6 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts when merging: - - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'equals': all values and dimensions must be the same. @@ -578,6 +575,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, References ---------- + .. [1] http://xarray.pydata.org/en/stable/dask.html .. [2] http://xarray.pydata.org/en/stable/dask.html#chunking-and-performance """ @@ -594,6 +592,25 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, if not paths: raise IOError('no files to open') + # Coerce 1D input into ND to maintain backwards-compatible API until API + # for N-D combine decided + # (see https://github.com/pydata/xarray/pull/2553/#issuecomment-445892746) + if concat_dim is None or concat_dim == _CONCAT_DIM_DEFAULT: + concat_dims = concat_dim + elif not isinstance(concat_dim, list): + concat_dims = [concat_dim] + else: + concat_dims = concat_dim + infer_order_from_coords = False + + # If infer_order_from_coords=True then this is unnecessary, but quick. + # If infer_order_from_coords=False then this creates a flat list which is + # easier to iterate over, while saving the originally-supplied structure + combined_ids_paths, concat_dims = _infer_concat_order_from_positions( + paths, concat_dims) + ids, paths = ( + list(combined_ids_paths.keys()), list(combined_ids_paths.values())) + open_kwargs = dict(engine=engine, chunks=chunks or {}, lock=lock, autoclose=autoclose, **kwargs) @@ -618,15 +635,17 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, # the underlying datasets will still be stored as dask arrays datasets, file_objs = dask.compute(datasets, file_objs) - # close datasets in case of a ValueError + # Close datasets in case of a ValueError try: - if concat_dim is _CONCAT_DIM_DEFAULT: - combined = auto_combine(datasets, compat=compat, - data_vars=data_vars, coords=coords) - else: - combined = auto_combine(datasets, concat_dim=concat_dim, - compat=compat, - data_vars=data_vars, coords=coords) + if infer_order_from_coords: + # Discard ordering because it should be redone from coordinates + ids = False + + combined = _auto_combine(datasets, concat_dims=concat_dims, + compat=compat, + data_vars=data_vars, coords=coords, + infer_order_from_coords=infer_order_from_coords, + ids=ids) except ValueError: for ds in datasets: ds.close() diff --git a/xarray/core/combine.py b/xarray/core/combine.py index ea156667430..c9924b2ad1e 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -1,6 +1,8 @@ from __future__ import absolute_import, division, print_function import warnings +import itertools +from collections import Counter import pandas as pd @@ -369,24 +371,195 @@ def _auto_concat(datasets, dim=None, data_vars='all', coords='different'): _CONCAT_DIM_DEFAULT = '__infer_concat_dim__' -def auto_combine(datasets, - concat_dim=_CONCAT_DIM_DEFAULT, - compat='no_conflicts', - data_vars='all', coords='different'): - """Attempt to auto-magically combine the given datasets into one. +def _infer_concat_order_from_positions(datasets, concat_dims): + + combined_ids = OrderedDict(_infer_tile_ids_from_nested_list(datasets, ())) + + tile_id, ds = list(combined_ids.items())[0] + n_dims = len(tile_id) + if concat_dims == _CONCAT_DIM_DEFAULT or concat_dims is None: + concat_dims = [concat_dims]*n_dims + else: + if len(concat_dims) != n_dims: + raise ValueError("concat_dims has length {} but the datasets " + "passed are nested in a {}-dimensional " + "structure".format(str(len(concat_dims)), + str(n_dims))) + + return combined_ids, concat_dims + + +def _infer_tile_ids_from_nested_list(entry, current_pos): + """ + Given a list of lists (of lists...) of objects, returns a iterator + which returns a tuple containing the index of each object in the nested + list structure as the key, and the object. This can then be called by the + dict constructor to create a dictionary of the objects organised by their + position in the original nested list. + + Recursively traverses the given structure, while keeping track of the + current position. Should work for any type of object which isn't a list. + + Parameters + ---------- + entry : list[list[obj, obj, ...]] + List of lists of arbitrary depth, containing objects in the order + they are to be concatenated. + + Returns + ------- + combined_tile_ids : dict[tuple(int, ...), obj] + """ + + if isinstance(entry, list): + for i, item in enumerate(entry): + for result in _infer_tile_ids_from_nested_list(item, + current_pos + (i,)): + yield result + else: + yield current_pos, entry + + +def _check_shape_tile_ids(combined_tile_ids): + tile_ids = combined_tile_ids.keys() + + # Check all tuples are the same length + # i.e. check that all lists are nested to the same depth + nesting_depths = [len(tile_id) for tile_id in tile_ids] + if not set(nesting_depths) == {nesting_depths[0]}: + raise ValueError("The supplied objects do not form a hypercube because" + " sub-lists do not have consistent depths") + + # Check all lists along one dimension are same length + for dim in range(nesting_depths[0]): + indices_along_dim = [tile_id[dim] for tile_id in tile_ids] + occurrences = Counter(indices_along_dim) + if len(set(occurrences.values())) != 1: + raise ValueError("The supplied objects do not form a hypercube " + "because sub-lists do not have consistent " + "lengths along dimension" + str(dim)) + + +def _combine_nd(combined_ids, concat_dims, data_vars='all', + coords='different', compat='no_conflicts'): + """ + Concatenates and merges an N-dimensional structure of datasets. + + No checks are performed on the consistency of the datasets, concat_dims or + tile_IDs, because it is assumed that this has already been done. + + Parameters + ---------- + combined_ids : Dict[Tuple[int, ...]], xarray.Dataset] + Structure containing all datasets to be concatenated with "tile_IDs" as + keys, which specify position within the desired final combined result. + concat_dims : sequence of str + The dimensions along which the datasets should be concatenated. Must be + in order, and the length must match + + Returns + ------- + combined_ds : xarray.Dataset + """ + + # Perform N-D dimensional concatenation + # Each iteration of this loop reduces the length of the tile_ids tuples + # by one. It always combines along the first dimension, removing the first + # element of the tuple + for concat_dim in concat_dims: + combined_ids = _auto_combine_all_along_first_dim(combined_ids, + dim=concat_dim, + data_vars=data_vars, + coords=coords, + compat=compat) + combined_ds = list(combined_ids.values())[0] + return combined_ds + + +def _auto_combine_all_along_first_dim(combined_ids, dim, data_vars, + coords, compat): + # Group into lines of datasets which must be combined along dim + # need to sort by _new_tile_id first for groupby to work + # TODO remove all these sorted OrderedDicts once python >= 3.6 only + combined_ids = OrderedDict(sorted(combined_ids.items(), key=_new_tile_id)) + grouped = itertools.groupby(combined_ids.items(), key=_new_tile_id) + + new_combined_ids = {} + for new_id, group in grouped: + combined_ids = OrderedDict(sorted(group)) + datasets = combined_ids.values() + new_combined_ids[new_id] = _auto_combine_1d(datasets, dim, compat, + data_vars, coords) + return new_combined_ids + + +def _auto_combine_1d(datasets, concat_dim=_CONCAT_DIM_DEFAULT, + compat='no_conflicts', + data_vars='all', coords='different'): + # This is just the old auto_combine function (which only worked along 1D) + if concat_dim is not None: + dim = None if concat_dim is _CONCAT_DIM_DEFAULT else concat_dim + grouped = itertools.groupby(datasets, key=lambda ds: tuple(sorted(ds))) + concatenated = [_auto_concat(list(ds_group), dim=dim, + data_vars=data_vars, coords=coords) + for id, ds_group in grouped] + else: + concatenated = datasets + merged = merge(concatenated, compat=compat) + return merged + + +def _new_tile_id(single_id_ds_pair): + tile_id, ds = single_id_ds_pair + return tile_id[1:] + + +def _auto_combine(datasets, concat_dims, compat, data_vars, coords, + infer_order_from_coords, ids): + """ + Calls logic to decide concatenation order before concatenating. + """ + + # Arrange datasets for concatenation + if infer_order_from_coords: + raise NotImplementedError + # TODO Use coordinates to determine tile_ID for each dataset in N-D + # Ignore how they were ordered previously + # Should look like: + # combined_ids, concat_dims = _infer_tile_ids_from_coords(datasets, + # concat_dims) + else: + # Use information from the shape of the user input + if not ids: + # Determine tile_IDs by structure of input in N-D + # (i.e. ordering in list-of-lists) + combined_ids, concat_dims = _infer_concat_order_from_positions\ + (datasets, concat_dims) + else: + # Already sorted so just use the ids already passed + combined_ids = OrderedDict(zip(ids, datasets)) + + # Check that the inferred shape is combinable + _check_shape_tile_ids(combined_ids) + # Repeatedly concatenate then merge along each dimension + combined = _combine_nd(combined_ids, concat_dims, compat=compat, + data_vars=data_vars, coords=coords) + return combined + + +def auto_combine(datasets, concat_dim=_CONCAT_DIM_DEFAULT, + compat='no_conflicts', data_vars='all', coords='different'): + """Attempt to auto-magically combine the given datasets into one. This method attempts to combine a list of datasets into a single entity by inspecting metadata and using a combination of concat and merge. - It does not concatenate along more than one dimension or sort data under any circumstances. It does align coordinates, but different variables on datasets can cause it to fail under some scenarios. In complex cases, you may need to clean up your data and use ``concat``/``merge`` explicitly. - ``auto_combine`` works well if you have N years of data and M data variables, and each combination of a distinct time period and set of data variables is saved its own dataset. - Parameters ---------- datasets : sequence of xarray.Dataset @@ -404,7 +577,6 @@ def auto_combine(datasets, 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts: - - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'equals': all values and dimensions must be the same. @@ -415,9 +587,8 @@ def auto_combine(datasets, of all non-null values. data_vars : {'minimal', 'different', 'all' or list of str}, optional Details are in the documentation of concat - coords : {'minimal', 'different', 'all' o list of str}, optional - Details are in the documentation of concat - + coords : {'minimal', 'different', 'all' or list of str}, optional + Details are in the documentation of conca Returns ------- combined : xarray.Dataset @@ -427,15 +598,20 @@ def auto_combine(datasets, concat Dataset.merge """ - from toolz import itertoolz - if concat_dim is not None: - dim = None if concat_dim is _CONCAT_DIM_DEFAULT else concat_dim - grouped = itertoolz.groupby(lambda ds: tuple(sorted(ds.data_vars)), - datasets).values() - concatenated = [_auto_concat(ds, dim=dim, - data_vars=data_vars, coords=coords) - for ds in grouped] + + # Coerce 1D input into ND to maintain backwards-compatible API until API + # for N-D combine decided + # (see https://github.com/pydata/xarray/pull/2553/#issuecomment-445892746) + if concat_dim is None or concat_dim == _CONCAT_DIM_DEFAULT: + concat_dims = concat_dim + elif not isinstance(concat_dim, list): + concat_dims = [concat_dim] else: - concatenated = datasets - merged = merge(concatenated, compat=compat) - return merged + concat_dims = concat_dim + infer_order_from_coords = False + + # The IDs argument tells _auto_combine that the datasets are not yet sorted + return _auto_combine(datasets, concat_dims=concat_dims, compat=compat, + data_vars=data_vars, coords=coords, + infer_order_from_coords=infer_order_from_coords, + ids=False) diff --git a/xarray/testing.py b/xarray/testing.py index ee5a54cd7dc..03c5354cdff 100644 --- a/xarray/testing.py +++ b/xarray/testing.py @@ -138,3 +138,11 @@ def assert_allclose(a, b, rtol=1e-05, atol=1e-08, decode_bytes=True): else: raise TypeError('{} not supported by assertion comparison' .format(type(a))) + + +def assert_combined_tile_ids_equal(dict1, dict2): + assert len(dict1) == len(dict2) + for k, v in dict1.items(): + assert k in dict2.keys() + assert_equal(dict1[k], dict2[k]) + diff --git a/xarray/tests/__init__.py b/xarray/tests/__init__.py index a45f71bbc3b..cd66ad82356 100644 --- a/xarray/tests/__init__.py +++ b/xarray/tests/__init__.py @@ -15,7 +15,7 @@ from xarray.core import utils from xarray.core.indexing import ExplicitlyIndexed from xarray.testing import (assert_equal, assert_identical, # noqa: F401 - assert_allclose) + assert_allclose, assert_combined_tile_ids_equal) from xarray.plot.utils import import_seaborn try: diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 0ce3bd7290d..3998b3b9a77 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -2146,12 +2146,42 @@ def test_open_mfdataset(self): assert actual.foo.variable.data.chunks == \ ((3, 2, 3, 2),) + with raises_regex(IOError, 'no files to open'): open_mfdataset('foo-bar-baz-*.nc') with raises_regex(ValueError, 'wild-card'): open_mfdataset('http://some/remote/uri') + def test_open_mfdataset_2d(self): + original = Dataset({'foo': (['x', 'y'], np.random.randn(10, 8))}) + with create_tmp_file() as tmp1: + with create_tmp_file() as tmp2: + with create_tmp_file() as tmp3: + with create_tmp_file() as tmp4: + original.isel(x=slice(5), + y=slice(4)).to_netcdf(tmp1) + original.isel(x=slice(5, 10), + y=slice(4)).to_netcdf(tmp2) + original.isel(x=slice(5), + y=slice(4, 8)).to_netcdf(tmp3) + original.isel(x=slice(5, 10), + y=slice(4, 8)).to_netcdf(tmp4) + with open_mfdataset([[tmp1, tmp2], + [tmp3, tmp4]], + concat_dim=['y', 'x']) as actual: + assert isinstance(actual.foo.variable.data, + da.Array) + assert actual.foo.variable.data.chunks == \ + ((5, 5), (4, 4)) + assert_identical(original, actual) + with open_mfdataset([[tmp1, tmp2], + [tmp3, tmp4]], + concat_dim=['y', 'x'], + chunks={'x': 3, 'y': 2}) as actual: + assert actual.foo.variable.data.chunks == \ + ((3, 2, 3, 2), (2, 2, 2, 2),) + @requires_pathlib def test_open_mfdataset_pathlib(self): original = Dataset({'foo': ('x', np.random.randn(10))}) @@ -2164,6 +2194,45 @@ def test_open_mfdataset_pathlib(self): with open_mfdataset([tmp1, tmp2]) as actual: assert_identical(original, actual) + @requires_pathlib + def test_open_mfdataset_2d_pathlib(self): + original = Dataset({'foo': (['x', 'y'], np.random.randn(10, 8))}) + with create_tmp_file() as tmp1: + with create_tmp_file() as tmp2: + with create_tmp_file() as tmp3: + with create_tmp_file() as tmp4: + tmp1 = Path(tmp1) + tmp2 = Path(tmp2) + tmp3 = Path(tmp3) + tmp4 = Path(tmp4) + original.isel(x=slice(5), + y=slice(4)).to_netcdf(tmp1) + original.isel(x=slice(5, 10), + y=slice(4)).to_netcdf(tmp2) + original.isel(x=slice(5), + y=slice(4, 8)).to_netcdf(tmp3) + original.isel(x=slice(5, 10), + y=slice(4, 8)).to_netcdf(tmp4) + with open_mfdataset([[tmp1, tmp2], + [tmp3, tmp4]], + concat_dim=['y', 'x']) as actual: + assert_identical(original, actual) + + @pytest.mark.xfail(reason="Not yet implemented") + def test_open_mfdataset(self): + original = Dataset({'foo': ('x', np.random.randn(10))}) + with create_tmp_file() as tmp1: + with create_tmp_file() as tmp2: + original.isel(x=slice(5)).to_netcdf(tmp1) + original.isel(x=slice(5, 10)).to_netcdf(tmp2) + + with pytest.raises(NotImplementedError): + open_mfdataset([tmp1, tmp2], infer_order_from_coords=True) + + # With infer_order_from_coords=True this should pass in future + with open_mfdataset([tmp1, tmp2]) as actual: + assert_identical(original, actual) + def test_attrs_mfdataset(self): original = Dataset({'foo': ('x', np.random.randn(10))}) with create_tmp_file() as tmp1: @@ -2636,7 +2705,7 @@ def test_uamiv_format_mfread(self): ['example.uamiv', 'example.uamiv'], engine='pseudonetcdf', - concat_dim='TSTEP', + concat_dim=['TSTEP'], backend_kwargs={'format': 'uamiv'}) data1 = np.arange(20, dtype='f').reshape(1, 1, 4, 5) diff --git a/xarray/tests/test_combine.py b/xarray/tests/test_combine.py index 2004b1e660f..ec2288b1d2d 100644 --- a/xarray/tests/test_combine.py +++ b/xarray/tests/test_combine.py @@ -1,17 +1,22 @@ from __future__ import absolute_import, division, print_function from copy import deepcopy +from itertools import product import numpy as np import pandas as pd import pytest -from xarray import DataArray, Dataset, Variable, auto_combine, concat +from xarray import DataArray, Dataset, Variable, auto_combine, concat, merge from xarray.core.pycompat import OrderedDict, iteritems +from xarray.core.combine import ( + _new_tile_id, _auto_combine_all_along_first_dim, + _infer_concat_order_from_positions, _infer_tile_ids_from_nested_list, + _check_shape_tile_ids, _combine_nd, _auto_combine_1d, _auto_combine) from . import ( InaccessibleArray, assert_array_equal, assert_equal, assert_identical, - raises_regex, requires_dask) + assert_combined_tile_ids_equal, raises_regex, requires_dask) from .test_dataset import create_test_data @@ -297,39 +302,40 @@ def test_concat_lazy(self): class TestAutoCombine(object): + @pytest.mark.parametrize("combine", [_auto_combine_1d, auto_combine]) @requires_dask # only for toolz - def test_auto_combine(self): + def test_auto_combine(self, combine): objs = [Dataset({'x': [0]}), Dataset({'x': [1]})] - actual = auto_combine(objs) + actual = combine(objs) expected = Dataset({'x': [0, 1]}) assert_identical(expected, actual) - actual = auto_combine([actual]) + actual = combine([actual]) assert_identical(expected, actual) objs = [Dataset({'x': [0, 1]}), Dataset({'x': [2]})] - actual = auto_combine(objs) + actual = combine(objs) expected = Dataset({'x': [0, 1, 2]}) assert_identical(expected, actual) # ensure auto_combine handles non-sorted variables objs = [Dataset(OrderedDict([('x', ('a', [0])), ('y', ('a', [0]))])), Dataset(OrderedDict([('y', ('a', [1])), ('x', ('a', [1]))]))] - actual = auto_combine(objs) + actual = combine(objs) expected = Dataset({'x': ('a', [0, 1]), 'y': ('a', [0, 1])}) assert_identical(expected, actual) objs = [Dataset({'x': [0], 'y': [0]}), Dataset({'y': [1], 'x': [1]})] with raises_regex(ValueError, 'too many .* dimensions'): - auto_combine(objs) + combine(objs) objs = [Dataset({'x': 0}), Dataset({'x': 1})] with raises_regex(ValueError, 'cannot infer dimension'): - auto_combine(objs) + combine(objs) objs = [Dataset({'x': [0], 'y': [0]}), Dataset({'x': [0]})] with pytest.raises(KeyError): - auto_combine(objs) + combine(objs) @requires_dask # only for toolz def test_auto_combine_previously_failed(self): @@ -378,6 +384,13 @@ def test_auto_combine_no_concat(self): actual = auto_combine([data, data, data], concat_dim=None) assert_identical(data, actual) + tmp1 = Dataset({'x': 0}) + tmp2 = Dataset({'x': np.nan}) + actual = auto_combine([tmp1, tmp2], concat_dim=None) + assert_identical(tmp1, actual) + actual = auto_combine([tmp1, tmp2], concat_dim=[None]) + assert_identical(tmp1, actual) + # Single object, with a concat_dim explicitly provided # Test the issue reported in GH #1988 objs = [Dataset({'x': 0, 'y': 1})] @@ -396,3 +409,293 @@ def test_auto_combine_no_concat(self): 'y': (('baz', 'z'), [[1, 2]])}, {'baz': [100]}) assert_identical(expected, actual) + + +class TestTileIDsFromNestedList(object): + def test_1d(self): + ds = create_test_data + input = [ds(0), ds(1)] + + expected = {(0,): ds(0), (1,): ds(1)} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_2d(self): + ds = create_test_data + input = [[ds(0), ds(1)], [ds(2), ds(3)], [ds(4), ds(5)]] + + expected = {(0, 0): ds(0), (0, 1): ds(1), + (1, 0): ds(2), (1, 1): ds(3), + (2, 0): ds(4), (2, 1): ds(5)} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_3d(self): + ds = create_test_data + input = [[[ds(0), ds(1)], [ds(2), ds(3)], [ds(4), ds(5)]], + [[ds(6), ds(7)], [ds(8), ds(9)], [ds(10), ds(11)]]] + + expected = {(0, 0, 0): ds(0), (0, 0, 1): ds(1), + (0, 1, 0): ds(2), (0, 1, 1): ds(3), + (0, 2, 0): ds(4), (0, 2, 1): ds(5), + (1, 0, 0): ds(6), (1, 0, 1): ds(7), + (1, 1, 0): ds(8), (1, 1, 1): ds(9), + (1, 2, 0): ds(10), (1, 2, 1): ds(11)} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_single_dataset(self): + ds = create_test_data(0) + input = [ds] + + expected = {(0,): ds} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_redundant_nesting(self): + ds = create_test_data + input = [[ds(0)], [ds(1)]] + + expected = {(0, 0): ds(0), (1, 0): ds(1)} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_ignore_empty_list(self): + ds = create_test_data(0) + input = [ds, []] + expected = {(0,): ds} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_uneven_depth_input(self): + # Auto_combine won't work on ragged input + # but this is just to increase test coverage + ds = create_test_data + input = [ds(0), [ds(1), ds(2)]] + + expected = {(0,): ds(0), (1, 0): ds(1), (1, 1): ds(2)} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_uneven_length_input(self): + # Auto_combine won't work on ragged input + # but this is just to increase test coverage + ds = create_test_data + input = [[ds(0)], [ds(1), ds(2)]] + + expected = {(0, 0): ds(0), (1, 0): ds(1), (1, 1): ds(2)} + actual = dict(_infer_tile_ids_from_nested_list(input, ())) + assert_combined_tile_ids_equal(expected, actual) + + def test_infer_from_datasets(self): + ds = create_test_data + input = [ds(0), ds(1)] + + expected = {(0,): ds(0), (1,): ds(1)} + actual, concat_dims = _infer_concat_order_from_positions\ + (input, ['dim1']) + assert_combined_tile_ids_equal(expected, actual) + + input = [ds(0), ds(1)] + with pytest.raises(ValueError): + _infer_concat_order_from_positions(input, ['dim1', 'extra_dim']) + + +@pytest.fixture(scope='module') +def create_combined_ids(): + return _create_combined_ids + + +def _create_combined_ids(shape): + tile_ids = _create_tile_ids(shape) + nums = range(len(tile_ids)) + return {tile_id: create_test_data(num) + for tile_id, num in zip(tile_ids, nums)} + + +def _create_tile_ids(shape): + tile_ids = product(*(range(i) for i in shape)) + return list(tile_ids) + + +@requires_dask # only for toolz +class TestCombineND(object): + @pytest.mark.parametrize("old_id, new_id", [((3,0,1), (0,1)), + ((0, 0), (0,)), + ((1,), ()), + ((0,), ()), + ((1, 0), (0,))]) + def test_new_tile_id(self, old_id, new_id): + ds = create_test_data + assert _new_tile_id((old_id, ds)) == new_id + + def test_get_new_tile_ids(self, create_combined_ids): + shape = (1, 2, 3) + combined_ids = create_combined_ids(shape) + + expected_tile_ids = sorted(combined_ids.keys()) + actual_tile_ids = _create_tile_ids(shape) + assert expected_tile_ids == actual_tile_ids + + @pytest.mark.parametrize("concat_dim", ['dim1', 'new_dim']) + def test_concat_once(self, create_combined_ids, concat_dim): + shape = (2,) + combined_ids = create_combined_ids(shape) + ds = create_test_data + result = _auto_combine_all_along_first_dim(combined_ids, + dim=concat_dim, + data_vars='all', + coords='different', + compat='no_conflicts') + + expected_ds = concat([ds(0), ds(1)], dim=concat_dim) + assert_combined_tile_ids_equal(result, {(): expected_ds}) + + def test_concat_only_first_dim(self, create_combined_ids): + shape = (2, 3) + combined_ids = create_combined_ids(shape) + result = _auto_combine_all_along_first_dim(combined_ids, + dim='dim1', + data_vars='all', + coords='different', + compat='no_conflicts') + + ds = create_test_data + partway1 = concat([ds(0), ds(3)], dim='dim1') + partway2 = concat([ds(1), ds(4)], dim='dim1') + partway3 = concat([ds(2), ds(5)], dim='dim1') + expected_datasets = [partway1, partway2, partway3] + expected = {(i,): ds for i, ds in enumerate(expected_datasets)} + + assert_combined_tile_ids_equal(result, expected) + + @pytest.mark.parametrize("concat_dim", ['dim1', 'new_dim']) + def test_concat_twice(self, create_combined_ids, concat_dim): + shape = (2, 3) + combined_ids = create_combined_ids(shape) + result = _combine_nd(combined_ids, concat_dims=['dim1', concat_dim]) + + ds = create_test_data + partway1 = concat([ds(0), ds(3)], dim='dim1') + partway2 = concat([ds(1), ds(4)], dim='dim1') + partway3 = concat([ds(2), ds(5)], dim='dim1') + expected = concat([partway1, partway2, partway3], dim=concat_dim) + + assert_equal(result, expected) + + +class TestCheckShapeTileIDs(object): + def test_check_depths(self): + ds = create_test_data(0) + combined_tile_ids = {(0,): ds, (0, 1): ds} + with raises_regex(ValueError, 'sub-lists do not have ' + 'consistent depths'): + _check_shape_tile_ids(combined_tile_ids) + + def test_check_lengths(self): + ds = create_test_data(0) + combined_tile_ids = {(0, 0): ds, (0, 1): ds , (0, 2): ds, + (1, 0): ds, (1, 1): ds} + with raises_regex(ValueError, 'sub-lists do not have ' + 'consistent lengths'): + _check_shape_tile_ids(combined_tile_ids) + + +@requires_dask # only for toolz +class TestAutoCombineND(object): + def test_single_dataset(self): + objs = [Dataset({'x': [0]}), Dataset({'x': [1]})] + actual = auto_combine(objs) + expected = Dataset({'x': [0, 1]}) + assert_identical(expected, actual) + + actual = auto_combine(actual) + assert_identical(expected, actual) + + def test_auto_combine_2d(self): + ds = create_test_data + + partway1 = concat([ds(0), ds(3)], dim='dim1') + partway2 = concat([ds(1), ds(4)], dim='dim1') + partway3 = concat([ds(2), ds(5)], dim='dim1') + expected = concat([partway1, partway2, partway3], dim='dim2') + + datasets = [[ds(0), ds(1), ds(2)], [ds(3), ds(4), ds(5)]] + result = auto_combine(datasets, concat_dim=['dim1', 'dim2']) + + assert_equal(result, expected) + + def test_invalid_hypercube_input(self): + ds = create_test_data + + datasets = [[ds(0), ds(1), ds(2)], [ds(3), ds(4)]] + with raises_regex(ValueError, 'sub-lists do not have ' + 'consistent lengths'): + auto_combine(datasets, concat_dim=['dim1', 'dim2']) + + datasets = [[ds(0), ds(1)], [[ds(3), ds(4)]]] + with raises_regex(ValueError, 'sub-lists do not have ' + 'consistent depths'): + auto_combine(datasets, concat_dim=['dim1', 'dim2']) + + datasets = [[ds(0), ds(1)], [ds(3), ds(4)]] + with raises_regex(ValueError, 'concat_dims has length'): + auto_combine(datasets, concat_dim=['dim1']) + + def test_merge_one_dim_concat_another(self): + objs = [[Dataset({'foo': ('x', [0, 1])}), Dataset({'bar': ('x', [10, 20])})], + [Dataset({'foo': ('x', [2, 3])}), Dataset({'bar': ('x', [30, 40])})]] + expected = Dataset({'foo': ('x', [0, 1, 2, 3]), + 'bar': ('x', [10, 20, 30, 40])}) + + actual = auto_combine(objs, concat_dim=['x', None]) + assert_identical(expected, actual) + + actual = auto_combine(objs) + assert_identical(expected, actual) + + # Proving it works symmetrically + objs = [[Dataset({'foo': ('x', [0, 1])}), Dataset({'foo': ('x', [2, 3])})], + [Dataset({'bar': ('x', [10, 20])}), Dataset({'bar': ('x', [30, 40])})]] + actual = auto_combine(objs, concat_dim=[None, 'x']) + assert_identical(expected, actual) + + def test_combine_concat_over_redundant_nesting(self): + objs = [[Dataset({'x': [0]}), Dataset({'x': [1]})]] + actual = auto_combine(objs, concat_dim=[None, 'x']) + expected = Dataset({'x': [0, 1]}) + assert_identical(expected, actual) + + objs = [[Dataset({'x': [0]})], [Dataset({'x': [1]})]] + actual = auto_combine(objs, concat_dim=['x', None]) + expected = Dataset({'x': [0, 1]}) + assert_identical(expected, actual) + + objs = [[Dataset({'x': [0]})]] + actual = auto_combine(objs, concat_dim=[None, None]) + expected = Dataset({'x': [0]}) + assert_identical(expected, actual) + + objs = [[Dataset({'x': [0]})]] + actual = auto_combine(objs, concat_dim=None) + expected = Dataset({'x': [0]}) + assert_identical(expected, actual) + + +class TestAutoCombineUsingCoords(object): + def test_order_inferred_from_coords(self): + data = create_test_data() + objs = [data.isel(dim2=slice(4, 9)), data.isel(dim2=slice(4))] + with pytest.raises(NotImplementedError): + _auto_combine(objs, concat_dims=['dim2'], compat='no_conflicts', + data_vars='all', coords='different', + infer_order_from_coords=True, ids=True) + + @pytest.mark.xfail(reason="Not yet implemented") + def test_infer_order_from_coords(self): + # Should pass once inferring order from coords is implemented + data = create_test_data() + objs = [data.isel(dim2=slice(4, 9)), data.isel(dim2=slice(4))] + actual = auto_combine(objs) # but with infer_order_from_coords=True + expected = data + assert_identical(expected, actual) From 09494eb0c4299bb2d923a00ef8f6def9af4a1adc Mon Sep 17 00:00:00 2001 From: Martijn Visser Date: Fri, 14 Dec 2018 18:31:48 +0100 Subject: [PATCH 019/108] fix a few typos in rst files (#2607) --- doc/api.rst | 2 +- doc/computation.rst | 2 +- doc/examples/monthly-means.rst | 2 +- doc/interpolation.rst | 4 ++-- doc/pandas.rst | 2 +- doc/plotting.rst | 2 +- doc/roadmap.rst | 4 ++-- doc/time-series.rst | 2 +- 8 files changed, 10 insertions(+), 10 deletions(-) diff --git a/doc/api.rst b/doc/api.rst index 662ef567710..9a00630f88e 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -377,7 +377,7 @@ Universal functions .. warning:: With recent versions of numpy, dask and xarray, NumPy ufuncs are now - supported directly on all xarray and dask objects. This obliviates the need + supported directly on all xarray and dask objects. This obviates the need for the ``xarray.ufuncs`` module, which should not be used for new code unless compatibility with versions of NumPy prior to v1.13 is required. diff --git a/doc/computation.rst b/doc/computation.rst index 3eec891494b..f1d1450a6dc 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -267,7 +267,7 @@ This means, for example, that you always subtract an array from its transpose: c - c.T -You can explicitly broadcast xaray data structures by using the +You can explicitly broadcast xarray data structures by using the :py:func:`~xarray.broadcast` function: .. ipython:: python diff --git a/doc/examples/monthly-means.rst b/doc/examples/monthly-means.rst index cb41d5c59ad..7cc47eb2847 100644 --- a/doc/examples/monthly-means.rst +++ b/doc/examples/monthly-means.rst @@ -130,7 +130,7 @@ for each monthly data record - calculate weights using ``groupby('time.season')`` Finally, we just need to multiply our weights by the ``Dataset`` and sum -allong the time dimension. +along the time dimension. .. code:: python diff --git a/doc/interpolation.rst b/doc/interpolation.rst index 71e88079676..7c750506cf3 100644 --- a/doc/interpolation.rst +++ b/doc/interpolation.rst @@ -57,7 +57,7 @@ To interpolate data with a :py:func:`numpy.datetime64` coordinate you can pass a da_dt64.interp(time='2000-01-02') The interpolated data can be merged into the original :py:class:`~xarray.DataArray` -by specifing the time periods required. +by specifying the time periods required. .. ipython:: python @@ -232,7 +232,7 @@ then make the interpolation dropped dropped.interp(x=[0.5, 1.5, 2.5], method='cubic') -If NaNs are distributed rondomly in your multidimensional array, +If NaNs are distributed randomly in your multidimensional array, dropping all the columns containing more than one NaNs by :py:meth:`~xarray.DataArray.dropna` may lose a significant amount of information. In such a case, you can fill NaN by :py:meth:`~xarray.DataArray.interpolate_na`, diff --git a/doc/pandas.rst b/doc/pandas.rst index e0bad61f805..7a983872416 100644 --- a/doc/pandas.rst +++ b/doc/pandas.rst @@ -152,7 +152,7 @@ However, you will need to set dimension names explicitly, either with the Transitioning from pandas.Panel to xarray ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -:py:class:`~pandas.Panel`, pandas's data structure for 3D arrays, has always +:py:class:`~pandas.Panel`, pandas' data structure for 3D arrays, has always been a second class data structure compared to the Series and DataFrame. To allow pandas developers to focus more on its core functionality built around the DataFrame, pandas plans to eventually deprecate Panel. diff --git a/doc/plotting.rst b/doc/plotting.rst index f8ba82febb0..bac6e6e51fd 100644 --- a/doc/plotting.rst +++ b/doc/plotting.rst @@ -461,7 +461,7 @@ about three or four dimensional arrays? That's where facets become helpful. Consider the temperature data set. There are 4 observations per day for two years which makes for 2920 values along the time dimension. One way to visualize this data is to make a -seperate plot for each time period. +separate plot for each time period. The faceted dimension should not have too many values; faceting on the time dimension will produce 2920 plots. That's diff --git a/doc/roadmap.rst b/doc/roadmap.rst index 34d203c3f48..e336b35b2bc 100644 --- a/doc/roadmap.rst +++ b/doc/roadmap.rst @@ -186,7 +186,7 @@ Engaging more users Like many open-source projects, the documentation of xarray has grown together with the library's features. While we think that the xarray -documentation is comprehensive already, we aknowledge that the adoption +documentation is comprehensive already, we acknowledge that the adoption of xarray might be slowed down because of the substantial time investment required to learn its working principles. In particular, non-computer scientists or users less familiar with the pydata ecosystem @@ -198,7 +198,7 @@ In order to lower this adoption barrier, we propose to: - Develop entry-level tutorials for users with different backgrounds. For example, we would like to develop tutorials for users with or without previous knowledge of pandas, numpy, netCDF, etc. These tutorials may be - built as part of xarray's documentation or included in a seperate repository + built as part of xarray's documentation or included in a separate repository to enable interactive use (e.g. mybinder.org). - Document typical user workflows in a dedicated website, following the example of `dask-stories diff --git a/doc/time-series.rst b/doc/time-series.rst index 7f5389d3ae1..8bd490d784b 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -82,7 +82,7 @@ Datetime indexing xarray borrows powerful indexing machinery from pandas (see :ref:`indexing`). -This allows for several useful and suscinct forms of indexing, particularly for +This allows for several useful and succinct forms of indexing, particularly for `datetime64` data. For example, we support indexing with strings for single items and with the `slice` object: From f8cced75f718ca0ad278224cf4b09bd42f5cd999 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Sat, 15 Dec 2018 15:53:18 -0800 Subject: [PATCH 020/108] Fix parsing '_Unsigned' attribute (#2584) * Fix parsing '_Unsigned' attribute Fixes #2583 * Fix encode step too. * Add tests. * Fix whats-new. * Undo unnecessary change * Yay! fix test failure. --- doc/whats-new.rst | 3 ++ xarray/coding/variables.py | 8 ++- xarray/tests/test_backends.py | 97 +++++++++++++++++++++-------------- 3 files changed, 68 insertions(+), 40 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 91ee0d75aaa..bd573d1fc75 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -52,6 +52,9 @@ Bug fixes - Fix h5netcdf saving scalars with filters or chunks (:issue:`2563`). By `Martin Raspaud `_. +- Fix parsing of ``_Unsigned`` attribute set by OPENDAP servers. (:issue:`2583`). + By `Deepak Cherian `_ + .. _whats-new.0.11.0: diff --git a/xarray/coding/variables.py b/xarray/coding/variables.py index b86b77a3707..d5963b0e94f 100644 --- a/xarray/coding/variables.py +++ b/xarray/coding/variables.py @@ -249,7 +249,11 @@ class UnsignedIntegerCoder(VariableCoder): def encode(self, variable, name=None): dims, data, attrs, encoding = unpack_for_encoding(variable) - if encoding.get('_Unsigned', False): + # from netCDF best practices + # https://www.unidata.ucar.edu/software/netcdf/docs/BestPractices.html + # "_Unsigned = "true" to indicate that + # integer data should be treated as unsigned" + if encoding.get('_Unsigned', 'false') == 'true': pop_to(encoding, attrs, '_Unsigned') signed_dtype = np.dtype('i%s' % data.dtype.itemsize) if '_FillValue' in attrs: @@ -266,7 +270,7 @@ def decode(self, variable, name=None): unsigned = pop_to(attrs, encoding, '_Unsigned') if data.dtype.kind == 'i': - if unsigned: + if unsigned == 'true': unsigned_dtype = np.dtype('u%s' % data.dtype.itemsize) transform = partial(np.asarray, dtype=unsigned_dtype) data = lazy_elemwise_func(data, transform, unsigned_dtype) diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 3998b3b9a77..bad9e99c042 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -80,7 +80,7 @@ def create_masked_and_scaled_data(): def create_encoded_masked_and_scaled_data(): attributes = {'_FillValue': -1, 'add_offset': 10, 'scale_factor': np.float32(0.1)} - return Dataset({'x': ('t', [-1, -1, 0, 1, 2], attributes)}) + return Dataset({'x': ('t', np.int16([-1, -1, 0, 1, 2]), attributes)}) def create_unsigned_masked_scaled_data(): @@ -95,11 +95,45 @@ def create_encoded_unsigned_masked_scaled_data(): # be represented in the signed form. attributes = {'_FillValue': -1, '_Unsigned': 'true', 'add_offset': 10, 'scale_factor': np.float32(0.1)} + # Create unsigned data corresponding to [0, 1, 127, 128, 255] unsigned + sb = np.asarray([0, 1, 127, -128, -1], dtype='i1') + return Dataset({'x': ('t', sb, attributes)}) + + +def create_bad_unsigned_masked_scaled_data(): + encoding = {'_FillValue': 255, '_Unsigned': True, 'dtype': 'i1', + 'add_offset': 10, 'scale_factor': np.float32(0.1)} + x = np.array([10.0, 10.1, 22.7, 22.8, np.nan], dtype=np.float32) + return Dataset({'x': ('t', x, {}, encoding)}) + + +def create_bad_encoded_unsigned_masked_scaled_data(): + # These are values as written to the file: the _FillValue will + # be represented in the signed form. + attributes = {'_FillValue': -1, '_Unsigned': True, + 'add_offset': 10, 'scale_factor': np.float32(0.1)} # Create signed data corresponding to [0, 1, 127, 128, 255] unsigned sb = np.asarray([0, 1, 127, -128, -1], dtype='i1') return Dataset({'x': ('t', sb, attributes)}) +def create_signed_masked_scaled_data(): + encoding = {'_FillValue': -127, '_Unsigned': 'false', 'dtype': 'i1', + 'add_offset': 10, 'scale_factor': np.float32(0.1)} + x = np.array([-1.0, 10.1, 22.7, np.nan], dtype=np.float32) + return Dataset({'x': ('t', x, {}, encoding)}) + + +def create_encoded_signed_masked_scaled_data(): + # These are values as written to the file: the _FillValue will + # be represented in the signed form. + attributes = {'_FillValue': -127, '_Unsigned': 'false', + 'add_offset': 10, 'scale_factor': np.float32(0.1)} + # Create signed data corresponding to [0, 1, 127, 128, 255] unsigned + sb = np.asarray([-110, 1, 127, -127], dtype='i1') + return Dataset({'x': ('t', sb, attributes)}) + + def create_boolean_data(): attributes = {'units': '-'} return Dataset({'x': ('t', [True, False, False, True], attributes)}) @@ -617,65 +651,52 @@ def test_roundtrip_string_with_fill_value_nchar(self): with self.roundtrip(original) as actual: assert_identical(expected, actual) - def test_unsigned_roundtrip_mask_and_scale(self): - decoded = create_unsigned_masked_scaled_data() - encoded = create_encoded_unsigned_masked_scaled_data() + @pytest.mark.parametrize( + 'decoded_fn, encoded_fn', + [(create_unsigned_masked_scaled_data, + create_encoded_unsigned_masked_scaled_data), + pytest.param(create_bad_unsigned_masked_scaled_data, + create_bad_encoded_unsigned_masked_scaled_data, + marks=pytest.mark.xfail(reason="Bad _Unsigned attribute.")), + (create_signed_masked_scaled_data, + create_encoded_signed_masked_scaled_data), + (create_masked_and_scaled_data, + create_encoded_masked_and_scaled_data)]) + def test_roundtrip_mask_and_scale(self, decoded_fn, encoded_fn): + decoded = decoded_fn() + encoded = encoded_fn() + with self.roundtrip(decoded) as actual: for k in decoded.variables: assert (decoded.variables[k].dtype == actual.variables[k].dtype) assert_allclose(decoded, actual, decode_bytes=False) + with self.roundtrip(decoded, open_kwargs=dict(decode_cf=False)) as actual: + # TODO: this assumes that all roundtrips will first + # encode. Is that something we want to test for? for k in encoded.variables: assert (encoded.variables[k].dtype == actual.variables[k].dtype) assert_allclose(encoded, actual, decode_bytes=False) + with self.roundtrip(encoded, open_kwargs=dict(decode_cf=False)) as actual: for k in encoded.variables: assert (encoded.variables[k].dtype == actual.variables[k].dtype) assert_allclose(encoded, actual, decode_bytes=False) - # make sure roundtrip encoding didn't change the - # original dataset. - assert_allclose( - encoded, create_encoded_unsigned_masked_scaled_data()) - with self.roundtrip(encoded) as actual: - for k in decoded.variables: - assert decoded.variables[k].dtype == \ - actual.variables[k].dtype - assert_allclose(decoded, actual, decode_bytes=False) - with self.roundtrip(encoded, - open_kwargs=dict(decode_cf=False)) as actual: - for k in encoded.variables: - assert encoded.variables[k].dtype == \ - actual.variables[k].dtype - assert_allclose(encoded, actual, decode_bytes=False) - def test_roundtrip_mask_and_scale(self): - decoded = create_masked_and_scaled_data() - encoded = create_encoded_masked_and_scaled_data() - with self.roundtrip(decoded) as actual: - assert_allclose(decoded, actual, decode_bytes=False) - with self.roundtrip(decoded, - open_kwargs=dict(decode_cf=False)) as actual: - # TODO: this assumes that all roundtrips will first - # encode. Is that something we want to test for? - assert_allclose(encoded, actual, decode_bytes=False) - with self.roundtrip(encoded, - open_kwargs=dict(decode_cf=False)) as actual: - assert_allclose(encoded, actual, decode_bytes=False) # make sure roundtrip encoding didn't change the # original dataset. - assert_allclose(encoded, - create_encoded_masked_and_scaled_data(), - decode_bytes=False) + assert_allclose(encoded, encoded_fn(), decode_bytes=False) + with self.roundtrip(encoded) as actual: + for k in decoded.variables: + assert (decoded.variables[k].dtype == + actual.variables[k].dtype) assert_allclose(decoded, actual, decode_bytes=False) - with self.roundtrip(encoded, - open_kwargs=dict(decode_cf=False)) as actual: - assert_allclose(encoded, actual, decode_bytes=False) def test_coordinates_encoding(self): def equals_latlon(obj): From 090564c6cb621ee4d938f424f6e5acdf313bbbc7 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Mon, 17 Dec 2018 13:57:35 -0800 Subject: [PATCH 021/108] doc fixes. (#2611) * doc fixes Fixes #2610 * minor doc fixes. * Fix examples path for open statements. --- doc/dask.rst | 2 +- doc/examples/multidimensional-coords.rst | 5 +++-- doc/examples/weather-data.rst | 3 ++- doc/groupby.rst | 8 ++++---- doc/internals.rst | 2 +- doc/pandas.rst | 1 + doc/plotting.rst | 21 ++++++++++++++------- doc/reshaping.rst | 6 +++--- doc/time-series.rst | 4 ++++ doc/whats-new.rst | 8 +++++++- xarray/backends/api.py | 1 + xarray/core/combine.py | 2 ++ xarray/core/dataarray.py | 18 +++++++++--------- xarray/core/dataset.py | 9 ++++----- 14 files changed, 56 insertions(+), 34 deletions(-) diff --git a/doc/dask.rst b/doc/dask.rst index 975111cba33..ba75eea74cc 100644 --- a/doc/dask.rst +++ b/doc/dask.rst @@ -179,7 +179,7 @@ Explicit conversion by wrapping a DataArray with ``np.asarray`` also works: Alternatively you can load the data into memory but keep the arrays as Dask arrays using the :py:meth:`~xarray.Dataset.persist` method: -.. ipython:: +.. ipython:: python ds = ds.persist() diff --git a/doc/examples/multidimensional-coords.rst b/doc/examples/multidimensional-coords.rst index eed818ba064..7c86f897a24 100644 --- a/doc/examples/multidimensional-coords.rst +++ b/doc/examples/multidimensional-coords.rst @@ -25,7 +25,7 @@ As an example, consider this dataset from the .. ipython:: python - ds = xr.tutorial.load_dataset('rasm') + ds = xr.tutorial.open_dataset('rasm').load() ds In this example, the *logical coordinates* are ``x`` and ``y``, while @@ -107,7 +107,8 @@ function to specify the output coordinates of the group. # define a label for each bin corresponding to the central latitude lat_center = np.arange(1, 90, 2) # group according to those bins and take the mean - Tair_lat_mean = ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center).mean() + Tair_lat_mean = (ds.Tair.groupby_bins('xc', lat_bins, labels=lat_center) + .mean(xr.ALL_DIMS)) # plot the result @savefig xarray_multidimensional_coords_14_1.png width=5in Tair_lat_mean.plot(); diff --git a/doc/examples/weather-data.rst b/doc/examples/weather-data.rst index c13664d4ef5..84620360daa 100644 --- a/doc/examples/weather-data.rst +++ b/doc/examples/weather-data.rst @@ -17,7 +17,7 @@ Shared setup: .. ipython:: python :suppress: - fpath = "examples/_code/weather_data_setup.py" + fpath = "doc/examples/_code/weather_data_setup.py" with open(fpath) as f: code = compile(f.read(), fpath, 'exec') exec(code) @@ -123,6 +123,7 @@ The :py:func:`~xarray.Dataset.fillna` method on grouped objects lets you easily fill missing values by group: .. ipython:: python + :okwarning: # throw away the first half of every month some_missing = ds.tmin.sel(time=ds['time.day'] > 15).reindex_like(ds) diff --git a/doc/groupby.rst b/doc/groupby.rst index 6e42dbbc9f0..03c0881d836 100644 --- a/doc/groupby.rst +++ b/doc/groupby.rst @@ -118,7 +118,7 @@ dimensions *other than* the provided one: .. ipython:: python - ds.groupby('x').std() + ds.groupby('x').std(xr.ALL_DIMS) First and last ~~~~~~~~~~~~~~ @@ -129,7 +129,7 @@ values for group along the grouped dimension: .. ipython:: python - ds.groupby('letters').first() + ds.groupby('letters').first(xr.ALL_DIMS) By default, they skip missing values (control this with ``skipna``). @@ -144,7 +144,7 @@ coordinates. For example: .. ipython:: python - alt = arr.groupby('letters').mean() + alt = arr.groupby('letters').mean(xr.ALL_DIMS) alt ds.groupby('letters') - alt @@ -197,7 +197,7 @@ __ http://cfconventions.org/cf-conventions/v1.6.0/cf-conventions.html#_two_dimen 'lat': (['ny','nx'], [[10,10],[20,20]] ),}, dims=['ny','nx']) da - da.groupby('lon').sum() + da.groupby('lon').sum(xr.ALL_DIMS) da.groupby('lon').apply(lambda x: x - x.mean(), shortcut=False) Because multidimensional groups have the ability to generate a very large diff --git a/doc/internals.rst b/doc/internals.rst index 170e2d0b0cc..5c0e078ebb4 100644 --- a/doc/internals.rst +++ b/doc/internals.rst @@ -111,7 +111,7 @@ Back in an interactive IPython session, we can use these properties: .. ipython:: python :suppress: - exec(open("examples/_code/accessor_example.py").read()) + exec(open("doc/examples/_code/accessor_example.py").read()) .. ipython:: python diff --git a/doc/pandas.rst b/doc/pandas.rst index 7a983872416..fc20d161e05 100644 --- a/doc/pandas.rst +++ b/doc/pandas.rst @@ -173,6 +173,7 @@ So you can represent a Panel, in two ways: Let's take a look: .. ipython:: python + :okwarning: panel = pd.Panel(np.random.rand(2, 3, 4), items=list('ab'), major_axis=list('mno'), minor_axis=pd.date_range(start='2000', periods=4, name='date')) diff --git a/doc/plotting.rst b/doc/plotting.rst index bac6e6e51fd..1cb7aebe96d 100644 --- a/doc/plotting.rst +++ b/doc/plotting.rst @@ -144,7 +144,7 @@ axes created by ``plt.subplots``. plt.tight_layout() @savefig plotting_example_existing_axes.png width=6in - plt.show() + plt.draw() On the right is a histogram created by :py:func:`xarray.plot.hist`. @@ -343,7 +343,7 @@ matplotlib is available. plt.tight_layout() @savefig plotting_2d_call_matplotlib.png width=4in - plt.show() + plt.draw() .. note:: @@ -359,7 +359,7 @@ matplotlib is available. air2d.plot() @savefig plotting_2d_call_matplotlib2.png width=4in - plt.show() + plt.draw() Colormaps ~~~~~~~~~ @@ -444,9 +444,11 @@ if using ``imshow`` or ``pcolormesh`` (but not with ``contour`` or ``contourf``, since levels are chosen automatically). .. ipython:: python + :okwarning: @savefig plotting_seaborn_palette.png width=4in air2d.plot(levels=10, cmap='husl') + plt.draw() .. _plotting.faceting: @@ -519,6 +521,11 @@ Other features Faceted plotting supports other arguments common to xarray 2d plots. +.. ipython:: python + :suppress: + + plt.close('all') + .. ipython:: python hasoutliers = t.isel(time=slice(0, 5)).copy() @@ -528,7 +535,7 @@ Faceted plotting supports other arguments common to xarray 2d plots. @savefig plot_facet_robust.png g = hasoutliers.plot.pcolormesh('lon', 'lat', col='time', col_wrap=3, robust=True, cmap='viridis', - cbar_kwargs={'label': 'this has outliers'}) + cbar_kwargs={'label': 'this has outliers'}) FacetGrid Objects ~~~~~~~~~~~~~~~~~ @@ -568,7 +575,7 @@ they have been plotted. bottomright.annotate('bottom right', (240, 40)) @savefig plot_facet_iterator.png - plt.show() + plt.draw() TODO: add an example of using the ``map`` method to plot dataset variables (e.g., with ``plt.quiver``). @@ -603,7 +610,7 @@ by faceting are accessible in the object returned by ``plot``: ax.coastlines() ax.gridlines() @savefig plotting_maps_cartopy_facetting.png width=100% - plt.show(); + plt.draw(); Details @@ -634,7 +641,7 @@ These are provided for user convenience; they all call the same code. xplt.line(da, ax=axes[1, 1]) plt.tight_layout() @savefig plotting_ways_to_use.png width=6in - plt.show() + plt.draw() Here the output is the same. Since the data is 1 dimensional the line plot was used. diff --git a/doc/reshaping.rst b/doc/reshaping.rst index 67d9e198e8a..0fd078c8306 100644 --- a/doc/reshaping.rst +++ b/doc/reshaping.rst @@ -186,8 +186,8 @@ labels for one or several dimensions: array array['c'] = ('x', ['a', 'b', 'c']) array.set_index(x='c') - array.set_index(x='c', inplace=True) - array.reset_index('x', drop=True) + array = array.set_index(x='c') + array = array.reset_index('x', drop=True) .. _reshape.shift_and_roll: @@ -201,7 +201,7 @@ To adjust coordinate labels, you can use the :py:meth:`~xarray.Dataset.shift` an array = xr.DataArray([1, 2, 3, 4], dims='x') array.shift(x=2) - array.roll(x=2) + array.roll(x=2, roll_coords=True) .. _reshape.sort: diff --git a/doc/time-series.rst b/doc/time-series.rst index 8bd490d784b..1ced1ac30f6 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -163,6 +163,7 @@ Datetime components couple particularly well with grouped operations (see calculate the mean by time of day: .. ipython:: python + :okwarning: ds.groupby('time.hour').mean() @@ -176,6 +177,7 @@ same api as ``resample`` `in pandas`_. For example, we can downsample our dataset from hourly to 6-hourly: .. ipython:: python + :okwarning: ds.resample(time='6H') @@ -184,6 +186,7 @@ necessary for resampling. All of the reduction methods which work with ``Resample`` objects can also be used for resampling: .. ipython:: python + :okwarning: ds.resample(time='6H').mean() @@ -326,6 +329,7 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: :py:meth:`~xarray.CFTimeIndex.to_datetimeindex` method: .. ipython:: python + :okwarning: modern_times = xr.cftime_range('2000', periods=24, freq='MS', calendar='noleap') da = xr.DataArray(range(24), [('time', modern_times)]) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index bd573d1fc75..5143672a0c9 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -177,7 +177,7 @@ Bug fixes By `Spencer Clark `_. - We now properly handle arrays of ``datetime.datetime`` and ``datetime.timedelta`` provided as coordinates. (:issue:`2512`) - By `Deepak Cherian `_. - ``xarray.DataArray.roll`` correctly handles multidimensional arrays. (:issue:`2445`) By `Keisuke Fujii `_. @@ -2219,6 +2219,7 @@ Enhancements for shifting/rotating datasets or arrays along a dimension: .. ipython:: python + :okwarning: array = xray.DataArray([5, 6, 7, 8], dims='x') array.shift(x=2) @@ -2726,6 +2727,7 @@ Enhancements need to supply the time dimension explicitly: .. ipython:: python + :verbatim: time = pd.date_range('2000-01-01', freq='6H', periods=10) array = xray.DataArray(np.arange(10), [('time', time)]) @@ -2735,6 +2737,7 @@ Enhancements options such as ``closed`` and ``label`` let you control labeling: .. ipython:: python + :verbatim: array.resample('1D', dim='time', how='sum', label='right') @@ -2742,6 +2745,7 @@ Enhancements (upsampling), xray will insert missing values: .. ipython:: python + :verbatim: array.resample('3H', 'time') @@ -2749,12 +2753,14 @@ Enhancements last examples from each group along the grouped axis: .. ipython:: python + :verbatim: array.groupby('time.day').first() These methods combine well with ``resample``: .. ipython:: python + :verbatim: array.resample('1D', dim='time', how='first') diff --git a/xarray/backends/api.py b/xarray/backends/api.py index aa1439d2510..b4297801309 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -487,6 +487,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, """Open multiple files as a single dataset. Requires dask to be installed. See documentation for details on dask [1]. Attributes from the first dataset file are used for the combined dataset. + Parameters ---------- paths : str or sequence diff --git a/xarray/core/combine.py b/xarray/core/combine.py index c9924b2ad1e..e34bb05b3c1 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -560,6 +560,7 @@ def auto_combine(datasets, concat_dim=_CONCAT_DIM_DEFAULT, ``auto_combine`` works well if you have N years of data and M data variables, and each combination of a distinct time period and set of data variables is saved its own dataset. + Parameters ---------- datasets : sequence of xarray.Dataset @@ -589,6 +590,7 @@ def auto_combine(datasets, concat_dim=_CONCAT_DIM_DEFAULT, Details are in the documentation of concat coords : {'minimal', 'different', 'all' or list of str}, optional Details are in the documentation of conca + Returns ------- combined : xarray.Dataset diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 938b05f963b..e04648bd0b3 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -997,8 +997,8 @@ def interp(self, coords=None, method='linear', assume_sorted=False, interpolated: xr.DataArray New dataarray on the new coordinates. - Note - ---- + Notes + ----- scipy is required. See Also @@ -1053,8 +1053,8 @@ def interp_like(self, other, method='linear', assume_sorted=False, Another dataarray by interpolating this dataarray's data along the coordinates of the other object. - Note - ---- + Notes + ----- scipy is required. If the dataarray has object-type coordinates, reindex is used for these coordinates instead of the interpolation. @@ -2291,13 +2291,13 @@ def quantile(self, q, dim=None, interpolation='linear', keep_attrs=None): use when the desired quantile lies between two data points ``i < j``: - * linear: ``i + (j - i) * fraction``, where ``fraction`` is + - linear: ``i + (j - i) * fraction``, where ``fraction`` is the fractional part of the index surrounded by ``i`` and ``j``. - * lower: ``i``. - * higher: ``j``. - * nearest: ``i`` or ``j``, whichever is nearest. - * midpoint: ``(i + j) / 2``. + - lower: ``i``. + - higher: ``j``. + - nearest: ``i`` or ``j``, whichever is nearest. + - midpoint: ``(i + j) / 2``. keep_attrs : bool, optional If True, the dataset's attributes (`attrs`) will be copied from the original object to the new one. If False (default), the new diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 8f28798a8a9..b253d956a80 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -1945,8 +1945,8 @@ def interp(self, coords=None, method='linear', assume_sorted=False, interpolated: xr.Dataset New dataset on the new coordinates. - Note - ---- + Notes + ----- scipy is required. See Also @@ -2037,8 +2037,8 @@ def interp_like(self, other, method='linear', assume_sorted=False, Another dataset by interpolating this dataset's data along the coordinates of the other object. - Note - ---- + Notes + ----- scipy is required. If the dataset has object-type coordinates, reindex is used for these coordinates instead of the interpolation. @@ -2548,7 +2548,6 @@ def merge(self, other, inplace=None, overwrite_vars=frozenset(), 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts: - - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'equals': all values and dimensions must be the same. From a4c9ab5b5044801d2656e6e5527dcf21bd2dc356 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Tue, 18 Dec 2018 12:21:35 -0500 Subject: [PATCH 022/108] Remove meaningless tz argument in cftime_range (#2613) --- xarray/coding/cftime_offsets.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index 83e8c7a7e4b..9cdd74537d8 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -553,7 +553,7 @@ def _count_not_none(*args): def cftime_range(start=None, end=None, periods=None, freq='D', - tz=None, normalize=False, name=None, closed=None, + normalize=False, name=None, closed=None, calendar='standard'): """Return a fixed frequency CFTimeIndex. From 30288e8ab565bd87924c5bfd380820d9adc0b265 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Tue, 18 Dec 2018 19:56:58 -0800 Subject: [PATCH 023/108] Remove failing Appveyor Python 2.7 32-bit build (#2617) There seems to be some sort of dependency issue on Appveyor, but it's not worth tracking down given how we'll be dropping Python 2.7 in the new year anyways. --- appveyor.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index b816374e6e0..7020adae572 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -7,11 +7,6 @@ branches: environment: matrix: - - PYTHON: "C:\\Python27-conda32" - PYTHON_VERSION: "2.7" - PYTHON_ARCH: "32" - CONDA_ENV: "py27-windows" - - PYTHON: "C:\\Python27-conda64" PYTHON_VERSION: "2.7" PYTHON_ARCH: "64" From 778ffc49135d6f97e17b37b48304995fca72f1e0 Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Tue, 18 Dec 2018 21:12:58 -0800 Subject: [PATCH 024/108] .resample now supports loffset. (#2608) * .resample now supports loffset. * Update whats-new.rst * Fix for pandas 0.19.2 * doc update. * Review comments. --- doc/whats-new.rst | 3 +++ xarray/core/common.py | 9 +++++++-- xarray/core/groupby.py | 28 ++++++++++++++++++++++++++++ xarray/tests/test_dataarray.py | 5 +++++ xarray/tests/test_dataset.py | 12 ++++++++++++ 5 files changed, 55 insertions(+), 2 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 5143672a0c9..3ef4375c499 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -45,6 +45,9 @@ Enhancements "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark `_. - Support Dask ``HighLevelGraphs`` by `Matthew Rocklin `_. +- :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now supports the + ``loffset`` kwarg just like Pandas. + By `Deepak Cherian `_ Bug fixes diff --git a/xarray/core/common.py b/xarray/core/common.py index 34057e3715d..c0a0201c7ce 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -592,7 +592,7 @@ def rolling(self, dim=None, min_periods=None, center=False, **dim_kwargs): center=center) def resample(self, indexer=None, skipna=None, closed=None, label=None, - base=0, keep_attrs=None, **indexer_kwargs): + base=0, keep_attrs=None, loffset=None, **indexer_kwargs): """Returns a Resample object for performing resampling operations. Handles both downsampling and upsampling. If any intervals contain no @@ -612,6 +612,9 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, For frequencies that evenly subdivide 1 day, the "origin" of the aggregated intervals. For example, for '24H' frequency, base could range from 0 through 23. + loffset : timedelta or str, optional + Offset used to adjust the resampled time labels. Some pandas date + offset strings are supported. keep_attrs : bool, optional If True, the object's attributes (`attrs`) will be copied from the original object to the new one. If False (default), the new @@ -700,7 +703,9 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, group = DataArray(dim_coord, coords=dim_coord.coords, dims=dim_coord.dims, name=RESAMPLE_DIM) - grouper = pd.Grouper(freq=freq, closed=closed, label=label, base=base) + # TODO: to_offset() call required for pandas==0.19.2 + grouper = pd.Grouper(freq=freq, closed=closed, label=label, base=base, + loffset=pd.tseries.frequencies.to_offset(loffset)) resampler = self._resample_cls(self, group=group, dim=dim_name, grouper=grouper, resample_dim=RESAMPLE_DIM) diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index defe72ab3ee..58ba4570ede 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -3,6 +3,7 @@ import functools import warnings +import datetime import numpy as np import pandas as pd @@ -154,6 +155,32 @@ def _unique_and_monotonic(group): return index.is_unique and index.is_monotonic +def _apply_loffset(grouper, result): + """ + (copied from pandas) + if loffset is set, offset the result index + + This is NOT an idempotent routine, it will be applied + exactly once to the result. + + Parameters + ---------- + result : Series or DataFrame + the result of resample + """ + + needs_offset = ( + isinstance(grouper.loffset, (pd.DateOffset, datetime.timedelta)) + and isinstance(result.index, pd.DatetimeIndex) + and len(result.index) > 0 + ) + + if needs_offset: + result.index = result.index + grouper.loffset + + grouper.loffset = None + + class GroupBy(SupportsArithmetic): """A object that implements the split-apply-combine pattern. @@ -235,6 +262,7 @@ def __init__(self, obj, group, squeeze=False, grouper=None, bins=None, raise ValueError('index must be monotonic for resampling') s = pd.Series(np.arange(index.size), index) first_items = s.groupby(grouper).first() + _apply_loffset(grouper, first_items) full_index = first_items.index if first_items.isnull().any(): first_items = first_items.dropna() diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 87ee60715a1..ecb60239b72 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2273,6 +2273,11 @@ def test_resample(self): actual = array.resample(time='24H').reduce(np.mean) assert_identical(expected, actual) + actual = array.resample(time='24H', loffset='-12H').mean() + expected = DataArray(array.to_series().resample('24H', loffset='-12H') + .mean()) + assert_identical(expected, actual) + with raises_regex(ValueError, 'index must be monotonic'): array[[2, 0, 1]].resample(time='1D') diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 89ea3ba78a0..d4253ae445e 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -2804,6 +2804,18 @@ def test_resample_by_mean_with_keep_attrs(self): expected = ds.attrs assert expected == actual + def test_resample_loffset(self): + times = pd.date_range('2000-01-01', freq='6H', periods=10) + ds = Dataset({'foo': (['time', 'x', 'y'], np.random.randn(10, 5, 3)), + 'bar': ('time', np.random.randn(10), {'meta': 'data'}), + 'time': times}) + ds.attrs['dsmeta'] = 'dsdata' + + actual = ds.resample(time='24H', loffset='-12H').mean('time').time + expected = xr.DataArray(ds.bar.to_series() + .resample('24H', loffset='-12H').mean()).time + assert_identical(expected, actual) + def test_resample_by_mean_discarding_attrs(self): times = pd.date_range('2000-01-01', freq='6H', periods=10) ds = Dataset({'foo': (['time', 'x', 'y'], np.random.randn(10, 5, 3)), From 57348abb1f4d00a3015d0e7f7a5f0df3c6b59481 Mon Sep 17 00:00:00 2001 From: Fabien Maussion Date: Wed, 19 Dec 2018 18:19:04 +0100 Subject: [PATCH 025/108] CF: also decode time bounds when available (#2571) * CF: also decode time bounds when available * Fix failing test when cftime not present and what's new * Fix windows * Reviews * Reviews 2 --- doc/whats-new.rst | 9 +++++++- xarray/conventions.py | 34 ++++++++++++++++++++++++++++- xarray/tests/test_coding_times.py | 36 +++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 2 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 3ef4375c499..26894e2a1d2 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -33,6 +33,14 @@ v0.11.1 (unreleased) Breaking changes ~~~~~~~~~~~~~~~~ +- Time bounds variables are now also decoded according to CF conventions + (:issue:`2565`). The previous behavior was to decode them only if they + had specific time attributes, now these attributes are copied + automatically from the corresponding time coordinate. This might + brake downstream code that was relying on these variables to be + not decoded. + By `Fabien Maussion `_. + Enhancements ~~~~~~~~~~~~ @@ -49,7 +57,6 @@ Enhancements ``loffset`` kwarg just like Pandas. By `Deepak Cherian `_ - Bug fixes ~~~~~~~~~ diff --git a/xarray/conventions.py b/xarray/conventions.py index f60ee6b2c15..ea85a6d5b74 100644 --- a/xarray/conventions.py +++ b/xarray/conventions.py @@ -320,11 +320,39 @@ def decode_cf_variable(name, var, concat_characters=True, mask_and_scale=True, return Variable(dimensions, data, attributes, encoding=encoding) +def _update_bounds_attributes(variables): + """Adds time attributes to time bounds variables. + + Variables handling time bounds ("Cell boundaries" in the CF + conventions) do not necessarily carry the necessary attributes to be + decoded. This copies the attributes from the time variable to the + associated boundaries. + + See Also: + + http://cfconventions.org/Data/cf-conventions/cf-conventions-1.7/ + cf-conventions.html#cell-boundaries + + https://github.com/pydata/xarray/issues/2565 + """ + + # For all time variables with bounds + for v in variables.values(): + attrs = v.attrs + has_date_units = 'units' in attrs and 'since' in attrs['units'] + if has_date_units and 'bounds' in attrs: + if attrs['bounds'] in variables: + bounds_attrs = variables[attrs['bounds']].attrs + bounds_attrs.setdefault('units', attrs['units']) + if 'calendar' in attrs: + bounds_attrs.setdefault('calendar', attrs['calendar']) + + def decode_cf_variables(variables, attributes, concat_characters=True, mask_and_scale=True, decode_times=True, decode_coords=True, drop_variables=None): """ - Decode a several CF encoded variables. + Decode several CF encoded variables. See: decode_cf_variable """ @@ -350,6 +378,10 @@ def stackable(dim): drop_variables = [] drop_variables = set(drop_variables) + # Time bounds coordinates might miss the decoding attributes + if decode_times: + _update_bounds_attributes(variables) + new_vars = OrderedDict() for k, v in iteritems(variables): if k in drop_variables: diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 0ca57f98a6d..5b69d9adcc0 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -10,6 +10,7 @@ from xarray import DataArray, Variable, coding, decode_cf from xarray.coding.times import (_import_cftime, cftime_to_nptime, decode_cf_datetime, encode_cf_datetime) +from xarray.conventions import _update_bounds_attributes from xarray.core.common import contains_cftime_datetimes from . import ( @@ -624,6 +625,41 @@ def test_decode_cf(calendar): assert ds.test.dtype == np.dtype('M8[ns]') +def test_decode_cf_time_bounds(): + + da = DataArray(np.arange(6, dtype='int64').reshape((3, 2)), + coords={'time': [1, 2, 3]}, + dims=('time', 'nbnd'), name='time_bnds') + + attrs = {'units': 'days since 2001-01', + 'calendar': 'standard', + 'bounds': 'time_bnds'} + + ds = da.to_dataset() + ds['time'].attrs.update(attrs) + _update_bounds_attributes(ds.variables) + assert ds.variables['time_bnds'].attrs == {'units': 'days since 2001-01', + 'calendar': 'standard'} + dsc = decode_cf(ds) + assert dsc.time_bnds.dtype == np.dtype('M8[ns]') + dsc = decode_cf(ds, decode_times=False) + assert dsc.time_bnds.dtype == np.dtype('int64') + + # Do not overwrite existing attrs + ds = da.to_dataset() + ds['time'].attrs.update(attrs) + bnd_attr = {'units': 'hours since 2001-01', 'calendar': 'noleap'} + ds['time_bnds'].attrs.update(bnd_attr) + _update_bounds_attributes(ds.variables) + assert ds.variables['time_bnds'].attrs == bnd_attr + + # If bounds variable not available do not complain + ds = da.to_dataset() + ds['time'].attrs.update(attrs) + ds['time'].attrs['bounds'] = 'fake_var' + _update_bounds_attributes(ds.variables) + + @pytest.fixture(params=_ALL_CALENDARS) def calendar(request): return request.param From a15587de419f8a47a875013813186a36fdc04c08 Mon Sep 17 00:00:00 2001 From: Roman Yurchak Date: Thu, 20 Dec 2018 19:01:38 +0100 Subject: [PATCH 026/108] FIX Don't raise a deprecation warning for xarray.ufuncs.{angle,iscomplex} (#2615) * Don't raise a warning for xarray.ufuncs.angle * Update warning message --- xarray/tests/test_ufuncs.py | 35 +++++++++++++++++++++++++++++++++++ xarray/ufuncs.py | 10 ++++++---- 2 files changed, 41 insertions(+), 4 deletions(-) diff --git a/xarray/tests/test_ufuncs.py b/xarray/tests/test_ufuncs.py index 6941efb1c6e..ff24eee3303 100644 --- a/xarray/tests/test_ufuncs.py +++ b/xarray/tests/test_ufuncs.py @@ -172,6 +172,41 @@ def test_xarray_ufuncs_deprecation(): with pytest.warns(PendingDeprecationWarning, match='xarray.ufuncs'): xu.cos(xr.DataArray([0, 1])) + with pytest.warns(None) as record: + xu.angle(xr.DataArray([0, 1])) + record = [el.message for el in record + if el.category == PendingDeprecationWarning] + assert len(record) == 0 + + +@requires_np113 +@pytest.mark.filterwarnings('ignore::RuntimeWarning') +@pytest.mark.parametrize( + 'name', + [name for name in dir(xu) + if (not name.startswith('_') and hasattr(np, name) + and name not in ['print_function', 'absolute_import', 'division'])] +) +def test_numpy_ufuncs(name, request): + x = xr.DataArray([1, 1]) + + np_func = getattr(np, name) + if hasattr(np_func, 'nin') and np_func.nin == 2: + args = (x, x) + else: + args = (x,) + + y = np_func(*args) + + if name in ['angle', 'iscomplex']: + # these functions need to be handled with __array_function__ protocol + assert isinstance(y, np.ndarray) + elif name in ['frexp']: + # np.frexp returns a tuple + assert not isinstance(y, xr.DataArray) + else: + assert isinstance(y, xr.DataArray) + def test_xarray_ufuncs_pickle(): a = 1.0 diff --git a/xarray/ufuncs.py b/xarray/ufuncs.py index 628f8568a6d..66602290dab 100644 --- a/xarray/ufuncs.py +++ b/xarray/ufuncs.py @@ -44,10 +44,12 @@ def __init__(self, name): self._name = name def __call__(self, *args, **kwargs): - _warnings.warn( - 'xarray.ufuncs will be deprecated when xarray no longer supports ' - 'versions of numpy older than v1.13. Instead, use numpy ufuncs ' - 'directly.', PendingDeprecationWarning, stacklevel=2) + if self._name not in ['angle', 'iscomplex']: + _warnings.warn( + 'xarray.ufuncs will be deprecated when xarray no longer ' + 'supports versions of numpy older than v1.17. Instead, use ' + 'numpy ufuncs directly.', + PendingDeprecationWarning, stacklevel=2) new_args = args f = _dask_or_eager_func(self._name, array_args=slice(len(args))) From ce52341f309fda97f7d0e8482511d1c59eacb833 Mon Sep 17 00:00:00 2001 From: Daniel Wennberg Date: Sat, 22 Dec 2018 23:57:58 +0100 Subject: [PATCH 027/108] Get 0d slices of ndarrays directly from indexing (#2625) * Add test to ensure that 0d slices are views * Get 0d slices of ndarrays directly from indexing * Add 0d slice documentation --- doc/whats-new.rst | 3 +++ xarray/core/indexing.py | 16 +++++----------- xarray/tests/test_variable.py | 5 +++++ 3 files changed, 13 insertions(+), 11 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 26894e2a1d2..34654a85430 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -56,6 +56,9 @@ Enhancements - :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now supports the ``loffset`` kwarg just like Pandas. By `Deepak Cherian `_ +- 0d slices of ndarrays are now obtained directly through indexing, rather than + extracting and wrapping a scalar, avoiding unnecessary copying. By `Daniel + Wennberg `_. Bug fixes ~~~~~~~~~ diff --git a/xarray/core/indexing.py b/xarray/core/indexing.py index d51da471c8d..02f2644d57b 100644 --- a/xarray/core/indexing.py +++ b/xarray/core/indexing.py @@ -1142,15 +1142,6 @@ def __init__(self, array): 'Trying to wrap {}'.format(type(array))) self.array = array - def _ensure_ndarray(self, value): - # We always want the result of indexing to be a NumPy array. If it's - # not, then it really should be a 0d array. Doing the coercion here - # instead of inside variable.as_compatible_data makes it less error - # prone. - if not isinstance(value, np.ndarray): - value = utils.to_0d_array(value) - return value - def _indexing_array_and_key(self, key): if isinstance(key, OuterIndexer): array = self.array @@ -1160,7 +1151,10 @@ def _indexing_array_and_key(self, key): key = key.tuple elif isinstance(key, BasicIndexer): array = self.array - key = key.tuple + # We want 0d slices rather than scalars. This is achieved by + # appending an ellipsis (see + # https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#detailed-notes). # noqa + key = key.tuple + (Ellipsis,) else: raise TypeError('unexpected key type: {}'.format(type(key))) @@ -1171,7 +1165,7 @@ def transpose(self, order): def __getitem__(self, key): array, key = self._indexing_array_and_key(key) - return self._ensure_ndarray(array[key]) + return array[key] def __setitem__(self, key, value): array, key = self._indexing_array_and_key(key) diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 84813f6c918..d98783fe2dd 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -1147,6 +1147,11 @@ def test_getitem_basic(self): assert v_new.dims == ('x', ) assert_array_equal(v_new, v._data[:, 1]) + # test that we obtain a modifiable view when taking a 0d slice + v_new = v[0, 0] + v_new[...] += 99 + assert_array_equal(v_new, v._data[0, 0]) + def test_getitem_with_mask_2d_input(self): v = Variable(('x', 'y'), [[0, 1, 2], [3, 4, 5]]) assert_identical(v._getitem_with_mask(([-1, 0], [1, -1])), From 9352b3c382c3c90353f67ecfb9e7016b172c0955 Mon Sep 17 00:00:00 2001 From: Scott Henderson Date: Sun, 23 Dec 2018 11:02:52 -0800 Subject: [PATCH 028/108] added some logic to deal with rasterio objects in addition to filepaths (#2589) * added some logic to deal with rasterio objects in addition to filepath strings * added no network test, pep8 compliance, whatsnew.rst * removed subclass, added to base RasterioArrayWrapper * upped rasterio test version to > 1 * specified rasterio version should be greater than 1 --- .travis.yml | 2 +- ....36.yml => requirements-py36-rasterio.yml} | 2 +- doc/installing.rst | 2 +- doc/whats-new.rst | 5 + xarray/backends/rasterio_.py | 35 ++++-- xarray/tests/test_backends.py | 113 ++++++++++++++---- 6 files changed, 123 insertions(+), 36 deletions(-) rename ci/{requirements-py36-rasterio-0.36.yml => requirements-py36-rasterio.yml} (93%) diff --git a/.travis.yml b/.travis.yml index defb37ec8aa..881d293263b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,7 +29,7 @@ matrix: - env: CONDA_ENV=py36-bottleneck-dev - env: CONDA_ENV=py36-condaforge-rc - env: CONDA_ENV=py36-pynio-dev - - env: CONDA_ENV=py36-rasterio-0.36 + - env: CONDA_ENV=py36-rasterio - env: CONDA_ENV=py36-zarr-dev - env: CONDA_ENV=docs - env: CONDA_ENV=py36-hypothesis diff --git a/ci/requirements-py36-rasterio-0.36.yml b/ci/requirements-py36-rasterio.yml similarity index 93% rename from ci/requirements-py36-rasterio-0.36.yml rename to ci/requirements-py36-rasterio.yml index 5c724e1b981..2ec75f5d8b2 100644 --- a/ci/requirements-py36-rasterio-0.36.yml +++ b/ci/requirements-py36-rasterio.yml @@ -16,7 +16,7 @@ dependencies: - scipy - seaborn - toolz - - rasterio=0.36.0 + - rasterio>=1.0 - bottleneck - pip: - coveralls diff --git a/doc/installing.rst b/doc/installing.rst index 64751eea637..fbe6a316936 100644 --- a/doc/installing.rst +++ b/doc/installing.rst @@ -32,7 +32,7 @@ For netCDF and IO for accessing CAMx, GEOS-Chem (bpch), NOAA ARL files, ICARTT files (ffi1001) and many other. - `rasterio `__: for reading GeoTiffs and - other gridded raster datasets. + other gridded raster datasets. (version 1.0 or later) - `iris `__: for conversion to and from iris' Cube objects - `cfgrib `__: for reading GRIB files via the diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 34654a85430..ceacd6ca0b7 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -33,6 +33,7 @@ v0.11.1 (unreleased) Breaking changes ~~~~~~~~~~~~~~~~ +- Minimum rasterio version increased from 0.36 to 1.0 (for ``open_rasterio``) - Time bounds variables are now also decoded according to CF conventions (:issue:`2565`). The previous behavior was to decode them only if they had specific time attributes, now these attributes are copied @@ -49,6 +50,10 @@ Enhancements - :py:class:`CFTimeIndex` uses slicing for string indexing when possible (like :py:class:`pandas.DatetimeIndex`), which avoids unnecessary copies. By `Stephan Hoyer `_ +- Enable passing ``rasterio.io.DatasetReader`` or ``rasterio.vrt.WarpedVRT`` to + ``open_rasterio`` instead of file path string. Allows for in-memory + reprojection, see (:issue:`2588`). + By `Scott Henderson `_. - Like :py:class:`pandas.DatetimeIndex`, :py:class:`CFTimeIndex` now supports "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark `_. diff --git a/xarray/backends/rasterio_.py b/xarray/backends/rasterio_.py index 7a343a6529e..27655438cc3 100644 --- a/xarray/backends/rasterio_.py +++ b/xarray/backends/rasterio_.py @@ -2,7 +2,6 @@ import warnings from collections import OrderedDict from distutils.version import LooseVersion - import numpy as np from .. import DataArray @@ -23,13 +22,14 @@ class RasterioArrayWrapper(BackendArray): """A wrapper around rasterio dataset objects""" - - def __init__(self, manager): + def __init__(self, manager, vrt_params=None): + from rasterio.vrt import WarpedVRT self.manager = manager # cannot save riods as an attribute: this would break pickleability riods = manager.acquire() - + riods = riods if vrt_params is None else WarpedVRT(riods, **vrt_params) + self.vrt_params = vrt_params self._shape = (riods.count, riods.height, riods.width) dtypes = riods.dtypes @@ -103,6 +103,7 @@ def _get_indexer(self, key): return band_key, tuple(window), tuple(squeeze_axis), tuple(np_inds) def _getitem(self, key): + from rasterio.vrt import WarpedVRT band_key, window, squeeze_axis, np_inds = self._get_indexer(key) if not band_key or any(start == stop for (start, stop) in window): @@ -112,6 +113,7 @@ def _getitem(self, key): out = np.zeros(shape, dtype=self.dtype) else: riods = self.manager.acquire() + riods = riods if self.vrt_params is None else WarpedVRT(riods,**self.vrt_params) out = riods.read(band_key, window=window) if squeeze_axis: @@ -176,8 +178,8 @@ def open_rasterio(filename, parse_coordinates=None, chunks=None, cache=None, Parameters ---------- - filename : str - Path to the file to open. + filename : str, rasterio.DatasetReader, or rasterio.WarpedVRT + Path to the file to open. Or already open rasterio dataset. parse_coordinates : bool, optional Whether to parse the x and y coordinates out of the file's ``transform`` attribute or not. The default is to automatically @@ -204,11 +206,24 @@ def open_rasterio(filename, parse_coordinates=None, chunks=None, cache=None, data : DataArray The newly created DataArray. """ - import rasterio + from rasterio.vrt import WarpedVRT + vrt_params = None + if isinstance(filename, rasterio.io.DatasetReader): + filename = filename.name + elif isinstance(filename, rasterio.vrt.WarpedVRT): + vrt = filename + filename = vrt.src_dataset.name + vrt_params = dict(crs=vrt.crs.to_string(), + resampling=vrt.resampling, + src_nodata=vrt.src_nodata, + dst_nodata=vrt.dst_nodata, + tolerance=vrt.tolerance, + warp_extras=vrt.warp_extras) manager = CachingFileManager(rasterio.open, filename, mode='r') riods = manager.acquire() + riods = riods if vrt_params is None else WarpedVRT(riods, **vrt_params) if cache is None: cache = chunks is None @@ -282,13 +297,13 @@ def open_rasterio(filename, parse_coordinates=None, chunks=None, cache=None, for k, v in meta.items(): # Add values as coordinates if they match the band count, # as attributes otherwise - if (isinstance(v, (list, np.ndarray)) and - len(v) == riods.count): + if (isinstance(v, (list, np.ndarray)) + and len(v) == riods.count): coords[k] = ('band', np.asarray(v)) else: attrs[k] = v - data = indexing.LazilyOuterIndexedArray(RasterioArrayWrapper(manager)) + data = indexing.LazilyOuterIndexedArray(RasterioArrayWrapper(manager, vrt_params)) # this lets you write arrays loaded with rasterio data = indexing.CopyOnWriteArray(data) diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index bad9e99c042..3bc26c90ec0 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -233,9 +233,9 @@ def check_dtypes_roundtripped(self, expected, actual): actual_dtype = actual.variables[k].dtype # TODO: check expected behavior for string dtypes more carefully string_kinds = {'O', 'S', 'U'} - assert (expected_dtype == actual_dtype or - (expected_dtype.kind in string_kinds and - actual_dtype.kind in string_kinds)) + assert (expected_dtype == actual_dtype + or (expected_dtype.kind in string_kinds and + actual_dtype.kind in string_kinds)) def test_roundtrip_test_data(self): expected = create_test_data() @@ -410,17 +410,17 @@ def test_roundtrip_cftime_datetime_data(self): with self.roundtrip(expected, save_kwargs=kwds) as actual: abs_diff = abs(actual.t.values - expected_decoded_t) assert (abs_diff <= np.timedelta64(1, 's')).all() - assert (actual.t.encoding['units'] == - 'days since 0001-01-01 00:00:00.000000') - assert (actual.t.encoding['calendar'] == - expected_calendar) + assert (actual.t.encoding['units'] + == 'days since 0001-01-01 00:00:00.000000') + assert (actual.t.encoding['calendar'] + == expected_calendar) abs_diff = abs(actual.t0.values - expected_decoded_t0) assert (abs_diff <= np.timedelta64(1, 's')).all() - assert (actual.t0.encoding['units'] == - 'days since 0001-01-01') - assert (actual.t.encoding['calendar'] == - expected_calendar) + assert (actual.t0.encoding['units'] + == 'days since 0001-01-01') + assert (actual.t.encoding['calendar'] + == expected_calendar) def test_roundtrip_timedelta_data(self): time_deltas = pd.to_timedelta(['1h', '2h', 'NaT']) @@ -668,8 +668,8 @@ def test_roundtrip_mask_and_scale(self, decoded_fn, encoded_fn): with self.roundtrip(decoded) as actual: for k in decoded.variables: - assert (decoded.variables[k].dtype == - actual.variables[k].dtype) + assert (decoded.variables[k].dtype + == actual.variables[k].dtype) assert_allclose(decoded, actual, decode_bytes=False) with self.roundtrip(decoded, @@ -677,15 +677,15 @@ def test_roundtrip_mask_and_scale(self, decoded_fn, encoded_fn): # TODO: this assumes that all roundtrips will first # encode. Is that something we want to test for? for k in encoded.variables: - assert (encoded.variables[k].dtype == - actual.variables[k].dtype) + assert (encoded.variables[k].dtype + == actual.variables[k].dtype) assert_allclose(encoded, actual, decode_bytes=False) with self.roundtrip(encoded, open_kwargs=dict(decode_cf=False)) as actual: for k in encoded.variables: - assert (encoded.variables[k].dtype == - actual.variables[k].dtype) + assert (encoded.variables[k].dtype + == actual.variables[k].dtype) assert_allclose(encoded, actual, decode_bytes=False) # make sure roundtrip encoding didn't change the @@ -2621,8 +2621,8 @@ def myatts(**attrs): 'ULOD_FLAG': '-7777', 'ULOD_VALUE': 'N/A', 'LLOD_FLAG': '-8888', 'LLOD_VALUE': ('N/A, N/A, N/A, N/A, 0.025'), - 'OTHER_COMMENTS': ('www-air.larc.nasa.gov/missions/etc/' + - 'IcarttDataFormat.htm'), + 'OTHER_COMMENTS': ('www-air.larc.nasa.gov/missions/etc/' + + 'IcarttDataFormat.htm'), 'REVISION': 'R0', 'R0': 'No comments for this revision.', 'TFLAG': 'Start_UTC' @@ -2711,8 +2711,8 @@ def test_uamiv_format_read(self): expected = xr.Variable(('TSTEP',), data, dict(bounds='time_bounds', long_name=('synthesized time coordinate ' + - 'from SDATE, STIME, STEP ' + - 'global attributes'))) + 'from SDATE, STIME, STEP ' + + 'global attributes'))) actual = camxfile.variables['time'] assert_allclose(expected, actual) camxfile.close() @@ -2741,8 +2741,8 @@ def test_uamiv_format_mfread(self): data = np.concatenate([data1] * 2, axis=0) attrs = dict(bounds='time_bounds', long_name=('synthesized time coordinate ' + - 'from SDATE, STIME, STEP ' + - 'global attributes')) + 'from SDATE, STIME, STEP ' + + 'global attributes')) expected = xr.Variable(('TSTEP',), data, attrs) actual = camxfile.variables['time'] assert_allclose(expected, actual) @@ -3158,6 +3158,73 @@ def test_http_url(self): import dask.array as da assert isinstance(actual.data, da.Array) + def test_rasterio_environment(self): + import rasterio + with create_tmp_geotiff() as (tmp_file, expected): + # Should fail with error since suffix not allowed + with pytest.raises(Exception): + with rasterio.Env(GDAL_SKIP='GTiff'): + with xr.open_rasterio(tmp_file) as actual: + assert_allclose(actual, expected) + + def test_rasterio_vrt(self): + import rasterio + # tmp_file default crs is UTM: CRS({'init': 'epsg:32618'} + with create_tmp_geotiff() as (tmp_file, expected): + with rasterio.open(tmp_file) as src: + with rasterio.vrt.WarpedVRT(src, crs='epsg:4326') as vrt: + expected_shape = (vrt.width, vrt.height) + expected_crs = vrt.crs + print(expected_crs) + expected_res = vrt.res + # Value of single pixel in center of image + lon, lat = vrt.xy(vrt.width // 2, vrt.height // 2) + expected_val = next(vrt.sample([(lon, lat)])) + with xr.open_rasterio(vrt) as da: + actual_shape = (da.sizes['x'], da.sizes['y']) + actual_crs = da.crs + print(actual_crs) + actual_res = da.res + actual_val = da.sel(dict(x=lon, y=lat), + method='nearest').data + + assert actual_crs == expected_crs + assert actual_res == expected_res + assert actual_shape == expected_shape + assert expected_val.all() == actual_val.all() + + @network + def test_rasterio_vrt_network(self): + import rasterio + + url = 'https://storage.googleapis.com/\ + gcp-public-data-landsat/LC08/01/047/027/\ + LC08_L1TP_047027_20130421_20170310_01_T1/\ + LC08_L1TP_047027_20130421_20170310_01_T1_B4.TIF' + env = rasterio.Env(GDAL_DISABLE_READDIR_ON_OPEN='EMPTY_DIR', + CPL_VSIL_CURL_USE_HEAD=False, + CPL_VSIL_CURL_ALLOWED_EXTENSIONS='TIF') + with env: + with rasterio.open(url) as src: + with rasterio.vrt.WarpedVRT(src, crs='epsg:4326') as vrt: + expected_shape = (vrt.width, vrt.height) + expected_crs = vrt.crs + expected_res = vrt.res + # Value of single pixel in center of image + lon, lat = vrt.xy(vrt.width // 2, vrt.height // 2) + expected_val = next(vrt.sample([(lon, lat)])) + with xr.open_rasterio(vrt) as da: + actual_shape = (da.sizes['x'], da.sizes['y']) + actual_crs = da.crs + actual_res = da.res + actual_val = da.sel(dict(x=lon, y=lat), + method='nearest').data + + assert_equal(actual_shape, expected_shape) + assert_equal(actual_crs, expected_crs) + assert_equal(actual_res, expected_res) + assert_equal(expected_val, actual_val) + class TestEncodingInvalid(object): From c2ce5ea83b5924302653c8dfba7de68c7d98c942 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sun, 23 Dec 2018 12:11:31 -0800 Subject: [PATCH 029/108] Close files when CachingFileManager is garbage collected (#2595) * Close files when CachingFileManager is garbage collected Fixes GH2560 This frees users from needing to worry about this. * Minor tweak * Test raising an error in __del__ * restore change * Remove the need for a lock in __del__ * Handle locking ourselves with rasterio * Remove race condition with netCDF4 * refactor optional lock * Fix more possible race conditions * Warn if we can't close in FileManager.__del__ * Fix lock acquisition in CachingFileManager.__del__ * Cleaner fall-back for no dask-distributed * Test tweaks * Test for FileManager.__repr__ * Add reference counting to CachingFileManager * remove unused import * Spelling / reorg --- doc/whats-new.rst | 11 ++ xarray/backends/file_manager.py | 124 +++++++++++++++++---- xarray/backends/h5netcdf_.py | 5 +- xarray/backends/locks.py | 47 +++++--- xarray/backends/netCDF4_.py | 10 +- xarray/backends/pseudonetcdf_.py | 7 +- xarray/backends/pynio_.py | 9 +- xarray/backends/rasterio_.py | 31 ++++-- xarray/backends/scipy_.py | 32 +++--- xarray/core/options.py | 9 +- xarray/tests/__init__.py | 18 ++- xarray/tests/test_backends.py | 79 ++++++------- xarray/tests/test_backends_file_manager.py | 100 +++++++++++++++++ 13 files changed, 361 insertions(+), 121 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index ceacd6ca0b7..99a7d33226b 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -57,6 +57,11 @@ Enhancements - Like :py:class:`pandas.DatetimeIndex`, :py:class:`CFTimeIndex` now supports "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark `_. +- The option ``'warn_for_unclosed_files'`` (False by default) has been added to + allow users to enable a warning when files opened by xarray are deallocated + but were not explicitly closed. This is mostly useful for debugging; we + recommend enabling it in your test suites if you use xarray for IO. + By `Stephan Hoyer `_ - Support Dask ``HighLevelGraphs`` by `Matthew Rocklin `_. - :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now supports the ``loffset`` kwarg just like Pandas. @@ -68,6 +73,12 @@ Enhancements Bug fixes ~~~~~~~~~ +- Ensure files are automatically closed, if possible, when no longer referenced + by a Python variable (:issue:`2560`). + By `Stephan Hoyer `_ +- Fixed possible race conditions when reading/writing to disk in parallel + (:issue:`2595`). + By `Stephan Hoyer `_ - Fix h5netcdf saving scalars with filters or chunks (:issue:`2563`). By `Martin Raspaud `_. - Fix parsing of ``_Unsigned`` attribute set by OPENDAP servers. (:issue:`2583`). diff --git a/xarray/backends/file_manager.py b/xarray/backends/file_manager.py index a93285370b2..6362842dd42 100644 --- a/xarray/backends/file_manager.py +++ b/xarray/backends/file_manager.py @@ -1,7 +1,10 @@ +import contextlib import threading +import warnings from ..core import utils from ..core.options import OPTIONS +from .locks import acquire from .lru_cache import LRUCache @@ -11,6 +14,8 @@ assert FILE_CACHE.maxsize, 'file cache must be at least size one' +REF_COUNTS = {} + _DEFAULT_MODE = utils.ReprObject('') @@ -22,7 +27,7 @@ class FileManager(object): many open files and transferring them between multiple processes. """ - def acquire(self): + def acquire(self, needs_lock=True): """Acquire the file object from this manager.""" raise NotImplementedError @@ -62,6 +67,9 @@ class CachingFileManager(FileManager): def __init__(self, opener, *args, **keywords): """Initialize a FileManager. + The cache and ref_counts arguments exist solely to facilitate + dependency injection, and should only be set for tests. + Parameters ---------- opener : callable @@ -90,6 +98,9 @@ def __init__(self, opener, *args, **keywords): global variable and contains non-picklable file objects, an unpickled FileManager objects will be restored with the default cache. + ref_counts : dict, optional + Optional dict to use for keeping track the number of references to + the same file. """ # TODO: replace with real keyword arguments when we drop Python 2 # support @@ -97,6 +108,7 @@ def __init__(self, opener, *args, **keywords): kwargs = keywords.pop('kwargs', None) lock = keywords.pop('lock', None) cache = keywords.pop('cache', FILE_CACHE) + ref_counts = keywords.pop('ref_counts', REF_COUNTS) if keywords: raise TypeError('FileManager() got unexpected keyword arguments: ' '%s' % list(keywords)) @@ -105,34 +117,52 @@ def __init__(self, opener, *args, **keywords): self._args = args self._mode = mode self._kwargs = {} if kwargs is None else dict(kwargs) + self._default_lock = lock is None or lock is False self._lock = threading.Lock() if self._default_lock else lock + + # cache[self._key] stores the file associated with this object. self._cache = cache self._key = self._make_key() + # ref_counts[self._key] stores the number of CachingFileManager objects + # in memory referencing this same file. We use this to know if we can + # close a file when the manager is deallocated. + self._ref_counter = _RefCounter(ref_counts) + self._ref_counter.increment(self._key) + def _make_key(self): """Make a key for caching files in the LRU cache.""" value = (self._opener, self._args, - self._mode, + 'a' if self._mode == 'w' else self._mode, tuple(sorted(self._kwargs.items()))) return _HashedSequence(value) - def acquire(self): + @contextlib.contextmanager + def _optional_lock(self, needs_lock): + """Context manager for optionally acquiring a lock.""" + if needs_lock: + with self._lock: + yield + else: + yield + + def acquire(self, needs_lock=True): """Acquiring a file object from the manager. A new file is only opened if it has expired from the least-recently-used cache. - This method uses a reentrant lock, which ensures that it is - thread-safe. You can safely acquire a file in multiple threads at the - same time, as long as the underlying file object is thread-safe. + This method uses a lock, which ensures that it is thread-safe. You can + safely acquire a file in multiple threads at the same time, as long as + the underlying file object is thread-safe. Returns ------- An open file object, as returned by ``opener(*args, **kwargs)``. """ - with self._lock: + with self._optional_lock(needs_lock): try: file = self._cache[self._key] except KeyError: @@ -144,28 +174,53 @@ def acquire(self): if self._mode == 'w': # ensure file doesn't get overriden when opened again self._mode = 'a' - self._key = self._make_key() self._cache[self._key] = file return file - def _close(self): - default = None - file = self._cache.pop(self._key, default) - if file is not None: - file.close() - def close(self, needs_lock=True): """Explicitly close any associated file object (if necessary).""" # TODO: remove needs_lock if/when we have a reentrant lock in # dask.distributed: https://github.com/dask/dask/issues/3832 - if needs_lock: - with self._lock: - self._close() - else: - self._close() + with self._optional_lock(needs_lock): + default = None + file = self._cache.pop(self._key, default) + if file is not None: + file.close() + + def __del__(self): + # If we're the only CachingFileManger referencing a unclosed file, we + # should remove it from the cache upon garbage collection. + # + # Keeping our own count of file references might seem like overkill, + # but it's actually pretty common to reopen files with the same + # variable name in a notebook or command line environment, e.g., to + # fix the parameters used when opening a file: + # >>> ds = xarray.open_dataset('myfile.nc') + # >>> ds = xarray.open_dataset('myfile.nc', decode_times=False) + # This second assignment to "ds" drops CPython's ref-count on the first + # "ds" argument to zero, which can trigger garbage collections. So if + # we didn't check whether another object is referencing 'myfile.nc', + # the newly opened file would actually be immediately closed! + ref_count = self._ref_counter.decrement(self._key) + + if not ref_count and self._key in self._cache: + if acquire(self._lock, blocking=False): + # Only close files if we can do so immediately. + try: + self.close(needs_lock=False) + finally: + self._lock.release() + + if OPTIONS['warn_for_unclosed_files']: + warnings.warn( + 'deallocating {}, but file is not already closed. ' + 'This may indicate a bug.' + .format(self), RuntimeWarning, stacklevel=2) def __getstate__(self): """State for pickling.""" + # cache and ref_counts are intentionally omitted: we don't want to try + # to serialize these global objects. lock = None if self._default_lock else self._lock return (self._opener, self._args, self._mode, self._kwargs, lock) @@ -174,6 +229,34 @@ def __setstate__(self, state): opener, args, mode, kwargs, lock = state self.__init__(opener, *args, mode=mode, kwargs=kwargs, lock=lock) + def __repr__(self): + args_string = ', '.join(map(repr, self._args)) + if self._mode is not _DEFAULT_MODE: + args_string += ', mode={!r}'.format(self._mode) + return '{}({!r}, {}, kwargs={})'.format( + type(self).__name__, self._opener, args_string, self._kwargs) + + +class _RefCounter(object): + """Class for keeping track of reference counts.""" + def __init__(self, counts): + self._counts = counts + self._lock = threading.Lock() + + def increment(self, name): + with self._lock: + count = self._counts[name] = self._counts.get(name, 0) + 1 + return count + + def decrement(self, name): + with self._lock: + count = self._counts[name] - 1 + if count: + self._counts[name] = count + else: + del self._counts[name] + return count + class _HashedSequence(list): """Speedup repeated look-ups by caching hash values. @@ -198,7 +281,8 @@ class DummyFileManager(FileManager): def __init__(self, value): self._value = value - def acquire(self): + def acquire(self, needs_lock=True): + del needs_lock # ignored return self._value def close(self, needs_lock=True): diff --git a/xarray/backends/h5netcdf_.py b/xarray/backends/h5netcdf_.py index 90f63e88cde..0564df5b167 100644 --- a/xarray/backends/h5netcdf_.py +++ b/xarray/backends/h5netcdf_.py @@ -26,8 +26,8 @@ def _getitem(self, key): # h5py requires using lists for fancy indexing: # https://github.com/h5py/h5py/issues/992 key = tuple(list(k) if isinstance(k, np.ndarray) else k for k in key) - array = self.get_array() with self.datastore.lock: + array = self.get_array(needs_lock=False) return array[key] @@ -230,9 +230,6 @@ def prepare_variable(self, name, variable, check_encoding=False, def sync(self): self.ds.sync() - # if self.autoclose: - # self.close() - # super(H5NetCDFStore, self).sync(compute=compute) def close(self, **kwargs): self._manager.close(**kwargs) diff --git a/xarray/backends/locks.py b/xarray/backends/locks.py index f633280ef1d..6c135fd1240 100644 --- a/xarray/backends/locks.py +++ b/xarray/backends/locks.py @@ -8,6 +8,11 @@ # no need to worry about serializing the lock SerializableLock = threading.Lock +try: + from dask.distributed import Lock as DistributedLock +except ImportError: + DistributedLock = None + # Locks used by multiple backends. # Neither HDF5 nor the netCDF-C library are thread-safe. @@ -33,16 +38,11 @@ def _get_multiprocessing_lock(key): return multiprocessing.Lock() -def _get_distributed_lock(key): - from dask.distributed import Lock - return Lock(key) - - _LOCK_MAKERS = { None: _get_threaded_lock, 'threaded': _get_threaded_lock, 'multiprocessing': _get_multiprocessing_lock, - 'distributed': _get_distributed_lock, + 'distributed': DistributedLock, } @@ -113,6 +113,27 @@ def get_write_lock(key): return lock_maker(key) +def acquire(lock, blocking=True): + """Acquire a lock, possibly in a non-blocking fashion. + + Includes backwards compatibility hacks for old versions of Python, dask + and dask-distributed. + """ + if blocking: + # no arguments needed + return lock.acquire() + elif DistributedLock is not None and isinstance(lock, DistributedLock): + # distributed.Lock doesn't support the blocking argument yet: + # https://github.com/dask/distributed/pull/2412 + return lock.acquire(timeout=0) + else: + # "blocking" keyword argument not supported for: + # - threading.Lock on Python 2. + # - dask.SerializableLock with dask v1.0.0 or earlier. + # - multiprocessing.Lock calls the argument "block" instead. + return lock.acquire(blocking) + + class CombinedLock(object): """A combination of multiple locks. @@ -123,12 +144,12 @@ class CombinedLock(object): def __init__(self, locks): self.locks = tuple(set(locks)) # remove duplicates - def acquire(self, *args): - return all(lock.acquire(*args) for lock in self.locks) + def acquire(self, blocking=True): + return all(acquire(lock, blocking=blocking) for lock in self.locks) - def release(self, *args): + def release(self): for lock in self.locks: - lock.release(*args) + lock.release() def __enter__(self): for lock in self.locks: @@ -138,7 +159,6 @@ def __exit__(self, *args): for lock in self.locks: lock.__exit__(*args) - @property def locked(self): return any(lock.locked for lock in self.locks) @@ -149,10 +169,10 @@ def __repr__(self): class DummyLock(object): """DummyLock provides the lock API without any actual locking.""" - def acquire(self, *args): + def acquire(self, blocking=True): pass - def release(self, *args): + def release(self): pass def __enter__(self): @@ -161,7 +181,6 @@ def __enter__(self): def __exit__(self, *args): pass - @property def locked(self): return False diff --git a/xarray/backends/netCDF4_.py b/xarray/backends/netCDF4_.py index 08ba085b77e..2dc692e8724 100644 --- a/xarray/backends/netCDF4_.py +++ b/xarray/backends/netCDF4_.py @@ -48,13 +48,14 @@ def __init__(self, variable_name, datastore): def __setitem__(self, key, value): with self.datastore.lock: - data = self.get_array() + data = self.get_array(needs_lock=False) data[key] = value if self.datastore.autoclose: self.datastore.close(needs_lock=False) - def get_array(self): - return self.datastore.ds.variables[self.variable_name] + def get_array(self, needs_lock=True): + ds = self.datastore._manager.acquire(needs_lock).value + return ds.variables[self.variable_name] class NetCDF4ArrayWrapper(BaseNetCDF4Array): @@ -69,10 +70,9 @@ def _getitem(self, key): else: getitem = operator.getitem - original_array = self.get_array() - try: with self.datastore.lock: + original_array = self.get_array(needs_lock=False) array = getitem(original_array, key) except IndexError: # Catch IndexError in netCDF4 and return a more informative diff --git a/xarray/backends/pseudonetcdf_.py b/xarray/backends/pseudonetcdf_.py index 606ed5251ac..41bc256835a 100644 --- a/xarray/backends/pseudonetcdf_.py +++ b/xarray/backends/pseudonetcdf_.py @@ -24,8 +24,9 @@ def __init__(self, variable_name, datastore): self.shape = array.shape self.dtype = np.dtype(array.dtype) - def get_array(self): - return self.datastore.ds.variables[self.variable_name] + def get_array(self, needs_lock=True): + ds = self.datastore._manager.acquire(needs_lock) + return ds.variables[self.variable_name] def __getitem__(self, key): return indexing.explicit_indexing_adapter( @@ -33,8 +34,8 @@ def __getitem__(self, key): self._getitem) def _getitem(self, key): - array = self.get_array() with self.datastore.lock: + array = self.get_array(needs_lock=False) return array[key] diff --git a/xarray/backends/pynio_.py b/xarray/backends/pynio_.py index 574fff744e3..b171192ed6a 100644 --- a/xarray/backends/pynio_.py +++ b/xarray/backends/pynio_.py @@ -26,18 +26,21 @@ def __init__(self, variable_name, datastore): self.shape = array.shape self.dtype = np.dtype(array.typecode()) - def get_array(self): - return self.datastore.ds.variables[self.variable_name] + def get_array(self, needs_lock=True): + ds = self.datastore._manager.acquire(needs_lock) + return ds.variables[self.variable_name] def __getitem__(self, key): return indexing.explicit_indexing_adapter( key, self.shape, indexing.IndexingSupport.BASIC, self._getitem) def _getitem(self, key): - array = self.get_array() with self.datastore.lock: + array = self.get_array(needs_lock=False) + if key == () and self.ndim == 0: return array.get_value() + return array[key] diff --git a/xarray/backends/rasterio_.py b/xarray/backends/rasterio_.py index 27655438cc3..24874d63f93 100644 --- a/xarray/backends/rasterio_.py +++ b/xarray/backends/rasterio_.py @@ -22,13 +22,16 @@ class RasterioArrayWrapper(BackendArray): """A wrapper around rasterio dataset objects""" - def __init__(self, manager, vrt_params=None): + + def __init__(self, manager, lock, vrt_params=None): from rasterio.vrt import WarpedVRT self.manager = manager + self.lock = lock # cannot save riods as an attribute: this would break pickleability riods = manager.acquire() - riods = riods if vrt_params is None else WarpedVRT(riods, **vrt_params) + if vrt_params is not None: + riods = WarpedVRT(riods, **vrt_params) self.vrt_params = vrt_params self._shape = (riods.count, riods.height, riods.width) @@ -112,9 +115,11 @@ def _getitem(self, key): stop - start for (start, stop) in window) out = np.zeros(shape, dtype=self.dtype) else: - riods = self.manager.acquire() - riods = riods if self.vrt_params is None else WarpedVRT(riods,**self.vrt_params) - out = riods.read(band_key, window=window) + with self.lock: + riods = self.manager.acquire(needs_lock=False) + if self.vrt_params is not None: + riods = WarpedVRT(riods, **self.vrt_params) + out = riods.read(band_key, window=window) if squeeze_axis: out = np.squeeze(out, axis=squeeze_axis) @@ -221,9 +226,13 @@ def open_rasterio(filename, parse_coordinates=None, chunks=None, cache=None, tolerance=vrt.tolerance, warp_extras=vrt.warp_extras) - manager = CachingFileManager(rasterio.open, filename, mode='r') + if lock is None: + lock = RASTERIO_LOCK + + manager = CachingFileManager(rasterio.open, filename, lock=lock, mode='r') riods = manager.acquire() - riods = riods if vrt_params is None else WarpedVRT(riods, **vrt_params) + if vrt_params is not None: + riods = WarpedVRT(riods, **vrt_params) if cache is None: cache = chunks is None @@ -303,7 +312,8 @@ def open_rasterio(filename, parse_coordinates=None, chunks=None, cache=None, else: attrs[k] = v - data = indexing.LazilyOuterIndexedArray(RasterioArrayWrapper(manager, vrt_params)) + data = indexing.LazilyOuterIndexedArray( + RasterioArrayWrapper(manager, lock, vrt_params)) # this lets you write arrays loaded with rasterio data = indexing.CopyOnWriteArray(data) @@ -323,10 +333,7 @@ def open_rasterio(filename, parse_coordinates=None, chunks=None, cache=None, mtime = None token = tokenize(filename, mtime, chunks) name_prefix = 'open_rasterio-%s' % token - if lock is None: - lock = RASTERIO_LOCK - result = result.chunk(chunks, name_prefix=name_prefix, token=token, - lock=lock) + result = result.chunk(chunks, name_prefix=name_prefix, token=token) # Make the file closeable result._file_obj = manager diff --git a/xarray/backends/scipy_.py b/xarray/backends/scipy_.py index b009342efb6..157ae44f547 100644 --- a/xarray/backends/scipy_.py +++ b/xarray/backends/scipy_.py @@ -11,7 +11,7 @@ from ..core.pycompat import OrderedDict, basestring, iteritems from ..core.utils import Frozen, FrozenOrderedDict from .common import BackendArray, WritableCFDataStore -from .locks import get_write_lock +from .locks import ensure_lock, get_write_lock from .file_manager import CachingFileManager, DummyFileManager from .netcdf3 import ( encode_nc3_attr_value, encode_nc3_variable, is_valid_nc3_name) @@ -35,16 +35,17 @@ class ScipyArrayWrapper(BackendArray): def __init__(self, variable_name, datastore): self.datastore = datastore self.variable_name = variable_name - array = self.get_array() + array = self.get_variable().data self.shape = array.shape self.dtype = np.dtype(array.dtype.kind + str(array.dtype.itemsize)) - def get_array(self): - return self.datastore.ds.variables[self.variable_name].data + def get_variable(self, needs_lock=True): + ds = self.datastore._manager.acquire(needs_lock) + return ds.variables[self.variable_name] def __getitem__(self, key): - data = NumpyIndexingAdapter(self.get_array())[key] + data = NumpyIndexingAdapter(self.get_variable().data)[key] # Copy data if the source file is mmapped. This makes things consistent # with the netCDF4 library by ensuring we can safely read arrays even # after closing associated files. @@ -52,15 +53,16 @@ def __getitem__(self, key): return np.array(data, dtype=self.dtype, copy=copy) def __setitem__(self, key, value): - data = self.datastore.ds.variables[self.variable_name] - try: - data[key] = value - except TypeError: - if key is Ellipsis: - # workaround for GH: scipy/scipy#6880 - data[:] = value - else: - raise + with self.datastore.lock: + data = self.get_variable(needs_lock=False) + try: + data[key] = value + except TypeError: + if key is Ellipsis: + # workaround for GH: scipy/scipy#6880 + data[:] = value + else: + raise def _open_scipy_netcdf(filename, mode, mmap, version): @@ -140,6 +142,8 @@ def __init__(self, filename_or_obj, mode='r', format=None, group=None, isinstance(filename_or_obj, basestring)): lock = get_write_lock(filename_or_obj) + self.lock = ensure_lock(lock) + if isinstance(filename_or_obj, basestring): manager = CachingFileManager( _open_scipy_netcdf, filename_or_obj, mode=mode, lock=lock, diff --git a/xarray/core/options.py b/xarray/core/options.py index ab461ca86bc..400508a5d59 100644 --- a/xarray/core/options.py +++ b/xarray/core/options.py @@ -6,6 +6,7 @@ ARITHMETIC_JOIN = 'arithmetic_join' ENABLE_CFTIMEINDEX = 'enable_cftimeindex' FILE_CACHE_MAXSIZE = 'file_cache_maxsize' +WARN_FOR_UNCLOSED_FILES = 'warn_for_unclosed_files' CMAP_SEQUENTIAL = 'cmap_sequential' CMAP_DIVERGENT = 'cmap_divergent' KEEP_ATTRS = 'keep_attrs' @@ -16,6 +17,7 @@ ARITHMETIC_JOIN: 'inner', ENABLE_CFTIMEINDEX: True, FILE_CACHE_MAXSIZE: 128, + WARN_FOR_UNCLOSED_FILES: False, CMAP_SEQUENTIAL: 'viridis', CMAP_DIVERGENT: 'RdBu_r', KEEP_ATTRS: 'default' @@ -33,6 +35,7 @@ def _positive_integer(value): ARITHMETIC_JOIN: _JOIN_OPTIONS.__contains__, ENABLE_CFTIMEINDEX: lambda value: isinstance(value, bool), FILE_CACHE_MAXSIZE: _positive_integer, + WARN_FOR_UNCLOSED_FILES: lambda value: isinstance(value, bool), KEEP_ATTRS: lambda choice: choice in [True, False, 'default'] } @@ -63,7 +66,8 @@ def _get_keep_attrs(default): elif global_choice in [True, False]: return global_choice else: - raise ValueError("The global option keep_attrs must be one of True, False or 'default'.") + raise ValueError("The global option keep_attrs must be one of True, " + "False or 'default'.") class set_options(object): @@ -79,6 +83,9 @@ class set_options(object): global least-recently-usage cached. This should be smaller than your system's per-process file descriptor limit, e.g., ``ulimit -n`` on Linux. Default: 128. + - ``warn_for_unclosed_files``: whether or not to issue a warning when + unclosed files are deallocated (default False). This is mostly useful + for debugging. - ``cmap_sequential``: colormap to use for nondivergent data plots. Default: ``viridis``. If string, must be matplotlib built-in colormap. Can also be a Colormap object (e.g. mpl.cm.magma) diff --git a/xarray/tests/__init__.py b/xarray/tests/__init__.py index cd66ad82356..c57f6720810 100644 --- a/xarray/tests/__init__.py +++ b/xarray/tests/__init__.py @@ -13,6 +13,7 @@ import pytest from xarray.core import utils +from xarray.core.options import set_options from xarray.core.indexing import ExplicitlyIndexed from xarray.testing import (assert_equal, assert_identical, # noqa: F401 assert_allclose, assert_combined_tile_ids_equal) @@ -88,12 +89,6 @@ def LooseVersion(vstring): not has_cftime_or_netCDF4, reason='requires cftime or netCDF4') if not has_pathlib: has_pathlib, requires_pathlib = _importorskip('pathlib2') -if has_dask: - import dask - if LooseVersion(dask.__version__) < '0.18': - dask.set_options(get=dask.get) - else: - dask.config.set(scheduler='single-threaded') try: import_seaborn() has_seaborn = True @@ -102,6 +97,17 @@ def LooseVersion(vstring): requires_seaborn = pytest.mark.skipif(not has_seaborn, reason='requires seaborn') +# change some global options for tests +set_options(warn_for_unclosed_files=True) + +if has_dask: + import dask + if LooseVersion(dask.__version__) < '0.18': + dask.set_options(get=dask.get) + else: + dask.config.set(scheduler='single-threaded') + +# pytest config try: _SKIP_FLAKY = not pytest.config.getoption("--run-flaky") _SKIP_NETWORK_TESTS = not pytest.config.getoption("--run-network-tests") diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 3bc26c90ec0..f4d9154eadb 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -299,18 +299,23 @@ def test_pickle(self): expected = Dataset({'foo': ('x', [42])}) with self.roundtrip( expected, allow_cleanup_failure=ON_WINDOWS) as roundtripped: - raw_pickle = pickle.dumps(roundtripped) - # windows doesn't like opening the same file twice - roundtripped.close() - unpickled_ds = pickle.loads(raw_pickle) - assert_identical(expected, unpickled_ds) + with roundtripped: + # Windows doesn't like reopening an already open file + raw_pickle = pickle.dumps(roundtripped) + with pickle.loads(raw_pickle) as unpickled_ds: + assert_identical(expected, unpickled_ds) + @pytest.mark.filterwarnings("ignore:deallocating CachingFileManager") def test_pickle_dataarray(self): expected = Dataset({'foo': ('x', [42])}) with self.roundtrip( expected, allow_cleanup_failure=ON_WINDOWS) as roundtripped: - unpickled_array = pickle.loads(pickle.dumps(roundtripped['foo'])) - assert_identical(expected['foo'], unpickled_array) + with roundtripped: + raw_pickle = pickle.dumps(roundtripped['foo']) + # TODO: figure out how to explicitly close the file for the + # unpickled DataArray? + unpickled = pickle.loads(raw_pickle) + assert_identical(expected['foo'], unpickled) def test_dataset_caching(self): expected = Dataset({'foo': ('x', [5, 6, 7])}) @@ -435,13 +440,13 @@ def test_roundtrip_float64_data(self): assert_identical(expected, actual) def test_roundtrip_example_1_netcdf(self): - expected = open_example_dataset('example_1.nc') - with self.roundtrip(expected) as actual: - # we allow the attributes to differ since that - # will depend on the encoding used. For example, - # without CF encoding 'actual' will end up with - # a dtype attribute. - assert_equal(expected, actual) + with open_example_dataset('example_1.nc') as expected: + with self.roundtrip(expected) as actual: + # we allow the attributes to differ since that + # will depend on the encoding used. For example, + # without CF encoding 'actual' will end up with + # a dtype attribute. + assert_equal(expected, actual) def test_roundtrip_coordinates(self): original = Dataset({'foo': ('x', [0, 1])}, @@ -1274,6 +1279,7 @@ def test_autoclose_future_warning(self): @requires_netCDF4 @requires_dask +@pytest.mark.filterwarnings('ignore:deallocating CachingFileManager') class TestNetCDF4ViaDaskData(TestNetCDF4Data): @contextlib.contextmanager def roundtrip(self, data, save_kwargs={}, open_kwargs={}, @@ -1659,9 +1665,9 @@ def test_roundtrip_example_1_netcdf_gz(self): def test_netcdf3_endianness(self): # regression test for GH416 - expected = open_example_dataset('bears.nc', engine='scipy') - for var in expected.variables.values(): - assert var.dtype.isnative + with open_example_dataset('bears.nc', engine='scipy') as expected: + for var in expected.variables.values(): + assert var.dtype.isnative @requires_netCDF4 def test_nc4_scipy(self): @@ -1979,13 +1985,13 @@ def test_open_mfdataset_manyfiles(readengine, nfiles, parallel, chunks, subds.to_netcdf(tmpfiles[ii], engine=writeengine) # check that calculation on opened datasets works properly - actual = open_mfdataset(tmpfiles, engine=readengine, parallel=parallel, - chunks=chunks) + with open_mfdataset(tmpfiles, engine=readengine, parallel=parallel, + chunks=chunks) as actual: - # check that using open_mfdataset returns dask arrays for variables - assert isinstance(actual['foo'].data, dask_array_type) + # check that using open_mfdataset returns dask arrays for variables + assert isinstance(actual['foo'].data, dask_array_type) - assert_identical(original, actual) + assert_identical(original, actual) @requires_scipy_or_netCDF4 @@ -2032,20 +2038,17 @@ def gen_datasets_with_common_coord_and_time(self): return ds1, ds2 - def test_open_mfdataset_does_same_as_concat(self): - options = ['all', 'minimal', 'different', ] - + @pytest.mark.parametrize('opt', ['all', 'minimal', 'different']) + def test_open_mfdataset_does_same_as_concat(self, opt): with self.setup_files_and_datasets() as (files, [ds1, ds2]): - for opt in options: - with open_mfdataset(files, data_vars=opt) as ds: - kwargs = dict(data_vars=opt, dim='t') - ds_expect = xr.concat([ds1, ds2], **kwargs) - assert_identical(ds, ds_expect) - - with open_mfdataset(files, coords=opt) as ds: - kwargs = dict(coords=opt, dim='t') - ds_expect = xr.concat([ds1, ds2], **kwargs) - assert_identical(ds, ds_expect) + with open_mfdataset(files, data_vars=opt) as ds: + kwargs = dict(data_vars=opt, dim='t') + ds_expect = xr.concat([ds1, ds2], **kwargs) + assert_identical(ds, ds_expect) + with open_mfdataset(files, coords=opt) as ds: + kwargs = dict(coords=opt, dim='t') + ds_expect = xr.concat([ds1, ds2], **kwargs) + assert_identical(ds, ds_expect) def test_common_coord_when_datavars_all(self): opt = 'all' @@ -2160,12 +2163,10 @@ def test_open_mfdataset(self): original.isel(x=slice(5, 10)).to_netcdf(tmp2) with open_mfdataset([tmp1, tmp2]) as actual: assert isinstance(actual.foo.variable.data, da.Array) - assert actual.foo.variable.data.chunks == \ - ((5, 5),) + assert actual.foo.variable.data.chunks == ((5, 5),) assert_identical(original, actual) with open_mfdataset([tmp1, tmp2], chunks={'x': 3}) as actual: - assert actual.foo.variable.data.chunks == \ - ((3, 2, 3, 2),) + assert actual.foo.variable.data.chunks == ((3, 2, 3, 2),) with raises_regex(IOError, 'no files to open'): diff --git a/xarray/tests/test_backends_file_manager.py b/xarray/tests/test_backends_file_manager.py index 591c981cd45..3b618f35ea7 100644 --- a/xarray/tests/test_backends_file_manager.py +++ b/xarray/tests/test_backends_file_manager.py @@ -1,3 +1,5 @@ +import collections +import gc import pickle import threading try: @@ -9,6 +11,7 @@ from xarray.backends.file_manager import CachingFileManager from xarray.backends.lru_cache import LRUCache +from xarray.core.options import set_options @pytest.fixture(params=[1, 2, 3, None]) @@ -38,6 +41,103 @@ def test_file_manager_mock_write(file_cache): lock.__enter__.assert_has_calls([mock.call(), mock.call()]) +@pytest.mark.parametrize('expected_warning', [None, RuntimeWarning]) +def test_file_manager_autoclose(expected_warning): + mock_file = mock.Mock() + opener = mock.Mock(return_value=mock_file) + cache = {} + + manager = CachingFileManager(opener, 'filename', cache=cache) + manager.acquire() + assert cache + + with set_options(warn_for_unclosed_files=expected_warning is not None): + with pytest.warns(expected_warning): + del manager + gc.collect() + + assert not cache + mock_file.close.assert_called_once_with() + + +def test_file_manager_autoclose_while_locked(): + opener = mock.Mock() + lock = threading.Lock() + cache = {} + + manager = CachingFileManager(opener, 'filename', lock=lock, cache=cache) + manager.acquire() + assert cache + + lock.acquire() + + with set_options(warn_for_unclosed_files=False): + del manager + gc.collect() + + # can't clear the cache while locked, but also don't block in __del__ + assert cache + + +def test_file_manager_repr(): + opener = mock.Mock() + manager = CachingFileManager(opener, 'my-file') + assert 'my-file' in repr(manager) + + +def test_file_manager_refcounts(): + mock_file = mock.Mock() + opener = mock.Mock(spec=open, return_value=mock_file) + cache = {} + ref_counts = {} + + manager = CachingFileManager( + opener, 'filename', cache=cache, ref_counts=ref_counts) + assert ref_counts[manager._key] == 1 + manager.acquire() + assert cache + + manager2 = CachingFileManager( + opener, 'filename', cache=cache, ref_counts=ref_counts) + assert cache + assert manager._key == manager2._key + assert ref_counts[manager._key] == 2 + + with set_options(warn_for_unclosed_files=False): + del manager + gc.collect() + + assert cache + assert ref_counts[manager2._key] == 1 + mock_file.close.assert_not_called() + + with set_options(warn_for_unclosed_files=False): + del manager2 + gc.collect() + + assert not ref_counts + assert not cache + + +def test_file_manager_replace_object(): + opener = mock.Mock() + cache = {} + ref_counts = {} + + manager = CachingFileManager( + opener, 'filename', cache=cache, ref_counts=ref_counts) + manager.acquire() + assert ref_counts[manager._key] == 1 + assert cache + + manager = CachingFileManager( + opener, 'filename', cache=cache, ref_counts=ref_counts) + assert ref_counts[manager._key] == 1 + assert cache + + manager.close() + + def test_file_manager_write_consecutive(tmpdir, file_cache): path1 = str(tmpdir.join('testing1.txt')) path2 = str(tmpdir.join('testing2.txt')) From b5059a538ee2efda4d753cc9a49f8c09cd026c19 Mon Sep 17 00:00:00 2001 From: Keisuke Fujii Date: Mon, 24 Dec 2018 16:37:26 +0100 Subject: [PATCH 030/108] Fix multiindex selection (#2621) * Fix multiindex selection * Support pandas0.19 * a bugfix * Do remove_unused_levels only once in unstack. * import algos * Remove unused import * Adopt local import --- doc/whats-new.rst | 3 +- xarray/core/dataset.py | 8 ++- xarray/core/indexing.py | 5 +- xarray/core/pdcompat.py | 119 +++++++++++++++++++++++++++++++++ xarray/tests/test_dataarray.py | 14 ++++ 5 files changed, 146 insertions(+), 3 deletions(-) create mode 100644 xarray/core/pdcompat.py diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 99a7d33226b..3b5baeaa3cb 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -83,7 +83,8 @@ Bug fixes By `Martin Raspaud `_. - Fix parsing of ``_Unsigned`` attribute set by OPENDAP servers. (:issue:`2583`). By `Deepak Cherian `_ - +- Fix MultiIndex selection to update label and level (:issue:`2619`). + By `Keisuke Fujii `_. .. _whats-new.0.11.0: diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index b253d956a80..397a0f72fef 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -14,7 +14,7 @@ from . import ( alignment, computation, duck_array_ops, formatting, groupby, indexing, ops, - resample, rolling, utils) + pdcompat, resample, rolling, utils) from .. import conventions from ..coding.cftimeindex import _parse_array_of_cftime_strings from .alignment import align @@ -2425,6 +2425,12 @@ def stack(self, dimensions=None, **dimensions_kwargs): def _unstack_once(self, dim): index = self.get_index(dim) + # GH2619. For MultiIndex, we need to call remove_unused. + if LooseVersion(pd.__version__) >= "0.20": + index = index.remove_unused_levels() + else: # for pandas 0.19 + index = pdcompat.remove_unused_levels(index) + full_idx = pd.MultiIndex.from_product(index.levels, names=index.names) # take a shortcut in case the MultiIndex was not modified. diff --git a/xarray/core/indexing.py b/xarray/core/indexing.py index 02f2644d57b..93da2437e28 100644 --- a/xarray/core/indexing.py +++ b/xarray/core/indexing.py @@ -159,6 +159,10 @@ def convert_label_indexer(index, label, index_name='', method=None, indexer, new_index = index.get_loc_level( tuple(label.values()), level=tuple(label.keys())) + # GH2619. Raise a KeyError if nothing is chosen + if indexer.dtype.kind == 'b' and indexer.sum() == 0: + raise KeyError('{} not found'.format(label)) + elif isinstance(label, tuple) and isinstance(index, pd.MultiIndex): if _is_nested_tuple(label): indexer = index.get_locs(label) @@ -168,7 +172,6 @@ def convert_label_indexer(index, label, index_name='', method=None, indexer, new_index = index.get_loc_level( label, level=list(range(len(label))) ) - else: label = (label if getattr(label, 'ndim', 1) > 1 # vectorized-indexing else _asarray_tuplesafe(label)) diff --git a/xarray/core/pdcompat.py b/xarray/core/pdcompat.py new file mode 100644 index 00000000000..c1e153f4d92 --- /dev/null +++ b/xarray/core/pdcompat.py @@ -0,0 +1,119 @@ +# The remove_unused_levels defined here was copied based on the source code +# defined in pandas.core.indexes.muli.py + +# For reference, here is a copy of the pandas copyright notice: + +# (c) 2011-2012, Lambda Foundry, Inc. and PyData Development Team +# All rights reserved. + +# Copyright (c) 2008-2011 AQR Capital Management, LLC +# All rights reserved. + +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: + +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. + +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. + +# * Neither the name of the copyright holder nor the names of any +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +import numpy as np +import pandas as pd + + +# for pandas 0.19 +def remove_unused_levels(self): + """ + create a new MultiIndex from the current that removing + unused levels, meaning that they are not expressed in the labels + The resulting MultiIndex will have the same outward + appearance, meaning the same .values and ordering. It will also + be .equals() to the original. + .. versionadded:: 0.20.0 + Returns + ------- + MultiIndex + Examples + -------- + >>> i = pd.MultiIndex.from_product([range(2), list('ab')]) + MultiIndex(levels=[[0, 1], ['a', 'b']], + labels=[[0, 0, 1, 1], [0, 1, 0, 1]]) + >>> i[2:] + MultiIndex(levels=[[0, 1], ['a', 'b']], + labels=[[1, 1], [0, 1]]) + The 0 from the first level is not represented + and can be removed + >>> i[2:].remove_unused_levels() + MultiIndex(levels=[[1], ['a', 'b']], + labels=[[0, 0], [0, 1]]) + """ + import pandas.core.algorithms as algos + + new_levels = [] + new_labels = [] + + changed = False + for lev, lab in zip(self.levels, self.labels): + + # Since few levels are typically unused, bincount() is more + # efficient than unique() - however it only accepts positive values + # (and drops order): + uniques = np.where(np.bincount(lab + 1) > 0)[0] - 1 + has_na = int(len(uniques) and (uniques[0] == -1)) + + if len(uniques) != len(lev) + has_na: + # We have unused levels + changed = True + + # Recalculate uniques, now preserving order. + # Can easily be cythonized by exploiting the already existing + # "uniques" and stop parsing "lab" when all items are found: + uniques = algos.unique(lab) + if has_na: + na_idx = np.where(uniques == -1)[0] + # Just ensure that -1 is in first position: + uniques[[0, na_idx[0]]] = uniques[[na_idx[0], 0]] + + # labels get mapped from uniques to 0:len(uniques) + # -1 (if present) is mapped to last position + label_mapping = np.zeros(len(lev) + has_na) + # ... and reassigned value -1: + label_mapping[uniques] = np.arange(len(uniques)) - has_na + + lab = label_mapping[lab] + + # new levels are simple + lev = lev.take(uniques[has_na:]) + + new_levels.append(lev) + new_labels.append(lab) + + result = self._shallow_copy() + + if changed: + result._reset_identity() + result._set_levels(new_levels, validate=False) + result._set_labels(new_labels, validate=False) + + return result diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index ecb60239b72..0672861da2c 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -1027,6 +1027,20 @@ def test_sel(lab_indexer, pos_indexer, replaced_idx=False, assert_identical(mdata.sel(x={'one': 'a', 'two': 1}), mdata.sel(one='a', two=1)) + def test_selection_multiindex(self): + # GH2619. For MultiIndex, we need to call remove_unused. + ds = xr.DataArray(np.arange(40).reshape(8, 5), dims=['x', 'y'], + coords={'x': np.arange(8), 'y': np.arange(5)}) + ds = ds.stack(xy=['x', 'y']) + ds_isel = ds.isel(xy=ds['x'] < 4) + with pytest.raises(KeyError): + ds_isel.sel(x=5) + + actual = ds_isel.unstack() + expected = ds.reset_index('xy').isel(xy=ds['x'] < 4) + expected = expected.set_index(xy=['x', 'y']).unstack() + assert_identical(expected, actual) + def test_virtual_default_coords(self): array = DataArray(np.zeros((5,)), dims='x') expected = DataArray(range(5), dims='x', name='x') From 7fcb80f9865a7ade1b9c2f3d48bf0d31d6672bdb Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Mon, 24 Dec 2018 10:58:02 -0500 Subject: [PATCH 031/108] Fix failure in time encoding for pandas < 0.21.1 (#2630) * Fix failure in time encoding for pandas < 0.21.1 * Add a test --- doc/whats-new.rst | 3 +++ xarray/coding/times.py | 2 +- xarray/tests/test_coding_times.py | 13 +++++++++++++ 3 files changed, 17 insertions(+), 1 deletion(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 3b5baeaa3cb..6a37e0c0833 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -83,6 +83,9 @@ Bug fixes By `Martin Raspaud `_. - Fix parsing of ``_Unsigned`` attribute set by OPENDAP servers. (:issue:`2583`). By `Deepak Cherian `_ +- Fix failure in time encoding when exporting to netCDF with versions of pandas + less than 0.21.1 (:issue:`2623`). By `Spencer Clark + `_. - Fix MultiIndex selection to update label and level (:issue:`2619`). By `Keisuke Fujii `_. diff --git a/xarray/coding/times.py b/xarray/coding/times.py index dfc4b2fb023..0f2045cf356 100644 --- a/xarray/coding/times.py +++ b/xarray/coding/times.py @@ -357,7 +357,7 @@ def encode_cf_datetime(dates, units=None, calendar=None): delta_units = _netcdf_to_numpy_timeunit(delta) time_delta = np.timedelta64(1, delta_units).astype('timedelta64[ns]') - ref_date = np.datetime64(pd.Timestamp(ref_date)) + ref_date = pd.Timestamp(ref_date) # Wrap the dates in a DatetimeIndex to do the subtraction to ensure # an OverflowError is raised if the ref_date is too far away from diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 5b69d9adcc0..b7db2b43cab 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -737,3 +737,16 @@ def test_encode_cf_datetime_overflow(shape): num, _, _ = encode_cf_datetime(dates, units, calendar) roundtrip = decode_cf_datetime(num, units, calendar) np.testing.assert_array_equal(dates, roundtrip) + + +def test_encode_cf_datetime_pandas_min(): + # Test that encode_cf_datetime does not fail for versions + # of pandas < 0.21.1 (GH 2623). + dates = pd.date_range('2000', periods=3) + num, units, calendar = encode_cf_datetime(dates) + expected_num = np.array([0., 1., 2.]) + expected_units = 'days since 2000-01-01 00:00:00' + expected_calendar = 'proleptic_gregorian' + np.testing.assert_array_equal(num, expected_num) + assert units == expected_units + assert calendar == expected_calendar From d8d87d21786a7823b84d8f1f1e14f793fbd5352a Mon Sep 17 00:00:00 2001 From: Matti Eskelinen Date: Mon, 24 Dec 2018 12:50:19 -0500 Subject: [PATCH 032/108] Allow passing of positional arguments in `apply` for Groupby objects (#2413) * Allow passing of positional arguments to `func` in `XGroupBy.apply` * Fix the documentation call to `func` to show the actual call. * Add changes to whats-new.rst * Fix typo * Allow passing args to func from DatasetResample and DataArrayResample * Update whats-new with Resample changes * Add tests for func arguments in groupby * Add tests for apply func arguments in resample * flake8 fixes --- doc/whats-new.rst | 8 ++++++++ xarray/core/dataset.py | 4 ++-- xarray/core/groupby.py | 12 ++++++++---- xarray/core/resample.py | 12 ++++++++---- xarray/tests/test_dataarray.py | 11 +++++++++++ xarray/tests/test_dataset.py | 13 +++++++++++++ xarray/tests/test_groupby.py | 22 ++++++++++++++++++++++ 7 files changed, 72 insertions(+), 10 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 6a37e0c0833..19e52f3a3ed 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -66,6 +66,10 @@ Enhancements - :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now supports the ``loffset`` kwarg just like Pandas. By `Deepak Cherian `_ +- The `apply` methods for `DatasetGroupBy`, `DataArrayGroupBy`, + `DatasetResample` and `DataArrayResample` can now pass positional arguments to + the applied function. + By `Matti Eskelinen `_. - 0d slices of ndarrays are now obtained directly through indexing, rather than extracting and wrapping a scalar, avoiding unnecessary copying. By `Daniel Wennberg `_. @@ -260,6 +264,9 @@ Announcements of note: for more details. - We have a new :doc:`roadmap` that outlines our future development plans. +- `Dataset.apply` now properly documents the way `func` is called. + By `Matti Eskelinen `_. + Enhancements ~~~~~~~~~~~~ @@ -267,6 +274,7 @@ Enhancements :py:meth:`~xarray.Dataset.differentiate` are newly added. (:issue:`1332`) By `Keisuke Fujii `_. + - Default colormap for sequential and divergent data can now be set via :py:func:`~xarray.set_options()` (:issue:`2394`) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 397a0f72fef..686ffb37adc 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -2953,8 +2953,8 @@ def apply(self, func, keep_attrs=None, args=(), **kwargs): Parameters ---------- func : function - Function which can be called in the form `f(x, **kwargs)` to - transform each DataArray `x` in this dataset into another + Function which can be called in the form `func(x, *args, **kwargs)` + to transform each DataArray `x` in this dataset into another DataArray. keep_attrs : bool, optional If True, the dataset's attributes (`attrs`) will be copied from diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index 58ba4570ede..9e8c1e6bbc3 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -503,7 +503,7 @@ def lookup_order(dimension): new_order = sorted(stacked.dims, key=lookup_order) return stacked.transpose(*new_order) - def apply(self, func, shortcut=False, **kwargs): + def apply(self, func, shortcut=False, args=(), **kwargs): """Apply a function over each array in the group and concatenate them together into a new array. @@ -532,6 +532,8 @@ def apply(self, func, shortcut=False, **kwargs): If these conditions are satisfied `shortcut` provides significant speedup. This should be the case for many common groupby operations (e.g., applying numpy ufuncs). + args : tuple, optional + Positional arguments passed to `func`. **kwargs Used to call `func(ar, **kwargs)` for each array `ar`. @@ -544,7 +546,7 @@ def apply(self, func, shortcut=False, **kwargs): grouped = self._iter_grouped_shortcut() else: grouped = self._iter_grouped() - applied = (maybe_wrap_array(arr, func(arr, **kwargs)) + applied = (maybe_wrap_array(arr, func(arr, *args, **kwargs)) for arr in grouped) return self._combine(applied, shortcut=shortcut) @@ -642,7 +644,7 @@ def wrapped_func(self, dim=DEFAULT_DIMS, axis=None, class DatasetGroupBy(GroupBy, ImplementsDatasetReduce): - def apply(self, func, **kwargs): + def apply(self, func, args=(), **kwargs): """Apply a function over each Dataset in the group and concatenate them together into a new Dataset. @@ -661,6 +663,8 @@ def apply(self, func, **kwargs): ---------- func : function Callable to apply to each sub-dataset. + args : tuple, optional + Positional arguments to pass to `func`. **kwargs Used to call `func(ds, **kwargs)` for each sub-dataset `ar`. @@ -670,7 +674,7 @@ def apply(self, func, **kwargs): The result of splitting, applying and combining this dataset. """ kwargs.pop('shortcut', None) # ignore shortcut if set (for now) - applied = (func(ds, **kwargs) for ds in self._iter_grouped()) + applied = (func(ds, *args, **kwargs) for ds in self._iter_grouped()) return self._combine(applied) def _combine(self, applied): diff --git a/xarray/core/resample.py b/xarray/core/resample.py index edf7dfc3d41..49351efc70f 100644 --- a/xarray/core/resample.py +++ b/xarray/core/resample.py @@ -129,7 +129,7 @@ def __init__(self, *args, **kwargs): "('{}')! ".format(self._resample_dim, self._dim)) super(DataArrayResample, self).__init__(*args, **kwargs) - def apply(self, func, shortcut=False, **kwargs): + def apply(self, func, shortcut=False, args=(), **kwargs): """Apply a function over each array in the group and concatenate them together into a new array. @@ -158,6 +158,8 @@ def apply(self, func, shortcut=False, **kwargs): If these conditions are satisfied `shortcut` provides significant speedup. This should be the case for many common groupby operations (e.g., applying numpy ufuncs). + args : tuple, optional + Positional arguments passed on to `func`. **kwargs Used to call `func(ar, **kwargs)` for each array `ar`. @@ -167,7 +169,7 @@ def apply(self, func, shortcut=False, **kwargs): The result of splitting, applying and combining this array. """ combined = super(DataArrayResample, self).apply( - func, shortcut=shortcut, **kwargs) + func, shortcut=shortcut, args=args, **kwargs) # If the aggregation function didn't drop the original resampling # dimension, then we need to do so before we can rename the proxy @@ -240,7 +242,7 @@ def __init__(self, *args, **kwargs): "('{}')! ".format(self._resample_dim, self._dim)) super(DatasetResample, self).__init__(*args, **kwargs) - def apply(self, func, **kwargs): + def apply(self, func, args=(), **kwargs): """Apply a function over each Dataset in the groups generated for resampling and concatenate them together into a new Dataset. @@ -259,6 +261,8 @@ def apply(self, func, **kwargs): ---------- func : function Callable to apply to each sub-dataset. + args : tuple, optional + Positional arguments passed on to `func`. **kwargs Used to call `func(ds, **kwargs)` for each sub-dataset `ar`. @@ -268,7 +272,7 @@ def apply(self, func, **kwargs): The result of splitting, applying and combining this dataset. """ kwargs.pop('shortcut', None) # ignore shortcut if set (for now) - applied = (func(ds, **kwargs) for ds in self._iter_grouped()) + applied = (func(ds, *args, **kwargs) for ds in self._iter_grouped()) combined = self._combine(applied) return combined.rename({self._resample_dim: self._dim}) diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 0672861da2c..fe05da16ad0 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2295,6 +2295,17 @@ def test_resample(self): with raises_regex(ValueError, 'index must be monotonic'): array[[2, 0, 1]].resample(time='1D') + def test_da_resample_func_args(self): + + def func(arg1, arg2, arg3=0.): + return arg1.mean('time') + arg2 + arg3 + + times = pd.date_range('2000', periods=3, freq='D') + da = xr.DataArray([1., 1., 1.], coords=[times], dims=['time']) + expected = xr.DataArray([3., 3., 3.], coords=[times], dims=['time']) + actual = da.resample(time='D').apply(func, args=(1.,), arg3=1.) + assert_identical(actual, expected) + @requires_cftime def test_resample_cftimeindex(self): cftime = _import_cftime() diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index d4253ae445e..521f2395758 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -2886,6 +2886,19 @@ def test_resample_old_api(self): with raises_regex(TypeError, r'resample\(\) no longer supports'): ds.resample('1D', dim='time') + def test_ds_resample_apply_func_args(self): + + def func(arg1, arg2, arg3=0.): + return arg1.mean('time') + arg2 + arg3 + + times = pd.date_range('2000', freq='D', periods=3) + ds = xr.Dataset({'foo': ('time', [1., 1., 1.]), + 'time': times}) + expected = xr.Dataset({'foo': ('time', [3., 3., 3.]), + 'time': times}) + actual = ds.resample(time='D').apply(func, args=(1.,), arg3=1.) + assert_identical(expected, actual) + def test_to_array(self): ds = Dataset(OrderedDict([('a', 1), ('b', ('x', [1, 2, 3]))]), coords={'c': 42}, attrs={'Conventions': 'None'}) diff --git a/xarray/tests/test_groupby.py b/xarray/tests/test_groupby.py index 8ace55be66b..205bc931693 100644 --- a/xarray/tests/test_groupby.py +++ b/xarray/tests/test_groupby.py @@ -85,4 +85,26 @@ def test_groupby_input_mutation(): assert_identical(array, array_copy) # should not modify inputs +def test_da_groupby_apply_func_args(): + + def func(arg1, arg2, arg3=0): + return arg1 + arg2 + arg3 + + array = xr.DataArray([1, 1, 1], [('x', [1, 2, 3])]) + expected = xr.DataArray([3, 3, 3], [('x', [1, 2, 3])]) + actual = array.groupby('x').apply(func, args=(1,), arg3=1) + assert_identical(expected, actual) + + +def test_ds_groupby_apply_func_args(): + + def func(arg1, arg2, arg3=0): + return arg1 + arg2 + arg3 + + dataset = xr.Dataset({'foo': ('x', [1, 1, 1])}, {'x': [1, 2, 3]}) + expected = xr.Dataset({'foo': ('x', [3, 3, 3])}, {'x': [1, 2, 3]}) + actual = dataset.groupby('x').apply(func, args=(1,), arg3=1) + assert_identical(expected, actual) + + # TODO: move other groupby tests from test_dataset and test_dataarray over here From 2667deb74a30dc3bd88752a3ce5da590cf7ddd48 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Mon, 24 Dec 2018 20:21:49 -0500 Subject: [PATCH 033/108] Flake fixed (#2629) * add ignores * test_combine * isort * fixes * odd interation between pytest fixture loop and flake * fix --- setup.cfg | 5 +- versioneer.py | 1 + xarray/backends/api.py | 34 +++++----- xarray/backends/cfgrib_.py | 2 +- xarray/backends/file_manager.py | 1 - xarray/backends/netCDF4_.py | 4 +- xarray/backends/netcdf3.py | 2 +- xarray/backends/pseudonetcdf_.py | 1 - xarray/backends/pynio_.py | 3 +- xarray/backends/rasterio_.py | 1 - xarray/backends/scipy_.py | 2 +- xarray/backends/zarr.py | 5 +- xarray/coding/cftime_offsets.py | 6 +- xarray/coding/cftimeindex.py | 17 ++--- xarray/core/combine.py | 8 +-- xarray/core/common.py | 28 ++++---- xarray/core/dataarray.py | 2 +- xarray/core/dataset.py | 78 ++++++++++++---------- xarray/core/groupby.py | 4 +- xarray/core/options.py | 5 +- xarray/core/utils.py | 2 +- xarray/core/variable.py | 2 +- xarray/plot/plot.py | 2 - xarray/testing.py | 1 - xarray/tests/test_backends.py | 26 ++++---- xarray/tests/test_backends_api.py | 1 + xarray/tests/test_backends_file_manager.py | 10 +-- xarray/tests/test_cftimeindex.py | 6 +- xarray/tests/test_coding_times.py | 4 +- xarray/tests/test_combine.py | 42 ++++++------ xarray/tests/test_dataarray.py | 2 +- xarray/tests/test_distributed.py | 36 +++++----- xarray/tests/test_options.py | 4 +- xarray/tests/test_plot.py | 4 +- xarray/tests/test_utils.py | 1 - xarray/tests/test_variable.py | 4 +- 36 files changed, 179 insertions(+), 177 deletions(-) diff --git a/setup.cfg b/setup.cfg index 17f24b3f1ce..a0d4b46c14e 100644 --- a/setup.cfg +++ b/setup.cfg @@ -8,7 +8,10 @@ testpaths=xarray/tests [flake8] max-line-length=79 ignore= - W503 + E402 # module level import not at top of file + E731 # do not assign a lambda expression, use a def + W503 # line break before binary operator + W504 # line break after binary operator exclude= doc/ diff --git a/versioneer.py b/versioneer.py index dffd66b69a6..577743023ca 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,3 +1,4 @@ +# flake8: noqa # Version: 0.18 diff --git a/xarray/backends/api.py b/xarray/backends/api.py index b4297801309..0ba2e94028c 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -1,33 +1,32 @@ from __future__ import absolute_import, division, print_function import os.path +import warnings from glob import glob from io import BytesIO from numbers import Number -import warnings import numpy as np from .. import Dataset, backends, conventions from ..core import indexing -from ..core.combine import _infer_concat_order_from_positions, _auto_combine +from ..core.combine import _auto_combine, _infer_concat_order_from_positions from ..core.pycompat import basestring, path_type -from ..core.utils import close_on_error, is_remote_uri, is_grib_path +from ..core.utils import close_on_error, is_grib_path, is_remote_uri from .common import ArrayWriter from .locks import _get_scheduler - DATAARRAY_NAME = '__xarray_dataarray_name__' DATAARRAY_VARIABLE = '__xarray_dataarray_variable__' def _get_default_engine_remote_uri(): try: - import netCDF4 + import netCDF4 # noqa engine = 'netcdf4' except ImportError: # pragma: no cover try: - import pydap # flake8: noqa + import pydap # noqa engine = 'pydap' except ImportError: raise ValueError('netCDF4 or pydap is required for accessing ' @@ -38,12 +37,12 @@ def _get_default_engine_remote_uri(): def _get_default_engine_grib(): msgs = [] try: - import Nio # flake8: noqa + import Nio # noqa msgs += ["set engine='pynio' to access GRIB files with PyNIO"] except ImportError: # pragma: no cover pass try: - import cfgrib # flake8: noqa + import cfgrib # noqa msgs += ["set engine='cfgrib' to access GRIB files with cfgrib"] except ImportError: # pragma: no cover pass @@ -56,7 +55,7 @@ def _get_default_engine_grib(): def _get_default_engine_gz(): try: - import scipy # flake8: noqa + import scipy # noqa engine = 'scipy' except ImportError: # pragma: no cover raise ValueError('scipy is required for accessing .gz files') @@ -65,11 +64,11 @@ def _get_default_engine_gz(): def _get_default_engine_netcdf(): try: - import netCDF4 # flake8: noqa + import netCDF4 # noqa engine = 'netcdf4' except ImportError: # pragma: no cover try: - import scipy.io.netcdf # flake8: noqa + import scipy.io.netcdf # noqa engine = 'scipy' except ImportError: raise ValueError('cannot read or write netCDF files without ' @@ -579,7 +578,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, .. [1] http://xarray.pydata.org/en/stable/dask.html .. [2] http://xarray.pydata.org/en/stable/dask.html#chunking-and-performance - """ + """ # noqa if isinstance(paths, basestring): if is_remote_uri(paths): raise ValueError( @@ -642,11 +641,12 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, # Discard ordering because it should be redone from coordinates ids = False - combined = _auto_combine(datasets, concat_dims=concat_dims, - compat=compat, - data_vars=data_vars, coords=coords, - infer_order_from_coords=infer_order_from_coords, - ids=ids) + combined = _auto_combine( + datasets, concat_dims=concat_dims, + compat=compat, + data_vars=data_vars, coords=coords, + infer_order_from_coords=infer_order_from_coords, + ids=ids) except ValueError: for ds in datasets: ds.close() diff --git a/xarray/backends/cfgrib_.py b/xarray/backends/cfgrib_.py index 0807900054a..96095b7b858 100644 --- a/xarray/backends/cfgrib_.py +++ b/xarray/backends/cfgrib_.py @@ -6,7 +6,7 @@ from ..core import indexing from ..core.utils import Frozen, FrozenOrderedDict from .common import AbstractDataStore, BackendArray -from .locks import ensure_lock, SerializableLock +from .locks import SerializableLock, ensure_lock # FIXME: Add a dedicated lock, even if ecCodes is supposed to be thread-safe # in most circumstances. See: diff --git a/xarray/backends/file_manager.py b/xarray/backends/file_manager.py index 6362842dd42..d329f9e734f 100644 --- a/xarray/backends/file_manager.py +++ b/xarray/backends/file_manager.py @@ -7,7 +7,6 @@ from .locks import acquire from .lru_cache import LRUCache - # Global cache for storing open files. FILE_CACHE = LRUCache( OPTIONS['file_cache_maxsize'], on_evict=lambda k, v: v.close()) diff --git a/xarray/backends/netCDF4_.py b/xarray/backends/netCDF4_.py index 2dc692e8724..9306b24a2fc 100644 --- a/xarray/backends/netCDF4_.py +++ b/xarray/backends/netCDF4_.py @@ -14,9 +14,9 @@ from ..core.utils import FrozenOrderedDict, close_on_error, is_remote_uri from .common import ( BackendArray, WritableCFDataStore, find_root, robust_getitem) -from .locks import (NETCDFC_LOCK, HDF5_LOCK, - combine_locks, ensure_lock, get_write_lock) from .file_manager import CachingFileManager, DummyFileManager +from .locks import ( + HDF5_LOCK, NETCDFC_LOCK, combine_locks, ensure_lock, get_write_lock) from .netcdf3 import encode_nc3_attr_value, encode_nc3_variable # This lookup table maps from dtype.byteorder to a readable endian diff --git a/xarray/backends/netcdf3.py b/xarray/backends/netcdf3.py index c7bfa0ea20b..a6084649442 100644 --- a/xarray/backends/netcdf3.py +++ b/xarray/backends/netcdf3.py @@ -9,7 +9,7 @@ # Special characters that are permitted in netCDF names except in the # 0th position of the string -_specialchars = '_.@+- !"#$%&\()*,:;<=>?[]^`{|}~' +_specialchars = '_.@+- !"#$%&\\()*,:;<=>?[]^`{|}~' # The following are reserved names in CDL and may not be used as names of # variables, dimension, attributes diff --git a/xarray/backends/pseudonetcdf_.py b/xarray/backends/pseudonetcdf_.py index 41bc256835a..81b5722db78 100644 --- a/xarray/backends/pseudonetcdf_.py +++ b/xarray/backends/pseudonetcdf_.py @@ -10,7 +10,6 @@ from .file_manager import CachingFileManager from .locks import HDF5_LOCK, NETCDFC_LOCK, combine_locks, ensure_lock - # psuedonetcdf can invoke netCDF libraries internally PNETCDF_LOCK = combine_locks([HDF5_LOCK, NETCDFC_LOCK]) diff --git a/xarray/backends/pynio_.py b/xarray/backends/pynio_.py index b171192ed6a..03507ab6c2c 100644 --- a/xarray/backends/pynio_.py +++ b/xarray/backends/pynio_.py @@ -8,8 +8,7 @@ from .common import AbstractDataStore, BackendArray from .file_manager import CachingFileManager from .locks import ( - HDF5_LOCK, NETCDFC_LOCK, combine_locks, ensure_lock, SerializableLock) - + HDF5_LOCK, NETCDFC_LOCK, SerializableLock, combine_locks, ensure_lock) # PyNIO can invoke netCDF libraries internally # Add a dedicated lock just in case NCL as well isn't thread-safe. diff --git a/xarray/backends/rasterio_.py b/xarray/backends/rasterio_.py index 24874d63f93..26d408d50f6 100644 --- a/xarray/backends/rasterio_.py +++ b/xarray/backends/rasterio_.py @@ -11,7 +11,6 @@ from .file_manager import CachingFileManager from .locks import SerializableLock - # TODO: should this be GDAL_LOCK instead? RASTERIO_LOCK = SerializableLock() diff --git a/xarray/backends/scipy_.py b/xarray/backends/scipy_.py index 157ae44f547..5739c1a8617 100644 --- a/xarray/backends/scipy_.py +++ b/xarray/backends/scipy_.py @@ -11,8 +11,8 @@ from ..core.pycompat import OrderedDict, basestring, iteritems from ..core.utils import Frozen, FrozenOrderedDict from .common import BackendArray, WritableCFDataStore -from .locks import ensure_lock, get_write_lock from .file_manager import CachingFileManager, DummyFileManager +from .locks import ensure_lock, get_write_lock from .netcdf3 import ( encode_nc3_attr_value, encode_nc3_variable, is_valid_nc3_name) diff --git a/xarray/backends/zarr.py b/xarray/backends/zarr.py index 05e445a1e88..feefaf1735f 100644 --- a/xarray/backends/zarr.py +++ b/xarray/backends/zarr.py @@ -8,7 +8,7 @@ from ..core import indexing from ..core.pycompat import OrderedDict, integer_types, iteritems from ..core.utils import FrozenOrderedDict, HiddenKeyDict -from .common import AbstractWritableDataStore, ArrayWriter, BackendArray +from .common import AbstractWritableDataStore, BackendArray # need some special secret attributes to tell us the dimensions _DIMENSION_KEY = '_ARRAY_DIMENSIONS' @@ -237,7 +237,8 @@ def open_group(cls, store, mode='r', synchronizer=None, group=None, "#installation" % min_zarr) if consolidated or consolidate_on_close: - if LooseVersion(zarr.__version__) <= '2.2.1.dev2': # pragma: no cover + if LooseVersion( + zarr.__version__) <= '2.2.1.dev2': # pragma: no cover raise NotImplementedError("Zarr version 2.2.1.dev2 or greater " "is required by for consolidated " "metadata.") diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index 9cdd74537d8..144b0fba9e1 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -419,7 +419,7 @@ def __apply__(self, other): _FREQUENCY_CONDITION = '|'.join(_FREQUENCIES.keys()) -_PATTERN = '^((?P\d+)|())(?P({0}))$'.format( +_PATTERN = r'^((?P\d+)|())(?P({0}))$'.format( _FREQUENCY_CONDITION) @@ -726,10 +726,10 @@ def cftime_range(start=None, end=None, periods=None, freq='D', raise ValueError("Closed must be either 'left', 'right' or None") if (not left_closed and len(dates) and - start is not None and dates[0] == start): + start is not None and dates[0] == start): dates = dates[1:] if (not right_closed and len(dates) and - end is not None and dates[-1] == end): + end is not None and dates[-1] == end): dates = dates[:-1] return CFTimeIndex(dates, name=name) diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 98954e9af0c..82281b0d849 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -51,7 +51,7 @@ from xarray.core import pycompat from xarray.core.utils import is_scalar -from .times import cftime_to_nptime, infer_calendar_name, _STANDARD_CALENDARS +from .times import _STANDARD_CALENDARS, cftime_to_nptime, infer_calendar_name def named(name, pattern): @@ -68,13 +68,13 @@ def trailing_optional(xs): return xs[0] + optional(trailing_optional(xs[1:])) -def build_pattern(date_sep='\-', datetime_sep='T', time_sep='\:'): - pieces = [(None, 'year', '\d{4}'), - (date_sep, 'month', '\d{2}'), - (date_sep, 'day', '\d{2}'), - (datetime_sep, 'hour', '\d{2}'), - (time_sep, 'minute', '\d{2}'), - (time_sep, 'second', '\d{2}')] +def build_pattern(date_sep=r'\-', datetime_sep=r'T', time_sep=r'\:'): + pieces = [(None, 'year', r'\d{4}'), + (date_sep, 'month', r'\d{2}'), + (date_sep, 'day', r'\d{2}'), + (datetime_sep, 'hour', r'\d{2}'), + (time_sep, 'minute', r'\d{2}'), + (time_sep, 'second', r'\d{2}')] pattern_list = [] for sep, name, sub_pattern in pieces: pattern_list.append((sep if sep else '') + named(name, sub_pattern)) @@ -152,6 +152,7 @@ def get_date_field(datetimes, field): def _field_accessor(name, docstring=None): """Adapted from pandas.tseries.index._field_accessor""" + def f(self): return get_date_field(self._data, name) diff --git a/xarray/core/combine.py b/xarray/core/combine.py index e34bb05b3c1..2023c9ea30d 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -1,7 +1,7 @@ from __future__ import absolute_import, division, print_function -import warnings import itertools +import warnings from collections import Counter import pandas as pd @@ -378,7 +378,7 @@ def _infer_concat_order_from_positions(datasets, concat_dims): tile_id, ds = list(combined_ids.items())[0] n_dims = len(tile_id) if concat_dims == _CONCAT_DIM_DEFAULT or concat_dims is None: - concat_dims = [concat_dims]*n_dims + concat_dims = [concat_dims] * n_dims else: if len(concat_dims) != n_dims: raise ValueError("concat_dims has length {} but the datasets " @@ -533,8 +533,8 @@ def _auto_combine(datasets, concat_dims, compat, data_vars, coords, if not ids: # Determine tile_IDs by structure of input in N-D # (i.e. ordering in list-of-lists) - combined_ids, concat_dims = _infer_concat_order_from_positions\ - (datasets, concat_dims) + combined_ids, concat_dims = _infer_concat_order_from_positions( + datasets, concat_dims) else: # Already sorted so just use the ids already passed combined_ids = OrderedDict(zip(ids, datasets)) diff --git a/xarray/core/common.py b/xarray/core/common.py index c0a0201c7ce..5b090bf0d2f 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -1,7 +1,5 @@ from __future__ import absolute_import, division, print_function -import warnings -from distutils.version import LooseVersion from textwrap import dedent import numpy as np @@ -9,9 +7,9 @@ from . import dtypes, duck_array_ops, formatting, ops from .arithmetic import SupportsArithmetic +from .options import _get_keep_attrs from .pycompat import OrderedDict, basestring, dask_array_type, suppress from .utils import Frozen, ReprObject, SortedKeysDict, either_dict_or_kwargs -from .options import _get_keep_attrs # Used as a sentinel value to indicate a all dimensions ALL_DIMS = ReprObject('') @@ -96,7 +94,7 @@ def __complex__(self): return complex(self.values) def __long__(self): - return long(self.values) # flake8: noqa + return long(self.values) # noqa def __array__(self, dtype=None): return np.asarray(self.values, dtype=dtype) @@ -208,7 +206,7 @@ def _ipython_key_completions_(self): """Provide method for the key-autocompletions in IPython. See http://ipython.readthedocs.io/en/stable/config/integrating.html#tab-completion For the details. - """ + """ # noqa item_lists = [item for sublist in self._item_sources for item in sublist @@ -426,7 +424,8 @@ def pipe(self, func, *args, **kwargs): if isinstance(func, tuple): func, target = func if target in kwargs: - msg = '%s is both the pipe target and a keyword argument' % target + msg = ('%s is both the pipe target and a keyword argument' + % target) raise ValueError(msg) kwargs[target] = self return func(*args, **kwargs) @@ -476,7 +475,7 @@ def groupby(self, group, squeeze=True): -------- core.groupby.DataArrayGroupBy core.groupby.DatasetGroupBy - """ + """ # noqa return self._groupby_cls(self, group, squeeze=squeeze) def groupby_bins(self, group, bins, right=True, labels=None, precision=3, @@ -525,7 +524,7 @@ def groupby_bins(self, group, bins, right=True, labels=None, precision=3, References ---------- .. [1] http://pandas.pydata.org/pandas-docs/stable/generated/pandas.cut.html - """ + """ # noqa return self._groupby_cls(self, group, squeeze=squeeze, bins=bins, cut_kwargs={'right': right, 'labels': labels, 'precision': precision, @@ -586,7 +585,7 @@ def rolling(self, dim=None, min_periods=None, center=False, **dim_kwargs): -------- core.rolling.DataArrayRolling core.rolling.DatasetRolling - """ + """ # noqa dim = either_dict_or_kwargs(dim, dim_kwargs, 'rolling') return self._rolling_cls(self, dim, min_periods=min_periods, center=center) @@ -659,7 +658,7 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, ---------- .. [1] http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases - """ + """ # noqa # TODO support non-string indexer after removing the old API. from .dataarray import DataArray @@ -673,10 +672,11 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, if ((skipna is not None and not isinstance(skipna, bool)) or ('how' in indexer_kwargs and 'how' not in self.dims) or ('dim' in indexer_kwargs and 'dim' not in self.dims)): - raise TypeError('resample() no longer supports the `how` or ' - '`dim` arguments. Instead call methods on resample ' - "objects, e.g., data.resample(time='1D').mean()") - + raise TypeError( + 'resample() no longer supports the `how` or ' + '`dim` arguments. Instead call methods on resample ' + "objects, e.g., data.resample(time='1D').mean()") + indexer = either_dict_or_kwargs(indexer, indexer_kwargs, 'resample') if len(indexer) != 1: diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index e04648bd0b3..e8531a62f4f 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -16,7 +16,7 @@ assert_coordinate_consistent, remap_label_indexers) from .dataset import Dataset, merge_indexes, split_indexes from .formatting import format_item -from .options import OPTIONS, _get_keep_attrs +from .options import OPTIONS from .pycompat import OrderedDict, basestring, iteritems, range, zip from .utils import ( _check_inplace, decode_numpy_dict_values, either_dict_or_kwargs, diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 686ffb37adc..7ac3b458232 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -13,9 +13,8 @@ import xarray as xr from . import ( - alignment, computation, duck_array_ops, formatting, groupby, indexing, ops, - pdcompat, resample, rolling, utils) -from .. import conventions + alignment, duck_array_ops, formatting, groupby, indexing, ops, pdcompat, + resample, rolling, utils) from ..coding.cftimeindex import _parse_array_of_cftime_strings from .alignment import align from .common import ( @@ -24,15 +23,14 @@ from .coordinates import ( DatasetCoordinates, Indexes, LevelCoordinatesSource, assert_coordinate_consistent, remap_label_indexers) -from .dtypes import is_datetime_like from .merge import ( dataset_merge_method, dataset_update_method, merge_data_and_coords, merge_variables) from .options import OPTIONS, _get_keep_attrs from .pycompat import ( - OrderedDict, basestring, dask_array_type, integer_types, iteritems, range) + OrderedDict, basestring, dask_array_type, iteritems, range) from .utils import ( - _check_inplace, Frozen, SortedKeysDict, datetime_to_numeric, + Frozen, SortedKeysDict, _check_inplace, datetime_to_numeric, decode_numpy_dict_values, either_dict_or_kwargs, ensure_us_time_resolution, hashable, maybe_wrap_array) from .variable import IndexVariable, Variable, as_variable, broadcast_variables @@ -516,7 +514,6 @@ def __dask_graph__(self): from dask import sharedict return sharedict.merge(*graphs.values()) - def __dask_keys__(self): import dask return [v.__dask_keys__() for v in self.variables.values() @@ -814,7 +811,7 @@ def copy(self, deep=False, data=None): See Also -------- pandas.DataFrame.copy - """ + """ # noqa if data is None: variables = OrderedDict((k, v.copy(deep=deep)) for k, v in iteritems(self._variables)) @@ -825,14 +822,16 @@ def copy(self, deep=False, data=None): data_keys = set(data.keys()) keys_not_in_vars = data_keys - var_keys if keys_not_in_vars: - raise ValueError('Data must only contain variables in original ' - 'dataset. Extra variables: {}' - .format(keys_not_in_vars)) + raise ValueError( + 'Data must only contain variables in original ' + 'dataset. Extra variables: {}' + .format(keys_not_in_vars)) keys_missing_from_data = var_keys - data_keys if keys_missing_from_data: - raise ValueError('Data must contain all variables in original ' - 'dataset. Data is missing {}' - .format(keys_missing_from_data)) + raise ValueError( + 'Data must contain all variables in original ' + 'dataset. Data is missing {}' + .format(keys_missing_from_data)) variables = OrderedDict((k, v.copy(deep=deep, data=data.get(k))) for k, v in iteritems(self._variables)) @@ -1175,7 +1174,8 @@ def to_netcdf(self, path=None, mode='w', format=None, group=None, Write ('w') or append ('a') mode. If mode='w', any existing file at this location will be overwritten. If mode='a', existing variables will be overwritten. - format : {'NETCDF4', 'NETCDF4_CLASSIC', 'NETCDF3_64BIT','NETCDF3_CLASSIC'}, optional + format : {'NETCDF4', 'NETCDF4_CLASSIC', 'NETCDF3_64BIT', + 'NETCDF3_CLASSIC'}, optional File format for the resulting netCDF file: * NETCDF4: Data is stored in an HDF5 file, using netCDF4 API @@ -1362,7 +1362,8 @@ def chunk(self, chunks=None, name_prefix='xarray-', token=None, try: from dask.base import tokenize except ImportError: - import dask # raise the usual error if dask is entirely missing # flake8: noqa + # raise the usual error if dask is entirely missing + import dask # noqa raise ImportError('xarray requires dask version 0.9 or newer') if isinstance(chunks, Number): @@ -1647,7 +1648,7 @@ def isel_points(self, dim='points', **indexers): Dataset.isel Dataset.sel_points DataArray.isel_points - """ + """ # noqa warnings.warn('Dataset.isel_points is deprecated: use Dataset.isel()' 'instead.', DeprecationWarning, stacklevel=2) @@ -1798,7 +1799,7 @@ def sel_points(self, dim='points', method=None, tolerance=None, Dataset.isel Dataset.isel_points DataArray.sel_points - """ + """ # noqa warnings.warn('Dataset.sel_points is deprecated: use Dataset.sel()' 'instead.', DeprecationWarning, stacklevel=2) @@ -1863,9 +1864,9 @@ def reindex(self, indexers=None, method=None, tolerance=None, copy=True, ---------- indexers : dict. optional Dictionary with keys given by dimension names and values given by - arrays of coordinates tick labels. Any mis-matched coordinate values - will be filled in with NaN, and any mis-matched dimension names will - simply be ignored. + arrays of coordinates tick labels. Any mis-matched coordinate + values will be filled in with NaN, and any mis-matched dimension + names will simply be ignored. One of indexers or indexers_kwargs must be provided. method : {None, 'nearest', 'pad'/'ffill', 'backfill'/'bfill'}, optional Method to use for filling index values in ``indexers`` not found in @@ -1973,12 +1974,12 @@ def _validate_interp_indexer(x, new_x): # used with interp are stronger than those which are placed on # isel, so we need an additional check after _validate_indexers. if (_contains_datetime_like_objects(x) and - not _contains_datetime_like_objects(new_x)): - raise TypeError('When interpolating over a datetime-like ' - 'coordinate, the coordinates to ' - 'interpolate to must be either datetime ' - 'strings or datetimes. ' - 'Instead got\n{}'.format(new_x)) + not _contains_datetime_like_objects(new_x)): + raise TypeError('When interpolating over a datetime-like ' + 'coordinate, the coordinates to ' + 'interpolate to must be either datetime ' + 'strings or datetimes. ' + 'Instead got\n{}'.format(new_x)) else: return (x, new_x) @@ -1988,7 +1989,7 @@ def _validate_interp_indexer(x, new_x): if var.dtype.kind in 'uifc': var_indexers = {k: _validate_interp_indexer( maybe_variable(obj, k), v) for k, v - in indexers.items() if k in var.dims} + in indexers.items() if k in var.dims} variables[name] = missing.interp( var, var_indexers, method, **kwargs) elif all(d not in indexers for d in var.dims): @@ -2911,7 +2912,7 @@ def reduce(self, func, dim=None, keep_attrs=None, numeric_only=False, else: dims = set(dim) - missing_dimensions = [dim for dim in dims if dim not in self.dims] + missing_dimensions = [d for d in dims if d not in self.dims] if missing_dimensions: raise ValueError('Dataset does not contain the dimensions: %s' % missing_dimensions) @@ -2921,7 +2922,7 @@ def reduce(self, func, dim=None, keep_attrs=None, numeric_only=False, variables = OrderedDict() for name, var in iteritems(self._variables): - reduce_dims = [dim for dim in var.dims if dim in dims] + reduce_dims = [d for d in var.dims if d in dims] if name in self.coords: if not reduce_dims: variables[name] = var @@ -2988,7 +2989,7 @@ def apply(self, func, keep_attrs=None, args=(), **kwargs): Data variables: foo (dim_0, dim_1) float64 0.3751 1.951 1.945 0.2948 0.711 0.3948 bar (x) float64 1.0 2.0 - """ + """ # noqa variables = OrderedDict( (k, maybe_wrap_array(v, func(v, *args, **kwargs))) for k, v in iteritems(self.data_vars)) @@ -3030,7 +3031,8 @@ def assign(self, variables=None, **variables_kwargs): -------- pandas.DataFrame.assign """ - variables = either_dict_or_kwargs(variables, variables_kwargs, 'assign') + variables = either_dict_or_kwargs( + variables, variables_kwargs, 'assign') data = self.copy() # do all calculations first... results = data._calc_assign_results(variables) @@ -3709,14 +3711,14 @@ def quantile(self, q, dim=None, interpolation='linear', else: dims = set(dim) - _assert_empty([dim for dim in dims if dim not in self.dims], + _assert_empty([d for d in dims if d not in self.dims], 'Dataset does not contain the dimensions: %s') q = np.asarray(q, dtype=np.float64) variables = OrderedDict() for name, var in iteritems(self.variables): - reduce_dims = [dim for dim in var.dims if dim in dims] + reduce_dims = [d for d in var.dims if d in dims] if reduce_dims or not var.dims: if name not in self.coords: if (not numeric_only or @@ -3749,7 +3751,8 @@ def rank(self, dim, pct=False, keep_attrs=None): """Ranks the data. Equal values are assigned a rank that is the average of the ranks that - would have been otherwise assigned to all of the values within that set. + would have been otherwise assigned to all of the values within + that set. Ranks begin at 1, not 0. If pct is True, computes percentage ranks. NaNs in the input array are returned as NaNs. @@ -3832,7 +3835,8 @@ def differentiate(self, coord, edge_order=1, datetime_unit=None): datetime_unit, _ = np.datetime_data(coord_var.dtype) elif datetime_unit is None: datetime_unit = 's' # Default to seconds for cftime objects - coord_var = datetime_to_numeric(coord_var, datetime_unit=datetime_unit) + coord_var = datetime_to_numeric( + coord_var, datetime_unit=datetime_unit) variables = OrderedDict() for k, v in self.variables.items(): @@ -3935,7 +3939,7 @@ def filter_by_attrs(self, **kwargs): temperature (x, y, time) float64 25.86 20.82 6.954 23.13 10.25 11.68 ... precipitation (x, y, time) float64 5.702 0.9422 2.075 1.178 3.284 ... - """ + """ # noqa selection = [] for var_name, variable in self.data_vars.items(): has_value_flag = False diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index 9e8c1e6bbc3..ec8329d6805 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -1,9 +1,9 @@ from __future__ import absolute_import, division, print_function +import datetime import functools import warnings -import datetime import numpy as np import pandas as pd @@ -11,10 +11,10 @@ from .arithmetic import SupportsArithmetic from .combine import concat from .common import ALL_DIMS, ImplementsArrayReduce, ImplementsDatasetReduce +from .options import _get_keep_attrs from .pycompat import integer_types, range, zip from .utils import hashable, maybe_wrap_array, peek_at, safe_cast_to_index from .variable import IndexVariable, Variable, as_variable -from .options import _get_keep_attrs def unique_value_groups(ar, sort=True): diff --git a/xarray/core/options.py b/xarray/core/options.py index 400508a5d59..db8e696eedf 100644 --- a/xarray/core/options.py +++ b/xarray/core/options.py @@ -66,8 +66,9 @@ def _get_keep_attrs(default): elif global_choice in [True, False]: return global_choice else: - raise ValueError("The global option keep_attrs must be one of True, " - "False or 'default'.") + raise ValueError( + "The global option keep_attrs must be one of" + " True, False or 'default'.") class set_options(object): diff --git a/xarray/core/utils.py b/xarray/core/utils.py index 50d6ec7e05a..fbda658c23f 100644 --- a/xarray/core/utils.py +++ b/xarray/core/utils.py @@ -508,7 +508,7 @@ def close_on_error(f): def is_remote_uri(path): - return bool(re.search('^https?\://', path)) + return bool(re.search(r'^https?\://', path)) def is_grib_path(path): diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 469e8741a29..cabab259446 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -15,10 +15,10 @@ from .indexing import ( BasicIndexer, OuterIndexer, PandasIndexAdapter, VectorizedIndexer, as_indexable) +from .options import _get_keep_attrs from .pycompat import ( OrderedDict, basestring, dask_array_type, integer_types, zip) from .utils import OrderedSet, either_dict_or_kwargs -from .options import _get_keep_attrs try: import dask.array as da diff --git a/xarray/plot/plot.py b/xarray/plot/plot.py index 8d21e084946..1f7b8d8587a 100644 --- a/xarray/plot/plot.py +++ b/xarray/plot/plot.py @@ -14,7 +14,6 @@ import numpy as np import pandas as pd -from xarray.core.alignment import align from xarray.core.common import contains_cftime_datetimes from xarray.core.pycompat import basestring @@ -255,7 +254,6 @@ def _infer_line_data(darray, x, y, hue): huelabel = label_from_attrs(darray[huename]) hueplt = darray[huename] - xlabel = label_from_attrs(xplt) ylabel = label_from_attrs(yplt) diff --git a/xarray/testing.py b/xarray/testing.py index 03c5354cdff..c2bb5044ef4 100644 --- a/xarray/testing.py +++ b/xarray/testing.py @@ -145,4 +145,3 @@ def assert_combined_tile_ids_equal(dict1, dict2): for k, v in dict1.items(): assert k in dict2.keys() assert_equal(dict1[k], dict2[k]) - diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index f4d9154eadb..993db79a66e 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -23,17 +23,18 @@ from xarray.backends.netCDF4_ import _extract_nc4_variable_encoding from xarray.backends.pydap_ import PydapDataStore from xarray.core import indexing +from xarray.core.options import set_options from xarray.core.pycompat import ( ExitStack, basestring, dask_array_type, iteritems) -from xarray.core.options import set_options from xarray.tests import mock from . import ( assert_allclose, assert_array_equal, assert_equal, assert_identical, - has_dask, has_netCDF4, has_scipy, network, raises_regex, requires_cftime, - requires_dask, requires_h5netcdf, requires_netCDF4, requires_pathlib, - requires_pseudonetcdf, requires_pydap, requires_pynio, requires_rasterio, - requires_scipy, requires_scipy_or_netCDF4, requires_zarr, requires_cfgrib) + has_dask, has_netCDF4, has_scipy, network, raises_regex, requires_cfgrib, + requires_cftime, requires_dask, requires_h5netcdf, requires_netCDF4, + requires_pathlib, requires_pseudonetcdf, requires_pydap, requires_pynio, + requires_rasterio, requires_scipy, requires_scipy_or_netCDF4, + requires_zarr) from .test_dataset import create_test_data try: @@ -662,7 +663,8 @@ def test_roundtrip_string_with_fill_value_nchar(self): create_encoded_unsigned_masked_scaled_data), pytest.param(create_bad_unsigned_masked_scaled_data, create_bad_encoded_unsigned_masked_scaled_data, - marks=pytest.mark.xfail(reason="Bad _Unsigned attribute.")), + marks=pytest.mark.xfail( + reason="Bad _Unsigned attribute.")), (create_signed_masked_scaled_data, create_encoded_signed_masked_scaled_data), (create_masked_and_scaled_data, @@ -1348,7 +1350,7 @@ def roundtrip_append(self, data, save_kwargs={}, open_kwargs={}, pytest.skip("zarr backend does not support appending") def test_roundtrip_consolidated(self): - zarr = pytest.importorskip('zarr', minversion="2.2.1.dev2") + pytest.importorskip('zarr', minversion="2.2.1.dev2") expected = create_test_data() with self.roundtrip(expected, save_kwargs={'consolidated': True}, @@ -2168,7 +2170,6 @@ def test_open_mfdataset(self): with open_mfdataset([tmp1, tmp2], chunks={'x': 3}) as actual: assert actual.foo.variable.data.chunks == ((3, 2, 3, 2),) - with raises_regex(IOError, 'no files to open'): open_mfdataset('foo-bar-baz-*.nc') @@ -2195,14 +2196,14 @@ def test_open_mfdataset_2d(self): assert isinstance(actual.foo.variable.data, da.Array) assert actual.foo.variable.data.chunks == \ - ((5, 5), (4, 4)) + ((5, 5), (4, 4)) assert_identical(original, actual) with open_mfdataset([[tmp1, tmp2], [tmp3, tmp4]], concat_dim=['y', 'x'], chunks={'x': 3, 'y': 2}) as actual: assert actual.foo.variable.data.chunks == \ - ((3, 2, 3, 2), (2, 2, 2, 2),) + ((3, 2, 3, 2), (2, 2, 2, 2),) @requires_pathlib def test_open_mfdataset_pathlib(self): @@ -2241,7 +2242,7 @@ def test_open_mfdataset_2d_pathlib(self): assert_identical(original, actual) @pytest.mark.xfail(reason="Not yet implemented") - def test_open_mfdataset(self): + def test_open_mfdataset_2(self): original = Dataset({'foo': ('x', np.random.randn(10))}) with create_tmp_file() as tmp1: with create_tmp_file() as tmp2: @@ -2963,7 +2964,8 @@ def test_indexing(self): assert_allclose(expected.isel(**ind), actual.isel(**ind)) assert not actual.variable._in_memory - ind = {'band': 0, 'x': np.array([0, 0]), 'y': np.array([1, 1, 1])} + ind = {'band': 0, 'x': np.array( + [0, 0]), 'y': np.array([1, 1, 1])} assert_allclose(expected.isel(**ind), actual.isel(**ind)) assert not actual.variable._in_memory diff --git a/xarray/tests/test_backends_api.py b/xarray/tests/test_backends_api.py index ed49dd721d2..2b025db8cab 100644 --- a/xarray/tests/test_backends_api.py +++ b/xarray/tests/test_backends_api.py @@ -2,6 +2,7 @@ import pytest from xarray.backends.api import _get_default_engine + from . import requires_netCDF4, requires_scipy diff --git a/xarray/tests/test_backends_file_manager.py b/xarray/tests/test_backends_file_manager.py index 3b618f35ea7..9c4c1cf815c 100644 --- a/xarray/tests/test_backends_file_manager.py +++ b/xarray/tests/test_backends_file_manager.py @@ -1,11 +1,6 @@ -import collections import gc import pickle import threading -try: - from unittest import mock -except ImportError: - import mock # noqa: F401 import pytest @@ -13,6 +8,11 @@ from xarray.backends.lru_cache import LRUCache from xarray.core.options import set_options +try: + from unittest import mock +except ImportError: + import mock # noqa: F401 + @pytest.fixture(params=[1, 2, 3, None]) def file_cache(request): diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index ea41115937b..4c91bbd6195 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -12,9 +12,9 @@ _parsed_string_to_bounds, assert_all_valid_date_type, parse_iso8601) from xarray.tests import assert_array_equal, assert_identical -from . import has_cftime, has_cftime_or_netCDF4, requires_cftime, raises_regex -from .test_coding_times import (_all_cftime_date_types, _ALL_CALENDARS, - _NON_STANDARD_CALENDARS) +from . import has_cftime, has_cftime_or_netCDF4, raises_regex, requires_cftime +from .test_coding_times import ( + _ALL_CALENDARS, _NON_STANDARD_CALENDARS, _all_cftime_date_types) def date_dict(year=None, month=None, day=None, diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index b7db2b43cab..d9a40c23add 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -8,8 +8,8 @@ import pytest from xarray import DataArray, Variable, coding, decode_cf -from xarray.coding.times import (_import_cftime, cftime_to_nptime, - decode_cf_datetime, encode_cf_datetime) +from xarray.coding.times import ( + _import_cftime, cftime_to_nptime, decode_cf_datetime, encode_cf_datetime) from xarray.conventions import _update_bounds_attributes from xarray.core.common import contains_cftime_datetimes diff --git a/xarray/tests/test_combine.py b/xarray/tests/test_combine.py index ec2288b1d2d..9ea38e7d5f2 100644 --- a/xarray/tests/test_combine.py +++ b/xarray/tests/test_combine.py @@ -7,16 +7,16 @@ import pandas as pd import pytest -from xarray import DataArray, Dataset, Variable, auto_combine, concat, merge -from xarray.core.pycompat import OrderedDict, iteritems +from xarray import DataArray, Dataset, Variable, auto_combine, concat from xarray.core.combine import ( - _new_tile_id, _auto_combine_all_along_first_dim, - _infer_concat_order_from_positions, _infer_tile_ids_from_nested_list, - _check_shape_tile_ids, _combine_nd, _auto_combine_1d, _auto_combine) + _auto_combine, _auto_combine_1d, _auto_combine_all_along_first_dim, + _check_shape_tile_ids, _combine_nd, _infer_concat_order_from_positions, + _infer_tile_ids_from_nested_list, _new_tile_id) +from xarray.core.pycompat import OrderedDict, iteritems from . import ( - InaccessibleArray, assert_array_equal, assert_equal, assert_identical, - assert_combined_tile_ids_equal, raises_regex, requires_dask) + InaccessibleArray, assert_array_equal, assert_combined_tile_ids_equal, + assert_equal, assert_identical, raises_regex, requires_dask) from .test_dataset import create_test_data @@ -492,8 +492,8 @@ def test_infer_from_datasets(self): input = [ds(0), ds(1)] expected = {(0,): ds(0), (1,): ds(1)} - actual, concat_dims = _infer_concat_order_from_positions\ - (input, ['dim1']) + actual, concat_dims = _infer_concat_order_from_positions(input, [ + 'dim1']) assert_combined_tile_ids_equal(expected, actual) input = [ds(0), ds(1)] @@ -520,11 +520,11 @@ def _create_tile_ids(shape): @requires_dask # only for toolz class TestCombineND(object): - @pytest.mark.parametrize("old_id, new_id", [((3,0,1), (0,1)), - ((0, 0), (0,)), - ((1,), ()), - ((0,), ()), - ((1, 0), (0,))]) + @pytest.mark.parametrize("old_id, new_id", [((3, 0, 1), (0, 1)), + ((0, 0), (0,)), + ((1,), ()), + ((0,), ()), + ((1, 0), (0,))]) def test_new_tile_id(self, old_id, new_id): ds = create_test_data assert _new_tile_id((old_id, ds)) == new_id @@ -594,7 +594,7 @@ def test_check_depths(self): def test_check_lengths(self): ds = create_test_data(0) - combined_tile_ids = {(0, 0): ds, (0, 1): ds , (0, 2): ds, + combined_tile_ids = {(0, 0): ds, (0, 1): ds, (0, 2): ds, (1, 0): ds, (1, 1): ds} with raises_regex(ValueError, 'sub-lists do not have ' 'consistent lengths'): @@ -643,8 +643,10 @@ def test_invalid_hypercube_input(self): auto_combine(datasets, concat_dim=['dim1']) def test_merge_one_dim_concat_another(self): - objs = [[Dataset({'foo': ('x', [0, 1])}), Dataset({'bar': ('x', [10, 20])})], - [Dataset({'foo': ('x', [2, 3])}), Dataset({'bar': ('x', [30, 40])})]] + objs = [[Dataset({'foo': ('x', [0, 1])}), + Dataset({'bar': ('x', [10, 20])})], + [Dataset({'foo': ('x', [2, 3])}), + Dataset({'bar': ('x', [30, 40])})]] expected = Dataset({'foo': ('x', [0, 1, 2, 3]), 'bar': ('x', [10, 20, 30, 40])}) @@ -655,8 +657,10 @@ def test_merge_one_dim_concat_another(self): assert_identical(expected, actual) # Proving it works symmetrically - objs = [[Dataset({'foo': ('x', [0, 1])}), Dataset({'foo': ('x', [2, 3])})], - [Dataset({'bar': ('x', [10, 20])}), Dataset({'bar': ('x', [30, 40])})]] + objs = [[Dataset({'foo': ('x', [0, 1])}), + Dataset({'foo': ('x', [2, 3])})], + [Dataset({'bar': ('x', [10, 20])}), + Dataset({'bar': ('x', [30, 40])})]] actual = auto_combine(objs, concat_dim=[None, 'x']) assert_identical(expected, actual) diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index fe05da16ad0..5468905a320 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -11,7 +11,7 @@ import xarray as xr from xarray import ( - DataArray, Dataset, IndexVariable, Variable, align, broadcast, set_options) + DataArray, Dataset, IndexVariable, Variable, align, broadcast) from xarray.coding.times import CFDatetimeCoder, _import_cftime from xarray.convert import from_cdms2 from xarray.core.common import ALL_DIMS, full_like diff --git a/xarray/tests/test_distributed.py b/xarray/tests/test_distributed.py index bd62b8d906d..3a79d40c226 100644 --- a/xarray/tests/test_distributed.py +++ b/xarray/tests/test_distributed.py @@ -1,22 +1,17 @@ """ isort:skip_file """ from __future__ import absolute_import, division, print_function -from distutils.version import LooseVersion -import os -import sys import pickle -import tempfile import pytest dask = pytest.importorskip('dask', minversion='0.18') # isort:skip -distributed = pytest.importorskip('distributed', minversion='1.21') # isort:skip +distributed = pytest.importorskip( + 'distributed', minversion='1.21') # isort:skip -from dask import array from dask.distributed import Client, Lock from distributed.utils_test import cluster, gen_cluster -from distributed.utils_test import loop # flake8: noqa +from distributed.utils_test import loop # noqa from distributed.client import futures_of -import numpy as np import xarray as xr from xarray.backends.locks import HDF5_LOCK, CombinedLock @@ -27,7 +22,7 @@ from . import ( assert_allclose, has_h5netcdf, has_netCDF4, requires_rasterio, has_scipy, - requires_zarr, requires_cfgrib, raises_regex) + requires_zarr, requires_cfgrib) # this is to stop isort throwing errors. May have been easier to just use # `isort:skip` in retrospect @@ -63,7 +58,7 @@ def tmp_netcdf_filename(tmpdir): ] -@pytest.mark.parametrize('engine,nc_format', ENGINES_AND_FORMATS) +@pytest.mark.parametrize('engine,nc_format', ENGINES_AND_FORMATS) # noqa def test_dask_distributed_netcdf_roundtrip( loop, tmp_netcdf_filename, engine, nc_format): @@ -73,7 +68,7 @@ def test_dask_distributed_netcdf_roundtrip( chunks = {'dim1': 4, 'dim2': 3, 'dim3': 6} with cluster() as (s, [a, b]): - with Client(s['address'], loop=loop) as c: + with Client(s['address'], loop=loop): original = create_test_data().chunk(chunks) @@ -93,7 +88,7 @@ def test_dask_distributed_netcdf_roundtrip( assert_allclose(original, computed) -@pytest.mark.parametrize('engine,nc_format', ENGINES_AND_FORMATS) +@pytest.mark.parametrize('engine,nc_format', ENGINES_AND_FORMATS) # noqa def test_dask_distributed_read_netcdf_integration_test( loop, tmp_netcdf_filename, engine, nc_format): @@ -103,7 +98,7 @@ def test_dask_distributed_read_netcdf_integration_test( chunks = {'dim1': 4, 'dim2': 3, 'dim3': 6} with cluster() as (s, [a, b]): - with Client(s['address'], loop=loop) as c: + with Client(s['address'], loop=loop): original = create_test_data() original.to_netcdf(tmp_netcdf_filename, @@ -117,20 +112,19 @@ def test_dask_distributed_read_netcdf_integration_test( assert_allclose(original, computed) - -@requires_zarr +@requires_zarr # noqar @pytest.mark.parametrize('consolidated', [True, False]) @pytest.mark.parametrize('compute', [True, False]) def test_dask_distributed_zarr_integration_test(loop, consolidated, compute): if consolidated: - zarr = pytest.importorskip('zarr', minversion="2.2.1.dev2") + pytest.importorskip('zarr', minversion="2.2.1.dev2") write_kwargs = dict(consolidated=True) read_kwargs = dict(consolidated=True) else: write_kwargs = read_kwargs = {} chunks = {'dim1': 4, 'dim2': 3, 'dim3': 5} with cluster() as (s, [a, b]): - with Client(s['address'], loop=loop) as c: + with Client(s['address'], loop=loop): original = create_test_data().chunk(chunks) with create_tmp_file(allow_cleanup_failure=ON_WINDOWS, suffix='.zarrc') as filename: @@ -144,21 +138,21 @@ def test_dask_distributed_zarr_integration_test(loop, consolidated, compute): assert_allclose(original, computed) -@requires_rasterio +@requires_rasterio # noqa def test_dask_distributed_rasterio_integration_test(loop): with create_tmp_geotiff() as (tmp_file, expected): with cluster() as (s, [a, b]): - with Client(s['address'], loop=loop) as c: + with Client(s['address'], loop=loop): da_tiff = xr.open_rasterio(tmp_file, chunks={'band': 1}) assert isinstance(da_tiff.data, da.Array) actual = da_tiff.compute() assert_allclose(actual, expected) -@requires_cfgrib +@requires_cfgrib # noqa def test_dask_distributed_cfgrib_integration_test(loop): with cluster() as (s, [a, b]): - with Client(s['address'], loop=loop) as c: + with Client(s['address'], loop=loop): with open_example_dataset('example.grib', engine='cfgrib', chunks={'time': 1}) as ds: diff --git a/xarray/tests/test_options.py b/xarray/tests/test_options.py index d594e1dcd18..3374ded39f0 100644 --- a/xarray/tests/test_options.py +++ b/xarray/tests/test_options.py @@ -3,10 +3,10 @@ import pytest import xarray -from xarray.core.options import OPTIONS, _get_keep_attrs +from xarray import concat, merge from xarray.backends.file_manager import FILE_CACHE +from xarray.core.options import OPTIONS, _get_keep_attrs from xarray.tests.test_dataset import create_test_data -from xarray import concat, merge def test_invalid_option_raises(): diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py index 10c4283032d..a2c3adf191f 100644 --- a/xarray/tests/test_plot.py +++ b/xarray/tests/test_plot.py @@ -1161,8 +1161,8 @@ def test_facetgrid_no_cbar_ax(self): a = easy_array((10, 15, 2, 3)) d = DataArray(a, dims=['y', 'x', 'columns', 'rows']) with pytest.raises(ValueError): - g = self.plotfunc(d, x='x', y='y', col='columns', row='rows', - cbar_ax=1) + self.plotfunc(d, x='x', y='y', col='columns', row='rows', + cbar_ax=1) def test_cmap_and_color_both(self): with pytest.raises(ValueError): diff --git a/xarray/tests/test_utils.py b/xarray/tests/test_utils.py index ed07af0d7bb..fc14ae2350a 100644 --- a/xarray/tests/test_utils.py +++ b/xarray/tests/test_utils.py @@ -9,7 +9,6 @@ import xarray as xr from xarray.coding.cftimeindex import CFTimeIndex from xarray.core import duck_array_ops, utils -from xarray.core.options import set_options from xarray.core.pycompat import OrderedDict from xarray.core.utils import either_dict_or_kwargs from xarray.testing import assert_identical diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index d98783fe2dd..91bc0e555c0 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -12,7 +12,7 @@ import pytest import pytz -from xarray import Coordinate, Dataset, IndexVariable, Variable +from xarray import Coordinate, Dataset, IndexVariable, Variable, set_options from xarray.core import indexing from xarray.core.common import full_like, ones_like, zeros_like from xarray.core.indexing import ( @@ -28,8 +28,6 @@ assert_allclose, assert_array_equal, assert_equal, assert_identical, raises_regex, requires_dask, source_ndarray) -from xarray import set_options - class VariableSubclassobjects(object): def test_properties(self): From 85ded913d030dda8eb1f3ed18db76b32a9f9ca2d Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Thu, 27 Dec 2018 17:58:29 -0500 Subject: [PATCH 034/108] fill_value in shift (#2470) * enable fill_value in shift * whatsnew * docstrings * should we make some dataarray methods avoid rtp-ing to dataset? * revert joining doc start * code comments * WIP * pad use dict rather than kwargs * handle 'missing' values in a more consistent way in shift * whatsnew move --- doc/whats-new.rst | 3 +++ xarray/core/dataarray.py | 12 ++++++++---- xarray/core/dataset.py | 15 +++++++++------ xarray/core/rolling.py | 2 +- xarray/core/variable.py | 20 +++++++++++++------- xarray/tests/test_dataarray.py | 18 +++++++++++++----- xarray/tests/test_dataset.py | 13 +++++++++---- xarray/tests/test_variable.py | 32 ++++++++++++++++++++------------ 8 files changed, 76 insertions(+), 39 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 19e52f3a3ed..de358d6d6b7 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -73,6 +73,9 @@ Enhancements - 0d slices of ndarrays are now obtained directly through indexing, rather than extracting and wrapping a scalar, avoiding unnecessary copying. By `Daniel Wennberg `_. +- Added support for ``fill_value`` with + :py:meth:`~xarray.DataArray.shift` and :py:meth:`~xarray.Dataset.shift` + By `Maximilian Roos `_ Bug fixes ~~~~~~~~~ diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index e8531a62f4f..25a66e529ae 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -6,7 +6,8 @@ import numpy as np import pandas as pd -from . import computation, groupby, indexing, ops, resample, rolling, utils +from . import ( + computation, dtypes, groupby, indexing, ops, resample, rolling, utils) from ..plot.plot import _PlotMethods from .accessors import DatetimeAccessor from .alignment import align, reindex_like_indexers @@ -2085,7 +2086,7 @@ def diff(self, dim, n=1, label='upper'): ds = self._to_temp_dataset().diff(n=n, dim=dim, label=label) return self._from_temp_dataset(ds) - def shift(self, shifts=None, **shifts_kwargs): + def shift(self, shifts=None, fill_value=dtypes.NA, **shifts_kwargs): """Shift this array by an offset along one or more dimensions. Only the data is moved; coordinates stay in place. Values shifted from @@ -2098,6 +2099,8 @@ def shift(self, shifts=None, **shifts_kwargs): Integer offset to shift along each of the given dimensions. Positive offsets shift to the right; negative offsets shift to the left. + fill_value: scalar, optional + Value to use for newly missing values **shifts_kwargs: The keyword arguments form of ``shifts``. One of shifts or shifts_kwarg must be provided. @@ -2122,8 +2125,9 @@ def shift(self, shifts=None, **shifts_kwargs): Coordinates: * x (x) int64 0 1 2 """ - ds = self._to_temp_dataset().shift(shifts=shifts, **shifts_kwargs) - return self._from_temp_dataset(ds) + variable = self.variable.shift( + shifts=shifts, fill_value=fill_value, **shifts_kwargs) + return self._replace(variable=variable) def roll(self, shifts=None, roll_coords=None, **shifts_kwargs): """Roll this array by an offset along one or more dimensions. diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 7ac3b458232..62c6e98c954 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -13,8 +13,8 @@ import xarray as xr from . import ( - alignment, duck_array_ops, formatting, groupby, indexing, ops, pdcompat, - resample, rolling, utils) + alignment, dtypes, duck_array_ops, formatting, groupby, indexing, ops, + pdcompat, resample, rolling, utils) from ..coding.cftimeindex import _parse_array_of_cftime_strings from .alignment import align from .common import ( @@ -3476,7 +3476,7 @@ def diff(self, dim, n=1, label='upper'): else: return difference - def shift(self, shifts=None, **shifts_kwargs): + def shift(self, shifts=None, fill_value=dtypes.NA, **shifts_kwargs): """Shift this dataset by an offset along one or more dimensions. Only data variables are moved; coordinates stay in place. This is @@ -3488,6 +3488,8 @@ def shift(self, shifts=None, **shifts_kwargs): Integer offset to shift along each of the given dimensions. Positive offsets shift to the right; negative offsets shift to the left. + fill_value: scalar, optional + Value to use for newly missing values **shifts_kwargs: The keyword arguments form of ``shifts``. One of shifts or shifts_kwarg must be provided. @@ -3522,9 +3524,10 @@ def shift(self, shifts=None, **shifts_kwargs): variables = OrderedDict() for name, var in iteritems(self.variables): if name in self.data_vars: - var_shifts = dict((k, v) for k, v in shifts.items() - if k in var.dims) - variables[name] = var.shift(**var_shifts) + var_shifts = {k: v for k, v in shifts.items() + if k in var.dims} + variables[name] = var.shift( + fill_value=fill_value, shifts=var_shifts) else: variables[name] = var diff --git a/xarray/core/rolling.py b/xarray/core/rolling.py index 883dbb34dff..09b632e47a6 100644 --- a/xarray/core/rolling.py +++ b/xarray/core/rolling.py @@ -301,7 +301,7 @@ def wrapped_func(self, **kwargs): else: shift = (-self.window // 2) + 1 valid = (slice(None), ) * axis + (slice(-shift, None), ) - padded = padded.pad_with_fill_value(**{self.dim: (0, -shift)}) + padded = padded.pad_with_fill_value({self.dim: (0, -shift)}) if isinstance(padded.data, dask_array_type): values = dask_rolling_wrapper(func, padded, diff --git a/xarray/core/variable.py b/xarray/core/variable.py index cabab259446..243487db034 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -933,7 +933,7 @@ def squeeze(self, dim=None): dims = common.get_squeeze_dims(self, dim) return self.isel({d: 0 for d in dims}) - def _shift_one_dim(self, dim, count): + def _shift_one_dim(self, dim, count, fill_value=dtypes.NA): axis = self.get_axis_num(dim) if count > 0: @@ -944,7 +944,11 @@ def _shift_one_dim(self, dim, count): keep = slice(None) trimmed_data = self[(slice(None),) * axis + (keep,)].data - dtype, fill_value = dtypes.maybe_promote(self.dtype) + + if fill_value is dtypes.NA: + dtype, fill_value = dtypes.maybe_promote(self.dtype) + else: + dtype = self.dtype shape = list(self.shape) shape[axis] = min(abs(count), shape[axis]) @@ -956,12 +960,12 @@ def _shift_one_dim(self, dim, count): else: full = np.full - nans = full(shape, fill_value, dtype=dtype) + filler = full(shape, fill_value, dtype=dtype) if count > 0: - arrays = [nans, trimmed_data] + arrays = [filler, trimmed_data] else: - arrays = [trimmed_data, nans] + arrays = [trimmed_data, filler] data = duck_array_ops.concatenate(arrays, axis) @@ -973,7 +977,7 @@ def _shift_one_dim(self, dim, count): return type(self)(self.dims, data, self._attrs, fastpath=True) - def shift(self, shifts=None, **shifts_kwargs): + def shift(self, shifts=None, fill_value=dtypes.NA, **shifts_kwargs): """ Return a new Variable with shifted data. @@ -983,6 +987,8 @@ def shift(self, shifts=None, **shifts_kwargs): Integer offset to shift along each of the given dimensions. Positive offsets shift to the right; negative offsets shift to the left. + fill_value: scalar, optional + Value to use for newly missing values **shifts_kwargs: The keyword arguments form of ``shifts``. One of shifts or shifts_kwarg must be provided. @@ -995,7 +1001,7 @@ def shift(self, shifts=None, **shifts_kwargs): shifts = either_dict_or_kwargs(shifts, shifts_kwargs, 'shift') result = self for dim, count in shifts.items(): - result = result._shift_one_dim(dim, count) + result = result._shift_one_dim(dim, count, fill_value=fill_value) return result def pad_with_fill_value(self, pad_widths=None, fill_value=dtypes.NA, diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 5468905a320..53f53574031 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -14,6 +14,7 @@ DataArray, Dataset, IndexVariable, Variable, align, broadcast) from xarray.coding.times import CFDatetimeCoder, _import_cftime from xarray.convert import from_cdms2 +from xarray.core import dtypes from xarray.core.common import ALL_DIMS, full_like from xarray.core.pycompat import OrderedDict, iteritems from xarray.tests import ( @@ -3128,12 +3129,19 @@ def test_coordinate_diff(self): actual = lon.diff('lon') assert_equal(expected, actual) - @pytest.mark.parametrize('offset', [-5, -2, -1, 0, 1, 2, 5]) - def test_shift(self, offset): + @pytest.mark.parametrize('offset', [-5, 0, 1, 2]) + @pytest.mark.parametrize('fill_value, dtype', + [(2, int), (dtypes.NA, float)]) + def test_shift(self, offset, fill_value, dtype): arr = DataArray([1, 2, 3], dims='x') - actual = arr.shift(x=1) - expected = DataArray([np.nan, 1, 2], dims='x') - assert_identical(expected, actual) + actual = arr.shift(x=1, fill_value=fill_value) + if fill_value == dtypes.NA: + # if we supply the default, we expect the missing value for a + # float array + fill_value = np.nan + expected = DataArray([fill_value, 1, 2], dims='x') + assert_identical(expected, actual) + assert actual.dtype == dtype arr = DataArray([1, 2, 3], [('x', ['a', 'b', 'c'])]) expected = DataArray(arr.to_pandas().shift(offset)) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 521f2395758..6f6287efcac 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -15,7 +15,7 @@ from xarray import ( ALL_DIMS, DataArray, Dataset, IndexVariable, MergeError, Variable, align, backends, broadcast, open_dataset, set_options) -from xarray.core import indexing, npcompat, utils +from xarray.core import dtypes, indexing, npcompat, utils from xarray.core.common import full_like from xarray.core.pycompat import ( OrderedDict, integer_types, iteritems, unicode_type) @@ -3917,12 +3917,17 @@ def test_dataset_diff_exception_label_str(self): with raises_regex(ValueError, '\'label\' argument has to'): ds.diff('dim2', label='raise_me') - def test_shift(self): + @pytest.mark.parametrize('fill_value', [dtypes.NA, 2, 2.0]) + def test_shift(self, fill_value): coords = {'bar': ('x', list('abc')), 'x': [-4, 3, 2]} attrs = {'meta': 'data'} ds = Dataset({'foo': ('x', [1, 2, 3])}, coords, attrs) - actual = ds.shift(x=1) - expected = Dataset({'foo': ('x', [np.nan, 1, 2])}, coords, attrs) + actual = ds.shift(x=1, fill_value=fill_value) + if fill_value == dtypes.NA: + # if we supply the default, we expect the missing value for a + # float array + fill_value = np.nan + expected = Dataset({'foo': ('x', [fill_value, 1, 2])}, coords, attrs) assert_identical(expected, actual) with raises_regex(ValueError, 'dimensions'): diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 91bc0e555c0..08cab4b3541 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -13,7 +13,7 @@ import pytz from xarray import Coordinate, Dataset, IndexVariable, Variable, set_options -from xarray.core import indexing +from xarray.core import dtypes, indexing from xarray.core.common import full_like, ones_like, zeros_like from xarray.core.indexing import ( BasicIndexer, CopyOnWriteArray, DaskIndexingAdapter, @@ -1179,24 +1179,32 @@ def test_indexing_0d_unicode(self): expected = Variable((), u'tmax') assert_identical(actual, expected) - def test_shift(self): + @pytest.mark.parametrize('fill_value', [dtypes.NA, 2, 2.0]) + def test_shift(self, fill_value): v = Variable('x', [1, 2, 3, 4, 5]) assert_identical(v, v.shift(x=0)) assert v is not v.shift(x=0) - expected = Variable('x', [np.nan, 1, 2, 3, 4]) - assert_identical(expected, v.shift(x=1)) - expected = Variable('x', [np.nan, np.nan, 1, 2, 3]) assert_identical(expected, v.shift(x=2)) - expected = Variable('x', [2, 3, 4, 5, np.nan]) - assert_identical(expected, v.shift(x=-1)) + if fill_value == dtypes.NA: + # if we supply the default, we expect the missing value for a + # float array + fill_value_exp = np.nan + else: + fill_value_exp = fill_value + + expected = Variable('x', [fill_value_exp, 1, 2, 3, 4]) + assert_identical(expected, v.shift(x=1, fill_value=fill_value)) + + expected = Variable('x', [2, 3, 4, 5, fill_value_exp]) + assert_identical(expected, v.shift(x=-1, fill_value=fill_value)) - expected = Variable('x', [np.nan] * 5) - assert_identical(expected, v.shift(x=5)) - assert_identical(expected, v.shift(x=6)) + expected = Variable('x', [fill_value_exp] * 5) + assert_identical(expected, v.shift(x=5, fill_value=fill_value)) + assert_identical(expected, v.shift(x=6, fill_value=fill_value)) with raises_regex(ValueError, 'dimension'): v.shift(z=0) @@ -1204,8 +1212,8 @@ def test_shift(self): v = Variable('x', [1, 2, 3, 4, 5], {'foo': 'bar'}) assert_identical(v, v.shift(x=0)) - expected = Variable('x', [np.nan, 1, 2, 3, 4], {'foo': 'bar'}) - assert_identical(expected, v.shift(x=1)) + expected = Variable('x', [fill_value_exp, 1, 2, 3, 4], {'foo': 'bar'}) + assert_identical(expected, v.shift(x=1, fill_value=fill_value)) def test_shift2d(self): v = Variable(('x', 'y'), [[1, 2], [3, 4]]) From bc5558e99a6323226fec5fb641281e86167b2e74 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Fri, 28 Dec 2018 02:10:41 -0500 Subject: [PATCH 035/108] silence import warning (#2635) --- xarray/core/indexing.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/xarray/core/indexing.py b/xarray/core/indexing.py index 93da2437e28..dab23540178 100644 --- a/xarray/core/indexing.py +++ b/xarray/core/indexing.py @@ -2,7 +2,7 @@ import functools import operator -from collections import Hashable, defaultdict +from collections import defaultdict from datetime import timedelta import numpy as np @@ -13,6 +13,11 @@ dask_array_type, integer_types, iteritems, range, suppress) from .utils import is_dict_like +try: + from collections.abc import Hashable +except ImportError: # Py2 + from collections import Hashable + def expanded_indexer(key, ndim): """Given a key for indexing an ndarray, return an equivalent key which is a From a8e5002ab616e43f2e1b19a5963475a8275b0220 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Fri, 28 Dec 2018 14:04:49 -0500 Subject: [PATCH 036/108] Fix dayofweek and dayofyear attributes from dates generated by cftime_range (#2633) * Add workaround for cftime issue 106 * Raise ImportError for too old a version of cftime * lint * Simplify version check logic * Fix test skipping logic --- doc/whats-new.rst | 3 ++- xarray/coding/cftime_offsets.py | 6 +++++- xarray/coding/cftimeindex.py | 28 +++++++++++++++++++++++----- xarray/tests/__init__.py | 2 ++ xarray/tests/test_accessors.py | 6 ++++++ xarray/tests/test_cftime_offsets.py | 17 +++++++++++++++++ xarray/tests/test_cftimeindex.py | 9 ++++++--- 7 files changed, 61 insertions(+), 10 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index de358d6d6b7..a19eaa8b0bc 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -55,7 +55,8 @@ Enhancements reprojection, see (:issue:`2588`). By `Scott Henderson `_. - Like :py:class:`pandas.DatetimeIndex`, :py:class:`CFTimeIndex` now supports - "dayofyear" and "dayofweek" accessors (:issue:`2597`). By `Spencer Clark + "dayofyear" and "dayofweek" accessors (:issue:`2597`). Note this requires a + version of cftime greater than 1.0.2. By `Spencer Clark `_. - The option ``'warn_for_unclosed_files'`` (False by default) has been added to allow users to enable a warning when files opened by xarray are deallocated diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index 144b0fba9e1..f8e1cfa6718 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -204,7 +204,11 @@ def _shift_months(date, months, day_option='start'): day = _days_in_month(reference) else: raise ValueError(day_option) - return date.replace(year=year, month=month, day=day) + # dayofwk=-1 is required to update the dayofwk and dayofyr attributes of + # the returned date object in versions of cftime between 1.0.2 and + # 1.0.3.4. It can be removed for versions of cftime greater than + # 1.0.3.4. + return date.replace(year=year, month=month, day=day, dayofwk=-1) class MonthBegin(BaseCFTimeOffset): diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 82281b0d849..af22a3219ad 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -44,6 +44,7 @@ import re import warnings from datetime import timedelta +from distutils.version import LooseVersion import numpy as np import pandas as pd @@ -108,6 +109,11 @@ def _parse_iso8601_with_reso(date_type, timestr): replace[attr] = int(value) resolution = attr + # dayofwk=-1 is required to update the dayofwk and dayofyr attributes of + # the returned date object in versions of cftime between 1.0.2 and + # 1.0.3.4. It can be removed for versions of cftime greater than + # 1.0.3.4. + replace['dayofwk'] = -1 return default.replace(**replace), resolution @@ -150,11 +156,21 @@ def get_date_field(datetimes, field): return np.array([getattr(date, field) for date in datetimes]) -def _field_accessor(name, docstring=None): +def _field_accessor(name, docstring=None, min_cftime_version='0.0'): """Adapted from pandas.tseries.index._field_accessor""" - def f(self): - return get_date_field(self._data, name) + def f(self, min_cftime_version=min_cftime_version): + import cftime + + version = cftime.__version__ + + if LooseVersion(version) >= LooseVersion(min_cftime_version): + return get_date_field(self._data, name) + else: + raise ImportError('The {!r} accessor requires a minimum ' + 'version of cftime of {}. Found an ' + 'installed version of {}.'.format( + name, min_cftime_version, version)) f.__name__ = name f.__doc__ = docstring @@ -209,8 +225,10 @@ class CFTimeIndex(pd.Index): microsecond = _field_accessor('microsecond', 'The microseconds of the datetime') dayofyear = _field_accessor('dayofyr', - 'The ordinal day of year of the datetime') - dayofweek = _field_accessor('dayofwk', 'The day of week of the datetime') + 'The ordinal day of year of the datetime', + '1.0.2.1') + dayofweek = _field_accessor('dayofwk', 'The day of week of the datetime', + '1.0.2.1') date_type = property(get_date_type) def __new__(cls, data, name=None): diff --git a/xarray/tests/__init__.py b/xarray/tests/__init__.py index c57f6720810..52345396ffa 100644 --- a/xarray/tests/__init__.py +++ b/xarray/tests/__init__.py @@ -71,6 +71,8 @@ def LooseVersion(vstring): has_pynio, requires_pynio = _importorskip('Nio') has_pseudonetcdf, requires_pseudonetcdf = _importorskip('PseudoNetCDF') has_cftime, requires_cftime = _importorskip('cftime') +has_cftime_1_0_2_1, requires_cftime_1_0_2_1 = _importorskip( + 'cftime', minversion='1.0.2.1') has_dask, requires_dask = _importorskip('dask') has_bottleneck, requires_bottleneck = _importorskip('bottleneck') has_rasterio, requires_rasterio = _importorskip('rasterio') diff --git a/xarray/tests/test_accessors.py b/xarray/tests/test_accessors.py index 37b9c272e6e..5d088e8cd48 100644 --- a/xarray/tests/test_accessors.py +++ b/xarray/tests/test_accessors.py @@ -161,6 +161,8 @@ def times_3d(times): @pytest.mark.parametrize('field', ['year', 'month', 'day', 'hour', 'dayofyear', 'dayofweek']) def test_field_access(data, field): + if field == 'dayofyear' or field == 'dayofweek': + pytest.importorskip('cftime', minversion='1.0.2.1') result = getattr(data.time.dt, field) expected = xr.DataArray( getattr(xr.coding.cftimeindex.CFTimeIndex(data.time.values), field), @@ -176,6 +178,8 @@ def test_field_access(data, field): def test_dask_field_access_1d(data, field): import dask.array as da + if field == 'dayofyear' or field == 'dayofweek': + pytest.importorskip('cftime', minversion='1.0.2.1') expected = xr.DataArray( getattr(xr.coding.cftimeindex.CFTimeIndex(data.time.values), field), name=field, dims=['time']) @@ -193,6 +197,8 @@ def test_dask_field_access_1d(data, field): def test_dask_field_access(times_3d, data, field): import dask.array as da + if field == 'dayofyear' or field == 'dayofweek': + pytest.importorskip('cftime', minversion='1.0.2.1') expected = xr.DataArray( getattr(xr.coding.cftimeindex.CFTimeIndex(times_3d.values.ravel()), field).reshape(times_3d.shape), diff --git a/xarray/tests/test_cftime_offsets.py b/xarray/tests/test_cftime_offsets.py index 7acd764cab3..dfb46df21e3 100644 --- a/xarray/tests/test_cftime_offsets.py +++ b/xarray/tests/test_cftime_offsets.py @@ -1,6 +1,7 @@ from itertools import product import numpy as np +import pandas as pd import pytest from xarray import CFTimeIndex @@ -797,3 +798,19 @@ def test_calendar_year_length( result = cftime_range(start, end, freq='D', closed='left', calendar=calendar) assert len(result) == expected_number_of_days + + +@pytest.mark.parametrize('freq', ['A', 'M', 'D']) +def test_dayofweek_after_cftime_range(freq): + pytest.importorskip('cftime', minversion='1.0.2.1') + result = cftime_range('2000-02-01', periods=3, freq=freq).dayofweek + expected = pd.date_range('2000-02-01', periods=3, freq=freq).dayofweek + np.testing.assert_array_equal(result, expected) + + +@pytest.mark.parametrize('freq', ['A', 'M', 'D']) +def test_dayofyear_after_cftime_range(freq): + pytest.importorskip('cftime', minversion='1.0.2.1') + result = cftime_range('2000-02-01', periods=3, freq=freq).dayofyear + expected = pd.date_range('2000-02-01', periods=3, freq=freq).dayofyear + np.testing.assert_array_equal(result, expected) diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 4c91bbd6195..271cacb5ca0 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -12,7 +12,8 @@ _parsed_string_to_bounds, assert_all_valid_date_type, parse_iso8601) from xarray.tests import assert_array_equal, assert_identical -from . import has_cftime, has_cftime_or_netCDF4, raises_regex, requires_cftime +from . import (has_cftime, has_cftime_1_0_2_1, has_cftime_or_netCDF4, + raises_regex, requires_cftime) from .test_coding_times import ( _ALL_CALENDARS, _NON_STANDARD_CALENDARS, _all_cftime_date_types) @@ -175,14 +176,16 @@ def test_cftimeindex_field_accessors(index, field, expected): assert_array_equal(result, expected) -@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +@pytest.mark.skipif(not has_cftime_1_0_2_1, + reason='cftime not installed') def test_cftimeindex_dayofyear_accessor(index): result = index.dayofyear expected = [date.dayofyr for date in index] assert_array_equal(result, expected) -@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +@pytest.mark.skipif(not has_cftime_1_0_2_1, + reason='cftime not installed') def test_cftimeindex_dayofweek_accessor(index): result = index.dayofweek expected = [date.dayofwk for date in index] From 1545b50a3c8841b3f62c7bd59353d55aa2389697 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Sun, 30 Dec 2018 00:10:16 +0000 Subject: [PATCH 037/108] Add flake check to travis (#2632) * add flake check to travis * only flake xarray * flake changes * rename flake -> flake8 in travis config --- .travis.yml | 5 +++++ xarray/core/pdcompat.py | 1 - xarray/tests/test_dataarray.py | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 881d293263b..8c2ee3ab0d5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -32,6 +32,7 @@ matrix: - env: CONDA_ENV=py36-rasterio - env: CONDA_ENV=py36-zarr-dev - env: CONDA_ENV=docs + - env: CONDA_ENV=flake8 - env: CONDA_ENV=py36-hypothesis allow_failures: @@ -62,6 +63,8 @@ before_install: install: - if [[ "$CONDA_ENV" == "docs" ]]; then conda env create -n test_env --file doc/environment.yml; + elif [[ "$CONDA_ENV" == "flake8" ]]; then + conda env create -n test_env --file ci/requirements-py37.yml; else conda env create -n test_env --file ci/requirements-$CONDA_ENV.yml; fi @@ -77,6 +80,8 @@ script: - if [[ "$CONDA_ENV" == "docs" ]]; then conda install -c conda-forge sphinx sphinx_rtd_theme sphinx-gallery numpydoc; sphinx-build -n -j auto -b html -d _build/doctrees doc _build/html; + elif [[ "$CONDA_ENV" == "flake8" ]]; then + flake8 xarray ; elif [[ "$CONDA_ENV" == "py36-hypothesis" ]]; then pytest properties ; else diff --git a/xarray/core/pdcompat.py b/xarray/core/pdcompat.py index c1e153f4d92..f76634c65aa 100644 --- a/xarray/core/pdcompat.py +++ b/xarray/core/pdcompat.py @@ -39,7 +39,6 @@ import numpy as np -import pandas as pd # for pandas 0.19 diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 53f53574031..9b4f8523178 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -1028,7 +1028,7 @@ def test_sel(lab_indexer, pos_indexer, replaced_idx=False, assert_identical(mdata.sel(x={'one': 'a', 'two': 1}), mdata.sel(one='a', two=1)) - def test_selection_multiindex(self): + def test_selection_multiindex_remove_unused(self): # GH2619. For MultiIndex, we need to call remove_unused. ds = xr.DataArray(np.arange(40).reshape(8, 5), dims=['x', 'y'], coords={'x': np.arange(8), 'y': np.arange(5)}) From 250b19c8fff56c295f6047956400863db22cb48b Mon Sep 17 00:00:00 2001 From: Tom Nicholas <35968931+TomNicholas@users.noreply.github.com> Date: Sun, 30 Dec 2018 01:00:35 +0000 Subject: [PATCH 038/108] Source encoding always set when opening datasets (#2626) * Add source encoding if not already present when opening dataset * Test source encoding present * Updated what's new * Revert "Updated what's new" This reverts commit 78587990cfdfdfb74f456289b41be5e0e3036496. * Don't close file-like objects * Updated whats's new * DOC: document source encoding for datasets --- doc/io.rst | 24 +++++++++++++++--------- doc/whats-new.rst | 3 +++ xarray/backends/api.py | 14 ++++++++++++-- xarray/tests/test_backends.py | 11 +++++++++++ 4 files changed, 41 insertions(+), 11 deletions(-) diff --git a/doc/io.rst b/doc/io.rst index 682fbf5202e..151f5eb740f 100644 --- a/doc/io.rst +++ b/doc/io.rst @@ -197,24 +197,30 @@ turn this decoding off manually. .. _CF conventions: http://cfconventions.org/ You can view this encoding information (among others) in the -:py:attr:`DataArray.encoding ` attribute: +:py:attr:`DataArray.encoding ` and +:py:attr:`DataArray.encoding ` attributes: .. ipython:: :verbatim: In [1]: ds_disk['y'].encoding Out[1]: - {'calendar': u'proleptic_gregorian', - 'chunksizes': None, + {'zlib': False, + 'shuffle': False, 'complevel': 0, - 'contiguous': True, - 'dtype': dtype('float64'), 'fletcher32': False, - 'least_significant_digit': None, - 'shuffle': False, + 'contiguous': True, + 'chunksizes': None, 'source': 'saved_on_disk.nc', - 'units': u'days since 2000-01-01 00:00:00', - 'zlib': False} + 'original_shape': (5,), + 'dtype': dtype('int64'), + 'units': 'days since 2000-01-01 00:00:00', + 'calendar': 'proleptic_gregorian'} + + In [9]: ds_disk.encoding + Out[9]: + {'unlimited_dims': set(), + 'source': 'saved_on_disk.nc'} Note that all operations that manipulate variables other than indexing will remove encoding information. diff --git a/doc/whats-new.rst b/doc/whats-new.rst index a19eaa8b0bc..ab61852a785 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -67,6 +67,9 @@ Enhancements - :py:meth:`DataArray.resample` and :py:meth:`Dataset.resample` now supports the ``loffset`` kwarg just like Pandas. By `Deepak Cherian `_ +- Datasets are now guaranteed to have a ``'source'`` encoding, so the source + file name is always stored (:issue:`2550`). + By `Tom Nicholas `_. - The `apply` methods for `DatasetGroupBy`, `DataArrayGroupBy`, `DatasetResample` and `DataArrayResample` can now pass positional arguments to the applied function. diff --git a/xarray/backends/api.py b/xarray/backends/api.py index 0ba2e94028c..244b540d0ca 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -299,6 +299,7 @@ def maybe_decode_store(store, lock=False): if isinstance(filename_or_obj, backends.AbstractDataStore): store = filename_or_obj + ds = maybe_decode_store(store) elif isinstance(filename_or_obj, basestring): if (isinstance(filename_or_obj, bytes) and @@ -339,15 +340,21 @@ def maybe_decode_store(store, lock=False): % engine) with close_on_error(store): - return maybe_decode_store(store) + ds = maybe_decode_store(store) else: if engine is not None and engine != 'scipy': raise ValueError('can only read file-like objects with ' "default engine or engine='scipy'") # assume filename_or_obj is a file-like object store = backends.ScipyDataStore(filename_or_obj) + ds = maybe_decode_store(store) - return maybe_decode_store(store) + # Ensure source filename always stored in dataset object (GH issue #2550) + if 'source' not in ds.encoding: + if isinstance(filename_or_obj, basestring): + ds.encoding['source'] = filename_or_obj + + return ds def open_dataarray(filename_or_obj, group=None, decode_cf=True, @@ -484,6 +491,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, lock=None, data_vars='all', coords='different', autoclose=None, parallel=False, **kwargs): """Open multiple files as a single dataset. + Requires dask to be installed. See documentation for details on dask [1]. Attributes from the first dataset file are used for the combined dataset. @@ -523,6 +531,8 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, of all non-null values. preprocess : callable, optional If provided, call this function on each dataset prior to concatenation. + You can find the file-name from which each dataset was loaded in + ``ds.encoding['source']``. engine : {'netcdf4', 'scipy', 'pydap', 'h5netcdf', 'pynio', 'cfgrib'}, optional Engine to use when reading files. If not provided, the default engine diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 993db79a66e..48c2f64c8db 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -3426,3 +3426,14 @@ def test_no_warning_from_dask_effective_get(): ds = Dataset() ds.to_netcdf(tmpfile) assert len(record) == 0 + + +@requires_scipy_or_netCDF4 +def test_source_encoding_always_present(): + # Test for GH issue #2550. + rnddata = np.random.randn(10) + original = Dataset({'foo': ('x', rnddata)}) + with create_tmp_file() as tmp: + original.to_netcdf(tmp) + with open_dataset(tmp) as ds: + assert ds.encoding['source'] == tmp From d1d2ecec5febabceea9b724c26dd92180322c819 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sat, 29 Dec 2018 18:08:01 -0800 Subject: [PATCH 039/108] DOC: fix docstrings and doc build for 0.11.1 --- doc/examples/weather-data.rst | 2 +- doc/internals.rst | 2 +- doc/whats-new.rst | 29 ++++++++-------- xarray/backends/api.py | 63 ++++++++++++++++++----------------- xarray/core/alignment.py | 1 + xarray/core/combine.py | 6 ++-- xarray/core/merge.py | 25 ++++++-------- 7 files changed, 63 insertions(+), 65 deletions(-) diff --git a/doc/examples/weather-data.rst b/doc/examples/weather-data.rst index 84620360daa..5a019e637c4 100644 --- a/doc/examples/weather-data.rst +++ b/doc/examples/weather-data.rst @@ -17,7 +17,7 @@ Shared setup: .. ipython:: python :suppress: - fpath = "doc/examples/_code/weather_data_setup.py" + fpath = "examples/_code/weather_data_setup.py" with open(fpath) as f: code = compile(f.read(), fpath, 'exec') exec(code) diff --git a/doc/internals.rst b/doc/internals.rst index 5c0e078ebb4..170e2d0b0cc 100644 --- a/doc/internals.rst +++ b/doc/internals.rst @@ -111,7 +111,7 @@ Back in an interactive IPython session, we can use these properties: .. ipython:: python :suppress: - exec(open("doc/examples/_code/accessor_example.py").read()) + exec(open("examples/_code/accessor_example.py").read()) .. ipython:: python diff --git a/doc/whats-new.rst b/doc/whats-new.rst index ab61852a785..25bc09d32a3 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -13,23 +13,24 @@ What's New import xarray as xr np.random.seed(123456) +.. _whats-new.0.11.1: + +v0.11.1 (29 December 2018) +-------------------------- + +This minor release includes a number of enhancements and bug fixes, and two +(slightly) breaking changes. + .. warning:: - Xarray plans to drop support for python 2.7 at the end of 2018. This - means that new releases of xarray published after this date will only be - installable on python 3+ environments, but older versions of xarray will - always be available to python 2.7 users. For more information see the - following references + This is the last xarray release that will support Python 2.7. Future releases + will be Python 3 only, but older versions of xarray will always be available + for Python 2.7 users. For the more details, see: - - `Xarray Github issue discussing dropping Python 2 `__ + - `Xarray Github issue discussing dropping Python 2 `__ - `Python 3 Statement `__ - `Tips on porting to Python 3 `__ -.. _whats-new.0.11.1: - -v0.11.1 (unreleased) --------------------- - Breaking changes ~~~~~~~~~~~~~~~~ @@ -70,9 +71,9 @@ Enhancements - Datasets are now guaranteed to have a ``'source'`` encoding, so the source file name is always stored (:issue:`2550`). By `Tom Nicholas `_. -- The `apply` methods for `DatasetGroupBy`, `DataArrayGroupBy`, - `DatasetResample` and `DataArrayResample` can now pass positional arguments to - the applied function. +- The ``apply`` methods for ``DatasetGroupBy``, ``DataArrayGroupBy``, + ``DatasetResample`` and ``DataArrayResample`` now support passing positional + arguments to the applied function as a tuple to the ``args`` argument. By `Matti Eskelinen `_. - 0d slices of ndarrays are now obtained directly through indexing, rather than extracting and wrapping a scalar, avoiding unnecessary copying. By `Daniel diff --git a/xarray/backends/api.py b/xarray/backends/api.py index 244b540d0ca..3cd62e8264a 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -517,18 +517,17 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, By default, xarray attempts to infer this argument by examining component files. Set ``concat_dim=None`` explicitly to disable concatenation. - compat : {'identical', 'equals', 'broadcast_equals', - 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts when merging: - - 'broadcast_equals': all values must be equal when variables are - broadcast against each other to ensure common dimensions. - - 'equals': all values and dimensions must be the same. - - 'identical': all values, dimensions and attributes must be the - same. - - 'no_conflicts': only values which are not null in both datasets - must be equal. The returned dataset then contains the combination - of all non-null values. + * 'broadcast_equals': all values must be equal when variables are + broadcast against each other to ensure common dimensions. + * 'equals': all values and dimensions must be the same. + * 'identical': all values, dimensions and attributes must be the + same. + * 'no_conflicts': only values which are not null in both datasets + must be equal. The returned dataset then contains the combination + of all non-null values. preprocess : callable, optional If provided, call this function on each dataset prior to concatenation. You can find the file-name from which each dataset was loaded in @@ -545,29 +544,31 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, active dask scheduler. data_vars : {'minimal', 'different', 'all' or list of str}, optional These data variables will be concatenated together: - * 'minimal': Only data variables in which the dimension already - appears are included. - * 'different': Data variables which are not equal (ignoring - attributes) across all datasets are also concatenated (as well as - all for which dimension already appears). Beware: this option may - load the data payload of data variables into memory if they are not - already loaded. - * 'all': All data variables will be concatenated. - * list of str: The listed data variables will be concatenated, in - addition to the 'minimal' data variables. + + * 'minimal': Only data variables in which the dimension already + appears are included. + * 'different': Data variables which are not equal (ignoring + attributes) across all datasets are also concatenated (as well as + all for which dimension already appears). Beware: this option may + load the data payload of data variables into memory if they are not + already loaded. + * 'all': All data variables will be concatenated. + * list of str: The listed data variables will be concatenated, in + addition to the 'minimal' data variables. coords : {'minimal', 'different', 'all' o list of str}, optional These coordinate variables will be concatenated together: - * 'minimal': Only coordinates in which the dimension already appears - are included. - * 'different': Coordinates which are not equal (ignoring attributes) - across all datasets are also concatenated (as well as all for which - dimension already appears). Beware: this option may load the data - payload of coordinate variables into memory if they are not already - loaded. - * 'all': All coordinate variables will be concatenated, except - those corresponding to other dimensions. - * list of str: The listed coordinate variables will be concatenated, - in addition the 'minimal' coordinates. + + * 'minimal': Only coordinates in which the dimension already appears + are included. + * 'different': Coordinates which are not equal (ignoring attributes) + across all datasets are also concatenated (as well as all for which + dimension already appears). Beware: this option may load the data + payload of coordinate variables into memory if they are not already + loaded. + * 'all': All coordinate variables will be concatenated, except + those corresponding to other dimensions. + * list of str: The listed coordinate variables will be concatenated, + in addition the 'minimal' coordinates. parallel : bool, optional If True, the open and preprocess steps of this function will be performed in parallel using ``dask.delayed``. Default is False. diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index f82ddef25ba..33902abaf3e 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -53,6 +53,7 @@ def align(*objects, **kwargs): join : {'outer', 'inner', 'left', 'right', 'exact'}, optional Method for joining the indexes of the passed objects along each dimension: + - 'outer': use the union of object indexes - 'inner': use the intersection of object indexes - 'left': use indexes from the first object with each dimension diff --git a/xarray/core/combine.py b/xarray/core/combine.py index 2023c9ea30d..abb2e2c1306 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -574,10 +574,10 @@ def auto_combine(datasets, concat_dim=_CONCAT_DIM_DEFAULT, By default, xarray attempts to infer this argument by examining component files. Set ``concat_dim=None`` explicitly to disable concatenation. - compat : {'identical', 'equals', 'broadcast_equals', - 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts: + - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'equals': all values and dimensions must be the same. @@ -599,7 +599,7 @@ def auto_combine(datasets, concat_dim=_CONCAT_DIM_DEFAULT, -------- concat Dataset.merge - """ + """ # noqa # Coerce 1D input into ND to maintain backwards-compatible API until API # for N-D combine decided diff --git a/xarray/core/merge.py b/xarray/core/merge.py index 984dd2fa204..2a5e7acbb25 100644 --- a/xarray/core/merge.py +++ b/xarray/core/merge.py @@ -49,8 +49,7 @@ def unique_variable(name, variables, compat='broadcast_equals'): variables : list of xarray.Variable List of Variable objects, all of which go by the same name in different inputs. - compat : {'identical', 'equals', 'broadcast_equals', - 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'no_conflicts'}, optional Type of equality check to use. Returns @@ -60,7 +59,7 @@ def unique_variable(name, variables, compat='broadcast_equals'): Raises ------ MergeError: if any of the variables are not equal. - """ + """ # noqa out = variables[0] if len(variables) > 1: combine_method = None @@ -122,8 +121,7 @@ def merge_variables( priority_vars : mapping with Variable or None values, optional If provided, variables are always taken from this dict in preference to the input variable dictionaries, without checking for conflicts. - compat : {'identical', 'equals', 'broadcast_equals', - 'minimal', 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'minimal', 'no_conflicts'}, optional Type of equality check to use when checking for conflicts. Returns @@ -131,7 +129,7 @@ def merge_variables( OrderedDict with keys taken by the union of keys on list_of_variable_dicts, and Variable values corresponding to those that should be found on the merged result. - """ + """ # noqa if priority_vars is None: priority_vars = {} @@ -313,15 +311,14 @@ def _get_priority_vars(objects, priority_arg, compat='equals'): Dictionaries in which to find the priority variables. priority_arg : int or None Integer object whose variable should take priority. - compat : {'identical', 'equals', 'broadcast_equals', - 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'no_conflicts'}, optional Compatibility checks to use when merging variables. Returns ------- None, if priority_arg is None, or an OrderedDict with Variable objects as values indicating priority variables. - """ + """ # noqa if priority_arg is None: priority_vars = {} else: @@ -406,8 +403,7 @@ def merge_core(objs, ---------- objs : list of mappings All values must be convertable to labeled arrays. - compat : {'identical', 'equals', 'broadcast_equals', - 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'no_conflicts'}, optional Compatibility checks to use when merging variables. join : {'outer', 'inner', 'left', 'right'}, optional How to combine objects with different indexes. @@ -430,7 +426,7 @@ def merge_core(objs, Raises ------ MergeError if the merge cannot be done successfully. - """ + """ # noqa from .dataset import calculate_dimensions _assert_compat_valid(compat) @@ -472,8 +468,7 @@ def merge(objects, compat='no_conflicts', join='outer'): objects : Iterable[Union[xarray.Dataset, xarray.DataArray, dict]] Merge together all variables from these objects. If any of them are DataArray objects, they must have a name. - compat : {'identical', 'equals', 'broadcast_equals', - 'no_conflicts'}, optional + compat : {'identical', 'equals', 'broadcast_equals', 'no_conflicts'}, optional String indicating how to compare variables of the same name for potential conflicts: @@ -516,7 +511,7 @@ def merge(objects, compat='no_conflicts', join='outer'): See also -------- concat - """ + """ # noqa from .dataarray import DataArray from .dataset import Dataset From e95f765b52166b7b52b58ecdf1fc3ad4d7e24f99 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sat, 29 Dec 2018 18:27:27 -0800 Subject: [PATCH 040/108] revert to dev version --- doc/whats-new.rst | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 25bc09d32a3..ea3a12aae0d 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -13,6 +13,20 @@ What's New import xarray as xr np.random.seed(123456) +.. _whats-new.0.11.2: + +v0.11.2 (unreleased) +-------------------- + +Breaking changes +~~~~~~~~~~~~~~~~ + +Enhancements +~~~~~~~~~~~~ + +Bug fixes +~~~~~~~~~ + .. _whats-new.0.11.1: v0.11.1 (29 December 2018) From 11e6aac859a12a9ffda66bbf5963e545314257e0 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Mon, 31 Dec 2018 15:48:35 -0800 Subject: [PATCH 041/108] TST: silence warnings from bottleneck (#2638) --- setup.cfg | 3 +++ 1 file changed, 3 insertions(+) diff --git a/setup.cfg b/setup.cfg index a0d4b46c14e..51261be0b36 100644 --- a/setup.cfg +++ b/setup.cfg @@ -4,6 +4,9 @@ universal = 1 [tool:pytest] python_files=test_*.py testpaths=xarray/tests +# Fixed upstream in https://github.com/kwgoodman/bottleneck/pull/199 +filterwarnings = + ignore:Using a non-tuple sequence for multidimensional indexing is deprecated:FutureWarning [flake8] max-line-length=79 From faacc8da000b7971233142be349ee39c6d088510 Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Tue, 1 Jan 2019 20:52:03 -0800 Subject: [PATCH 042/108] DEP: drop python 2 support and associated ci mods (#2637) * drop python 2 support and associated ci mods * add py35-min env file * fix python version in py37-windows env * fix setup.py * move iris and pynio to py36 env * add cdms2 to 36 test env * testing with UVCDAT_ANONYMOUS_LOG=no * use pytest-env * pip for pytest plugins --- .travis.yml | 3 +- appveyor.yml | 9 +++--- ci/requirements-py27-cdat+iris+pynio.yml | 30 ------------------- ...py27-min.yml => requirements-py35-min.yml} | 5 ++-- ci/requirements-py35.yml | 6 ++-- ci/requirements-py36-bottleneck-dev.yml | 5 ++-- ci/requirements-py36-condaforge-rc.yml | 6 ++-- ci/requirements-py36-dask-dev.yml | 5 ++-- ci/requirements-py36-hypothesis.yml | 12 ++++---- ci/requirements-py36-netcdf4-dev.yml | 5 ++-- ci/requirements-py36-pandas-dev.yml | 5 ++-- ci/requirements-py36-pynio-dev.yml | 8 ++--- ci/requirements-py36-rasterio.yml | 8 ++--- ci/requirements-py36-windows.yml | 1 + ci/requirements-py36-zarr-dev.yml | 5 ++-- ci/requirements-py36.yml | 12 +++++--- ...dows.yml => requirements-py37-windows.yml} | 10 +++---- ci/requirements-py37.yml | 9 +++--- doc/installing.rst | 14 ++------- doc/whats-new.rst | 4 +++ setup.cfg | 2 ++ setup.py | 3 +- 22 files changed, 71 insertions(+), 96 deletions(-) delete mode 100644 ci/requirements-py27-cdat+iris+pynio.yml rename ci/{requirements-py27-min.yml => requirements-py35-min.yml} (71%) rename ci/{requirements-py27-windows.yml => requirements-py37-windows.yml} (74%) diff --git a/.travis.yml b/.travis.yml index 8c2ee3ab0d5..fbb7221d7ea 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,8 +10,7 @@ branches: matrix: fast_finish: true include: - - env: CONDA_ENV=py27-min - - env: CONDA_ENV=py27-cdat+iris+pynio + - env: CONDA_ENV=py35-min - env: CONDA_ENV=py35 - env: CONDA_ENV=py36 - env: CONDA_ENV=py37 diff --git a/appveyor.yml b/appveyor.yml index 7020adae572..347883b96cb 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -7,15 +7,14 @@ branches: environment: matrix: - - PYTHON: "C:\\Python27-conda64" - PYTHON_VERSION: "2.7" - PYTHON_ARCH: "64" - CONDA_ENV: "py27-windows" - - PYTHON: "C:\\Python36-conda64" PYTHON_VERSION: "3.6" PYTHON_ARCH: "64" CONDA_ENV: "py36-windows" + - PYTHON: "C:\\Python37-conda64" + PYTHON_VERSION: "3.7" + PYTHON_ARCH: "64" + CONDA_ENV: "py37-windows" install: # Install miniconda Python diff --git a/ci/requirements-py27-cdat+iris+pynio.yml b/ci/requirements-py27-cdat+iris+pynio.yml deleted file mode 100644 index 116e323d517..00000000000 --- a/ci/requirements-py27-cdat+iris+pynio.yml +++ /dev/null @@ -1,30 +0,0 @@ -name: test_env -channels: - - conda-forge -dependencies: - - python=2.7 - - cdat-lite - - cftime - - cyordereddict - - dask - - distributed - - h5py - - h5netcdf - - matplotlib - - netcdf4 - - numpy - - pandas - - pathlib2 - - pynio - - pytest - - flake8 - - mock - - scipy - - seaborn - - toolz - - rasterio - - iris>=1.10 - - zarr - - pip: - - coveralls - - pytest-cov diff --git a/ci/requirements-py27-min.yml b/ci/requirements-py35-min.yml similarity index 71% rename from ci/requirements-py27-min.yml rename to ci/requirements-py35-min.yml index 118b629271e..1f41d0d9dc1 100644 --- a/ci/requirements-py27-min.yml +++ b/ci/requirements-py35-min.yml @@ -1,11 +1,12 @@ name: test_env dependencies: - - python=2.7 + - python=3.5 - pytest - flake8 - mock - numpy=1.12 - pandas=0.19 - pip: - - coveralls + - pytest-env - pytest-cov + - coveralls \ No newline at end of file diff --git a/ci/requirements-py35.yml b/ci/requirements-py35.yml index 9615aeba9aa..29f4bb020fc 100644 --- a/ci/requirements-py35.yml +++ b/ci/requirements-py35.yml @@ -10,6 +10,9 @@ dependencies: - matplotlib=1.5 - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - pandas @@ -18,6 +21,3 @@ dependencies: - toolz - rasterio - zarr - - pip: - - coveralls - - pytest-cov diff --git a/ci/requirements-py36-bottleneck-dev.yml b/ci/requirements-py36-bottleneck-dev.yml index b8619658929..bdf0349b5c0 100644 --- a/ci/requirements-py36-bottleneck-dev.yml +++ b/ci/requirements-py36-bottleneck-dev.yml @@ -11,6 +11,9 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - pandas @@ -19,5 +22,3 @@ dependencies: - toolz - pip: - git+https://github.com/kwgoodman/bottleneck.git - - coveralls - - pytest-cov diff --git a/ci/requirements-py36-condaforge-rc.yml b/ci/requirements-py36-condaforge-rc.yml index 8436d4e3e83..ba980deeeea 100644 --- a/ci/requirements-py36-condaforge-rc.yml +++ b/ci/requirements-py36-condaforge-rc.yml @@ -12,12 +12,12 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - pandas - seaborn - scipy - toolz - - pip: - - coveralls - - pytest-cov diff --git a/ci/requirements-py36-dask-dev.yml b/ci/requirements-py36-dask-dev.yml index e580aaf3889..20b10fe29ee 100644 --- a/ci/requirements-py36-dask-dev.yml +++ b/ci/requirements-py36-dask-dev.yml @@ -9,6 +9,9 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - pandas @@ -20,7 +23,5 @@ dependencies: - zarr - pseudonetcdf>=3.0.1 - pip: - - coveralls - - pytest-cov - git+https://github.com/dask/dask.git - git+https://github.com/dask/distributed.git diff --git a/ci/requirements-py36-hypothesis.yml b/ci/requirements-py36-hypothesis.yml index 29f4ae33538..c5c228095a4 100644 --- a/ci/requirements-py36-hypothesis.yml +++ b/ci/requirements-py36-hypothesis.yml @@ -10,6 +10,10 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls + - hypothesis - flake8 - numpy - pandas @@ -19,9 +23,5 @@ dependencies: - rasterio - bottleneck - zarr - - pip: - - coveralls - - pytest-cov - - pydap - - lxml - - hypothesis + - pydap + - lxml diff --git a/ci/requirements-py36-netcdf4-dev.yml b/ci/requirements-py36-netcdf4-dev.yml index a473ceb5b0a..2616a113fa4 100644 --- a/ci/requirements-py36-netcdf4-dev.yml +++ b/ci/requirements-py36-netcdf4-dev.yml @@ -10,13 +10,14 @@ dependencies: - h5netcdf - matplotlib - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - pandas - scipy - toolz - pip: - - coveralls - - pytest-cov - git+https://github.com/Unidata/netcdf4-python.git - git+https://github.com/Unidata/cftime.git diff --git a/ci/requirements-py36-pandas-dev.yml b/ci/requirements-py36-pandas-dev.yml index 1f1acabcae9..2b914f746ab 100644 --- a/ci/requirements-py36-pandas-dev.yml +++ b/ci/requirements-py36-pandas-dev.yml @@ -12,11 +12,12 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - scipy - toolz - pip: - - coveralls - - pytest-cov - git+https://github.com/pydata/pandas.git diff --git a/ci/requirements-py36-pynio-dev.yml b/ci/requirements-py36-pynio-dev.yml index 2caaa8affe5..b8987611a6e 100644 --- a/ci/requirements-py36-pynio-dev.yml +++ b/ci/requirements-py36-pynio-dev.yml @@ -13,6 +13,9 @@ dependencies: - netcdf4 - pynio=dev - pytest + - pytest-env + - pytest-cov + - coveralls - numpy - pandas - scipy @@ -20,7 +23,4 @@ dependencies: - toolz - rasterio - bottleneck - - pip: - - coveralls - - pytest-cov - - pydap + - pydap diff --git a/ci/requirements-py36-rasterio.yml b/ci/requirements-py36-rasterio.yml index 2ec75f5d8b2..dda9ea8cd29 100644 --- a/ci/requirements-py36-rasterio.yml +++ b/ci/requirements-py36-rasterio.yml @@ -11,6 +11,9 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env + - pytest-cov + - coveralls - numpy - pandas - scipy @@ -18,7 +21,4 @@ dependencies: - toolz - rasterio>=1.0 - bottleneck - - pip: - - coveralls - - pytest-cov - - pydap + - pydap diff --git a/ci/requirements-py36-windows.yml b/ci/requirements-py36-windows.yml index 62f08318087..b139d5c78ca 100644 --- a/ci/requirements-py36-windows.yml +++ b/ci/requirements-py36-windows.yml @@ -11,6 +11,7 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-env - numpy - pandas - scipy diff --git a/ci/requirements-py36-zarr-dev.yml b/ci/requirements-py36-zarr-dev.yml index 6ed466ba5cb..9966cf74815 100644 --- a/ci/requirements-py36-zarr-dev.yml +++ b/ci/requirements-py36-zarr-dev.yml @@ -8,6 +8,9 @@ dependencies: - distributed - matplotlib - pytest + - pytest-env + - pytest-cov + - coveralls - flake8 - numpy - pandas @@ -16,6 +19,4 @@ dependencies: - toolz - bottleneck - pip: - - coveralls - - pytest-cov - git+https://github.com/zarr-developers/zarr.git diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index 321f3087ea2..2986dc33adb 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -11,6 +11,9 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-cov + - pytest-env + - coveralls - flake8 - numpy - pandas @@ -22,9 +25,10 @@ dependencies: - zarr - pseudonetcdf>=3.0.1 - eccodes + - cdms2 + - pynio + - iris>=1.10 + - pydap + - lxml - pip: - - coveralls - - pytest-cov - - pydap - - lxml - cfgrib>=0.9.2 diff --git a/ci/requirements-py27-windows.yml b/ci/requirements-py37-windows.yml similarity index 74% rename from ci/requirements-py27-windows.yml rename to ci/requirements-py37-windows.yml index 967b7c584b9..24a7f556b2c 100644 --- a/ci/requirements-py27-windows.yml +++ b/ci/requirements-py37-windows.yml @@ -2,16 +2,16 @@ name: test_env channels: - conda-forge dependencies: - - python=2.7 + - python=3.7 + - cftime - dask - distributed - h5py - h5netcdf - matplotlib - - pathlib2 + - netcdf4 - pytest - - flake8 - - mock + - pytest-env - numpy - pandas - scipy @@ -19,5 +19,3 @@ dependencies: - toolz - rasterio - zarr - - pip: - - netcdf4 diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 6292c4c5eb6..86a44ed5398 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -11,6 +11,9 @@ dependencies: - matplotlib - netcdf4 - pytest + - pytest-cov + - pytest-env + - coveralls - flake8 - numpy - pandas @@ -21,10 +24,8 @@ dependencies: - bottleneck - zarr - pseudonetcdf>=3.0.1 + - lxml - eccodes + - pydap - pip: - - coveralls - - pytest-cov - - pydap - - lxml - cfgrib>=0.9.2 \ No newline at end of file diff --git a/doc/installing.rst b/doc/installing.rst index fbe6a316936..083ac6c450a 100644 --- a/doc/installing.rst +++ b/doc/installing.rst @@ -6,7 +6,7 @@ Installation Required dependencies --------------------- -- Python 2.7 [1]_, 3.5, 3.6, or 3.7 +- Python 3.5, 3.6, or 3.7 - `numpy `__ (1.12 or later) - `pandas `__ (0.19.2 or later) @@ -111,14 +111,4 @@ To run these benchmark tests in a local machine, first install - `airspeed-velocity `__: a tool for benchmarking Python packages over their lifetime. and run -``asv run # this will install some conda environments in ./.asv/envs`` - -.. [1] Xarray plans to drop support for python 2.7 at the end of 2018. This - means that new releases of xarray published after this date will only be - installable on python 3+ environments, but older versions of xarray will - always be available to python 2.7 users. For more information see the - following references: - - - `Xarray Github issue discussing dropping Python 2 `__ - - `Python 3 Statement `__ - - `Tips on porting to Python 3 `__ +``asv run # this will install some conda environments in ./.asv/envs`` \ No newline at end of file diff --git a/doc/whats-new.rst b/doc/whats-new.rst index ea3a12aae0d..b1c80ced761 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -21,6 +21,10 @@ v0.11.2 (unreleased) Breaking changes ~~~~~~~~~~~~~~~~ +- Remove support for Python 2. This is the first version of xarray that is + Python 3 only. (:issue:`1876`). + By `Joe Hamman `_. + Enhancements ~~~~~~~~~~~~ diff --git a/setup.cfg b/setup.cfg index 51261be0b36..847415ac04d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -7,6 +7,8 @@ testpaths=xarray/tests # Fixed upstream in https://github.com/kwgoodman/bottleneck/pull/199 filterwarnings = ignore:Using a non-tuple sequence for multidimensional indexing is deprecated:FutureWarning +env = + UVCDAT_ANONYMOUS_LOG=no [flake8] max-line-length=79 diff --git a/setup.py b/setup.py index eaf57dff81d..ac226c4cab5 100644 --- a/setup.py +++ b/setup.py @@ -24,6 +24,7 @@ 'Topic :: Scientific/Engineering', ] +PYTHON_REQUIRES = '>=3.5' INSTALL_REQUIRES = ['numpy >= 1.12', 'pandas >= 0.19.2'] SETUP_REQUIRES = ['pytest-runner >= 4.2'] TESTS_REQUIRE = ['pytest >= 2.7.1'] @@ -66,10 +67,10 @@ classifiers=CLASSIFIERS, description=DESCRIPTION, long_description=LONG_DESCRIPTION, + python_requires=PYTHON_REQUIRES, install_requires=INSTALL_REQUIRES, setup_requires=SETUP_REQUIRES, tests_require=TESTS_REQUIRE, url=URL, - python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*', packages=find_packages(), package_data={'xarray': ['tests/data/*']}) From c62c4fa0a3fff09dbf5e4cb842c1dc290a3ba412 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Wed, 2 Jan 2019 17:14:37 -0800 Subject: [PATCH 043/108] BUG: pytest-runner no required for setup.py (#2643) --- setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index ac226c4cab5..458b161a510 100644 --- a/setup.py +++ b/setup.py @@ -26,7 +26,8 @@ PYTHON_REQUIRES = '>=3.5' INSTALL_REQUIRES = ['numpy >= 1.12', 'pandas >= 0.19.2'] -SETUP_REQUIRES = ['pytest-runner >= 4.2'] +needs_pytest = {'pytest', 'test', 'ptr'}.intersection(sys.argv) +SETUP_REQUIRES = ['pytest-runner >= 4.2'] if needs_pytest else [] TESTS_REQUIRE = ['pytest >= 2.7.1'] if sys.version_info[0] < 3: TESTS_REQUIRE.append('mock') From 49731d438e261073ddd71269e829c77418e465e9 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Wed, 2 Jan 2019 20:18:05 -0500 Subject: [PATCH 044/108] Use built-in interp for interpolation with resample (#2640) * Use built-in interp for interpolation with resample Use bounds_error=False in interpolate * Add test for 2197 * lint * flake8 --- doc/whats-new.rst | 10 ++++ xarray/core/resample.py | 96 ++++------------------------------ xarray/tests/test_dataarray.py | 45 +++++++++++++--- 3 files changed, 58 insertions(+), 93 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index b1c80ced761..e9ff93d630e 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -28,9 +28,19 @@ Breaking changes Enhancements ~~~~~~~~~~~~ +- Upsampling an array via interpolation with resample is now dask-compatible, + as long as the array is not chunked along the resampling dimension. + By `Spencer Clark `_. + Bug fixes ~~~~~~~~~ +- Interpolating via resample now internally specifies ``bounds_error=False`` + as an argument to ``scipy.interpolate.interp1d``, allowing for interpolation + from higher frequencies to lower frequencies. Datapoints outside the bounds + of the original time coordinate are now filled with NaN (:issue:`2197`). By + `Spencer Clark `_. + .. _whats-new.0.11.1: v0.11.1 (29 December 2018) diff --git a/xarray/core/resample.py b/xarray/core/resample.py index 49351efc70f..886303db345 100644 --- a/xarray/core/resample.py +++ b/xarray/core/resample.py @@ -2,7 +2,6 @@ from . import ops from .groupby import DEFAULT_DIMS, DataArrayGroupBy, DatasetGroupBy -from .pycompat import OrderedDict, dask_array_type RESAMPLE_DIM = '__resample_dim__' @@ -110,7 +109,16 @@ def interpolate(self, kind='linear'): return self._interpolate(kind=kind) def _interpolate(self, kind='linear'): - raise NotImplementedError + """Apply scipy.interpolate.interp1d along resampling dimension.""" + # drop any existing non-dimension coordinates along the resampling + # dimension + dummy = self._obj.copy() + for k, v in self._obj.coords.items(): + if k != self._dim and self._dim in v.dims: + dummy = dummy.drop(k) + return dummy.interp(assume_sorted=True, method=kind, + kwargs={'bounds_error': False}, + **{self._dim: self._full_index}) class DataArrayResample(DataArrayGroupBy, Resample): @@ -182,46 +190,6 @@ def apply(self, func, shortcut=False, args=(), **kwargs): return combined - def _interpolate(self, kind='linear'): - """Apply scipy.interpolate.interp1d along resampling dimension.""" - from .dataarray import DataArray - from scipy.interpolate import interp1d - - if isinstance(self._obj.data, dask_array_type): - raise TypeError( - "Up-sampling via interpolation was attempted on the the " - "variable '{}', but it is a dask array; dask arrays are not " - "yet supported in resample.interpolate(). Load into " - "memory with Dataset.load() before resampling." - .format(self._obj.data.name) - ) - - x = self._obj[self._dim].astype('float') - y = self._obj.data - - axis = self._obj.get_axis_num(self._dim) - - f = interp1d(x, y, kind=kind, axis=axis, bounds_error=True, - assume_sorted=True) - new_x = self._full_index.values.astype('float') - - # construct new up-sampled DataArray - dummy = self._obj.copy() - dims = dummy.dims - - # drop any existing non-dimension coordinates along the resampling - # dimension - coords = OrderedDict() - for k, v in dummy.coords.items(): - # is the resampling dimension - if k == self._dim: - coords[self._dim] = self._full_index - # else, check if resampling dim is in coordinate dimensions - elif self._dim not in v.dims: - coords[k] = v - return DataArray(f(new_x), coords, dims, name=dummy.name, - attrs=dummy.attrs) - ops.inject_reduce_methods(DataArrayResample) ops.inject_binary_ops(DataArrayResample) @@ -308,50 +276,6 @@ def reduce(self, func, dim=None, keep_attrs=None, **kwargs): return super(DatasetResample, self).reduce( func, dim, keep_attrs, **kwargs) - def _interpolate(self, kind='linear'): - """Apply scipy.interpolate.interp1d along resampling dimension.""" - from .dataset import Dataset - from .variable import Variable - from scipy.interpolate import interp1d - - old_times = self._obj[self._dim].astype(float) - new_times = self._full_index.values.astype(float) - - data_vars = OrderedDict() - coords = OrderedDict() - - # Apply the interpolation to each DataArray in our original Dataset - for name, variable in self._obj.variables.items(): - if name in self._obj.coords: - if name == self._dim: - coords[self._dim] = self._full_index - elif self._dim not in variable.dims: - coords[name] = variable - else: - if isinstance(variable.data, dask_array_type): - raise TypeError( - "Up-sampling via interpolation was attempted on the " - "variable '{}', but it is a dask array; dask arrays " - "are not yet supprted in resample.interpolate(). Load " - "into memory with Dataset.load() before resampling." - .format(name) - ) - - axis = variable.get_axis_num(self._dim) - - # We've previously checked for monotonicity along the - # re-sampling dimension (in __init__ via the GroupBy - # constructor), so we can avoid sorting the data again by - # passing 'assume_sorted=True' - f = interp1d(old_times, variable.data, kind=kind, - axis=axis, bounds_error=True, - assume_sorted=True) - interpolated = Variable(variable.dims, f(new_times)) - - data_vars[name] = interpolated - - return Dataset(data_vars, coords) - ops.inject_reduce_methods(DatasetResample) ops.inject_binary_ops(DatasetResample) diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 9b4f8523178..aa02e802fc5 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2524,6 +2524,16 @@ def test_upsample_interpolate(self): # done here due to floating point arithmetic assert_allclose(expected, actual, rtol=1e-16) + @requires_scipy + def test_upsample_interpolate_bug_2197(self): + dates = pd.date_range('2007-02-01', '2007-03-01', freq='D') + da = xr.DataArray(np.arange(len(dates)), [('time', dates)]) + result = da.resample(time='M').interpolate('linear') + expected_times = np.array([np.datetime64('2007-02-28'), + np.datetime64('2007-03-31')]) + expected = xr.DataArray([27., np.nan], [('time', expected_times)]) + assert_equal(result, expected) + @requires_scipy def test_upsample_interpolate_regression_1605(self): dates = pd.date_range('2016-01-01', '2016-03-31', freq='1D') @@ -2536,21 +2546,42 @@ def test_upsample_interpolate_regression_1605(self): @requires_dask @requires_scipy def test_upsample_interpolate_dask(self): - import dask.array as da - - times = pd.date_range('2000-01-01', freq='6H', periods=5) + from scipy.interpolate import interp1d xs = np.arange(6) ys = np.arange(3) + times = pd.date_range('2000-01-01', freq='6H', periods=5) z = np.arange(5)**2 - data = da.from_array(np.tile(z, (6, 3, 1)), (1, 3, 1)) + data = np.tile(z, (6, 3, 1)) array = DataArray(data, {'time': times, 'x': xs, 'y': ys}, ('x', 'y', 'time')) + chunks = {'x': 2, 'y': 1} + + expected_times = times.to_series().resample('1H').asfreq().index + # Split the times into equal sub-intervals to simulate the 6 hour + # to 1 hour up-sampling + new_times_idx = np.linspace(0, len(times) - 1, len(times) * 5) + for kind in ['linear', 'nearest', 'zero', 'slinear', 'quadratic', + 'cubic']: + actual = array.chunk(chunks).resample(time='1H').interpolate(kind) + actual = actual.compute() + f = interp1d(np.arange(len(times)), data, kind=kind, axis=-1, + bounds_error=True, assume_sorted=True) + expected_data = f(new_times_idx) + expected = DataArray(expected_data, + {'time': expected_times, 'x': xs, 'y': ys}, + ('x', 'y', 'time')) + # Use AllClose because there are some small differences in how + # we upsample timeseries versus the integer indexing as I've + # done here due to floating point arithmetic + assert_allclose(expected, actual, rtol=1e-16) - with raises_regex(TypeError, - "dask arrays are not yet supported"): - array.resample(time='1H').interpolate('linear') + # Check that an error is raised if an attempt is made to interpolate + # over a chunked dimension + with raises_regex(NotImplementedError, + 'Chunking along the dimension to be interpolated'): + array.chunk({'time': 1}).resample(time='1H').interpolate('linear') def test_align(self): array = DataArray(np.random.random((6, 8)), From cb5ef42d39fbd359b8a9800ca950bd0efad9035e Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Wed, 2 Jan 2019 17:54:44 -0800 Subject: [PATCH 045/108] DOC: document v0.11.2 release --- doc/whats-new.rst | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index e9ff93d630e..8f794041833 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -43,11 +43,11 @@ Bug fixes .. _whats-new.0.11.1: -v0.11.1 (29 December 2018) --------------------------- +v0.11.2 (2 January 2019) +------------------------ -This minor release includes a number of enhancements and bug fixes, and two -(slightly) breaking changes. +Removes inadvertently introduced setup dependency on pytest-runner +(:issue:`2641`). Otherwise, this release is exactly equivalent to 0.11.1. .. warning:: @@ -59,6 +59,14 @@ This minor release includes a number of enhancements and bug fixes, and two - `Python 3 Statement `__ - `Tips on porting to Python 3 `__ +.. _whats-new.0.11.1: + +v0.11.1 (29 December 2018) +-------------------------- + +This minor release includes a number of enhancements and bug fixes, and two +(slightly) breaking changes. + Breaking changes ~~~~~~~~~~~~~~~~ From a70b3c40979b16baaec3f58a97e11d6fa0353597 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Wed, 2 Jan 2019 17:59:54 -0800 Subject: [PATCH 046/108] Switch whats-new for 0.11.2 -> 0.11.3 --- doc/whats-new.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 8f794041833..27d0dc615d2 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -13,9 +13,9 @@ What's New import xarray as xr np.random.seed(123456) -.. _whats-new.0.11.2: +.. _whats-new.0.11.3: -v0.11.2 (unreleased) +v0.11.3 (unreleased) -------------------- Breaking changes @@ -41,7 +41,7 @@ Bug fixes of the original time coordinate are now filled with NaN (:issue:`2197`). By `Spencer Clark `_. -.. _whats-new.0.11.1: +.. _whats-new.0.11.2: v0.11.2 (2 January 2019) ------------------------ From 28123bb99cebee7d6bad2a1acd674ca023f4ff8d Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Thu, 3 Jan 2019 10:10:13 -0800 Subject: [PATCH 047/108] Use pycodestyle for lint checks. (#2642) * Use pycodestyle for lint checks. flake8 includes a few more useful checks, but it's annoying to only see it's output in Travis-CI results. This keeps Travis-CI and pep8speaks in sync. * Config fixup * Show issues from all patches with pep8speaks * lint in test_indexing.py * Lint adjust * blanket noqa * blanket ignore ambiguous variable name * Fix remaining lint errors --- .pep8speaks.yml | 14 +++++++++----- .travis.yml | 8 ++++---- ci/requirements-py37.yml | 4 ++-- setup.cfg | 11 +++-------- xarray/core/common.py | 2 +- xarray/core/dataset.py | 10 +++++----- xarray/core/pycompat.py | 10 ---------- xarray/tests/test_backends.py | 2 +- 8 files changed, 25 insertions(+), 36 deletions(-) diff --git a/.pep8speaks.yml b/.pep8speaks.yml index aedce6e44eb..018003f2223 100644 --- a/.pep8speaks.yml +++ b/.pep8speaks.yml @@ -1,12 +1,16 @@ # File : .pep8speaks.yml +# This should be kept in sync with the duplicate config in the [pycodestyle] +# block of setup.cfg. + scanner: - diff_only: True # If True, errors caused by only the patch are shown + diff_only: False # If True, errors caused by only the patch are shown pycodestyle: max-line-length: 79 ignore: # Errors and warnings to ignore - - E402, # module level import not at top of file - - E731, # do not assign a lambda expression, use a def - - W503 # line break before binary operator - - W504 # line break after binary operator + - E402 # module level import not at top of file + - E731 # do not assign a lambda expression, use a def + - E741 # ambiguous variable name + - W503 # line break before binary operator + - W504 # line break after binary operator diff --git a/.travis.yml b/.travis.yml index fbb7221d7ea..337447dbf69 100644 --- a/.travis.yml +++ b/.travis.yml @@ -31,7 +31,7 @@ matrix: - env: CONDA_ENV=py36-rasterio - env: CONDA_ENV=py36-zarr-dev - env: CONDA_ENV=docs - - env: CONDA_ENV=flake8 + - env: CONDA_ENV=lint - env: CONDA_ENV=py36-hypothesis allow_failures: @@ -62,7 +62,7 @@ before_install: install: - if [[ "$CONDA_ENV" == "docs" ]]; then conda env create -n test_env --file doc/environment.yml; - elif [[ "$CONDA_ENV" == "flake8" ]]; then + elif [[ "$CONDA_ENV" == "lint" ]]; then conda env create -n test_env --file ci/requirements-py37.yml; else conda env create -n test_env --file ci/requirements-$CONDA_ENV.yml; @@ -79,8 +79,8 @@ script: - if [[ "$CONDA_ENV" == "docs" ]]; then conda install -c conda-forge sphinx sphinx_rtd_theme sphinx-gallery numpydoc; sphinx-build -n -j auto -b html -d _build/doctrees doc _build/html; - elif [[ "$CONDA_ENV" == "flake8" ]]; then - flake8 xarray ; + elif [[ "$CONDA_ENV" == "lint" ]]; then + pycodestyle xarray ; elif [[ "$CONDA_ENV" == "py36-hypothesis" ]]; then pytest properties ; else diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 86a44ed5398..afd18e37a75 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -14,7 +14,7 @@ dependencies: - pytest-cov - pytest-env - coveralls - - flake8 + - pycodestyle - numpy - pandas - scipy @@ -28,4 +28,4 @@ dependencies: - eccodes - pydap - pip: - - cfgrib>=0.9.2 \ No newline at end of file + - cfgrib>=0.9.2 diff --git a/setup.cfg b/setup.cfg index 847415ac04d..21ba5ee8dec 100644 --- a/setup.cfg +++ b/setup.cfg @@ -10,15 +10,10 @@ filterwarnings = env = UVCDAT_ANONYMOUS_LOG=no -[flake8] +# This should be kept in sync with .pep8speaks.yml +[pycodestyle] max-line-length=79 -ignore= - E402 # module level import not at top of file - E731 # do not assign a lambda expression, use a def - W503 # line break before binary operator - W504 # line break after binary operator -exclude= - doc/ +ignore=E402,E731,E741,W503,W504 [isort] default_section=THIRDPARTY diff --git a/xarray/core/common.py b/xarray/core/common.py index 5b090bf0d2f..674c3b19b06 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -806,7 +806,7 @@ def close(self): self._file_obj = None def isin(self, test_elements): - """Tests each value in the array for whether it is in the supplied list. + """Tests each value in the array for whether it is in test elements. Parameters ---------- diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 62c6e98c954..9380023c5b7 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -1077,7 +1077,7 @@ def coords(self): @property def data_vars(self): - """Dictionary of xarray.DataArray objects corresponding to data variables + """Dictionary of DataArray objects corresponding to data variables """ return DataVariables(self) @@ -2171,8 +2171,8 @@ def swap_dims(self, dims_dict, inplace=None): inplace=inplace) def expand_dims(self, dim, axis=None): - """Return a new object with an additional axis (or axes) inserted at the - corresponding position in the array shape. + """Return a new object with an additional axis (or axes) inserted at + the corresponding position in the array shape. If dim is already a scalar coordinate, it will be promoted to a 1D coordinate consisting of a single value. @@ -2256,8 +2256,8 @@ def expand_dims(self, dim, axis=None): def set_index(self, indexes=None, append=False, inplace=None, **indexes_kwargs): - """Set Dataset (multi-)indexes using one or more existing coordinates or - variables. + """Set Dataset (multi-)indexes using one or more existing coordinates + or variables. Parameters ---------- diff --git a/xarray/core/pycompat.py b/xarray/core/pycompat.py index b980bc279b0..67921b5d145 100644 --- a/xarray/core/pycompat.py +++ b/xarray/core/pycompat.py @@ -128,22 +128,12 @@ def __exit__(self, exctype, excinst, exctb): # Inspired by discussions on http://bugs.python.org/issue13585 class ExitStack(object): """Context manager for dynamic management of a stack of exit callbacks - - For example: - - with ExitStack() as stack: - files = [stack.enter_context(open(fname)) for fname in filenames] - # All opened files will automatically be closed at the end of - # the with statement, even if attempts to open files later - # in the list raise an exception - """ def __init__(self): self._exit_callbacks = deque() def pop_all(self): - """Preserve the context stack by transferring it to a new instance""" new_stack = type(self)() new_stack._exit_callbacks = self._exit_callbacks self._exit_callbacks = deque() diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 48c2f64c8db..02ac06903c9 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -2463,7 +2463,7 @@ def test_cmp_local_file(self): assert actual.attrs.keys() == expected.attrs.keys() with self.create_datasets() as (actual, expected): - assert_equal(actual.isel(l=2), expected.isel(l=2)) # noqa + assert_equal(actual[{'l': 2}], expected[{'l': 2}]) with self.create_datasets() as (actual, expected): assert_equal(actual.isel(i=0, j=-1), From 06244df57cd910af4e85506fe067291888035155 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Fri, 4 Jan 2019 09:15:33 -0800 Subject: [PATCH 048/108] ENH: switch Dataset and DataArray to use explicit indexes (#2639) * ENH: switch Dataset and DataArray to use explicit indexes This change switches Dataset.indexes and DataArray.indexes to be backed by explicit dictionaries of indexes, instead of being implicitly defined by the set of coordinates with names matching dimensions. There are no changes to the public interface yet: these will come later. For now, indexes are recreated from coordinates every time a new DataArray or Dataset is created. In follow-up PRs, I will refactor indexes to be propagated explicitly in xarray operations. This will facilitate future API changes, when indexes will no longer only be associated with dimensions. * Add xarray.core.indexes * Fixes per review --- xarray/core/coordinates.py | 39 +-------------------------- xarray/core/dataarray.py | 15 ++++++++--- xarray/core/dataset.py | 27 +++++++++++++------ xarray/core/indexes.py | 55 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 86 insertions(+), 50 deletions(-) create mode 100644 xarray/core/indexes.py diff --git a/xarray/core/coordinates.py b/xarray/core/coordinates.py index efe8affb2a3..820937dae6a 100644 --- a/xarray/core/coordinates.py +++ b/xarray/core/coordinates.py @@ -196,6 +196,7 @@ def _update_coords(self, coords): self._data._variables = variables self._data._coord_names.update(new_coord_names) self._data._dims = dict(dims) + self._data._indexes = None def __delitem__(self, key): if key in self: @@ -276,44 +277,6 @@ def __iter__(self): return iter(self._data._level_coords) -class Indexes(Mapping, formatting.ReprMixin): - """Ordered Mapping[str, pandas.Index] for xarray objects. - """ - - def __init__(self, variables, sizes): - """Not for public consumption. - - Parameters - ---------- - variables : OrderedDict[Any, Variable] - Reference to OrderedDict holding variable objects. Should be the - same dictionary used by the source object. - sizes : OrderedDict[Any, int] - Map from dimension names to sizes. - """ - self._variables = variables - self._sizes = sizes - - def __iter__(self): - for key in self._sizes: - if key in self._variables: - yield key - - def __len__(self): - return sum(key in self._variables for key in self._sizes) - - def __contains__(self, key): - return key in self._sizes and key in self._variables - - def __getitem__(self, key): - if key not in self._sizes: - raise KeyError(key) - return self._variables[key].to_index() - - def __unicode__(self): - return formatting.indexes_repr(self) - - def assert_coordinate_consistent(obj, coords): """ Maeke sure the dimension coordinate of obj is consistent with coords. diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 25a66e529ae..38aa1b42b92 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -13,10 +13,11 @@ from .alignment import align, reindex_like_indexers from .common import AbstractArray, DataWithCoords from .coordinates import ( - DataArrayCoordinates, Indexes, LevelCoordinatesSource, + DataArrayCoordinates, LevelCoordinatesSource, assert_coordinate_consistent, remap_label_indexers) from .dataset import Dataset, merge_indexes, split_indexes from .formatting import format_item +from .indexes import default_indexes, Indexes from .options import OPTIONS from .pycompat import OrderedDict, basestring, iteritems, range, zip from .utils import ( @@ -165,7 +166,7 @@ class DataArray(AbstractArray, DataWithCoords): dt = property(DatetimeAccessor) def __init__(self, data, coords=None, dims=None, name=None, - attrs=None, encoding=None, fastpath=False): + attrs=None, encoding=None, indexes=None, fastpath=False): """ Parameters ---------- @@ -237,6 +238,10 @@ def __init__(self, data, coords=None, dims=None, name=None, self._coords = coords self._name = name + # TODO(shoyer): document this argument, once it becomes part of the + # public interface. + self._indexes = indexes + self._file_obj = None self._initialized = True @@ -534,9 +539,11 @@ def encoding(self, value): @property def indexes(self): - """OrderedDict of pandas.Index objects used for label based indexing + """Mapping of pandas.Index objects used for label based indexing """ - return Indexes(self._coords, self.sizes) + if self._indexes is None: + self._indexes = default_indexes(self._coords, self.dims) + return Indexes(self._indexes) @property def coords(self): diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 9380023c5b7..21f98e24c1f 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -13,16 +13,17 @@ import xarray as xr from . import ( - alignment, dtypes, duck_array_ops, formatting, groupby, indexing, ops, - pdcompat, resample, rolling, utils) + alignment, dtypes, duck_array_ops, formatting, groupby, + indexing, ops, pdcompat, resample, rolling, utils) from ..coding.cftimeindex import _parse_array_of_cftime_strings from .alignment import align from .common import ( ALL_DIMS, DataWithCoords, ImplementsDatasetReduce, _contains_datetime_like_objects) from .coordinates import ( - DatasetCoordinates, Indexes, LevelCoordinatesSource, + DatasetCoordinates, LevelCoordinatesSource, assert_coordinate_consistent, remap_label_indexers) +from .indexes import Indexes, default_indexes from .merge import ( dataset_merge_method, dataset_update_method, merge_data_and_coords, merge_variables) @@ -364,6 +365,10 @@ def __init__(self, data_vars=None, coords=None, attrs=None, coords = {} if data_vars is not None or coords is not None: self._set_init_vars_and_dims(data_vars, coords, compat) + + # TODO(shoyer): expose indexes as a public argument in __init__ + self._indexes = None + if attrs is not None: self.attrs = attrs self._encoding = None @@ -642,7 +647,7 @@ def persist(self, **kwargs): @classmethod def _construct_direct(cls, variables, coord_names, dims=None, attrs=None, - file_obj=None, encoding=None): + indexes=None, file_obj=None, encoding=None): """Shortcut around __init__ for internal use when we want to skip costly validation """ @@ -650,6 +655,7 @@ def _construct_direct(cls, variables, coord_names, dims=None, attrs=None, obj._variables = variables obj._coord_names = coord_names obj._dims = dims + obj._indexes = indexes obj._attrs = attrs obj._file_obj = file_obj obj._encoding = encoding @@ -664,7 +670,8 @@ def _from_vars_and_coord_names(cls, variables, coord_names, attrs=None): return cls._construct_direct(variables, coord_names, dims, attrs) def _replace_vars_and_dims(self, variables, coord_names=None, dims=None, - attrs=__default_attrs, inplace=False): + attrs=__default_attrs, indexes=None, + inplace=False): """Fastpath constructor for internal use. Preserves coord names and attributes. If not provided explicitly, @@ -693,13 +700,15 @@ def _replace_vars_and_dims(self, variables, coord_names=None, dims=None, self._coord_names = coord_names if attrs is not self.__default_attrs: self._attrs = attrs + self._indexes = indexes obj = self else: if coord_names is None: coord_names = self._coord_names.copy() if attrs is self.__default_attrs: attrs = self._attrs_copy() - obj = self._construct_direct(variables, coord_names, dims, attrs) + obj = self._construct_direct( + variables, coord_names, dims, attrs, indexes) return obj def _replace_indexes(self, indexes): @@ -1064,9 +1073,11 @@ def identical(self, other): @property def indexes(self): - """OrderedDict of pandas.Index objects used for label based indexing + """Mapping of pandas.Index objects used for label based indexing """ - return Indexes(self._variables, self._dims) + if self._indexes is None: + self._indexes = default_indexes(self._variables, self._dims) + return Indexes(self._indexes) @property def coords(self): diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py new file mode 100644 index 00000000000..ffa483fc370 --- /dev/null +++ b/xarray/core/indexes.py @@ -0,0 +1,55 @@ +from __future__ import absolute_import, division, print_function +try: + from collections.abc import Mapping +except ImportError: + from collections import Mapping +from collections import OrderedDict + +from . import formatting + + +class Indexes(Mapping, formatting.ReprMixin): + """Immutable proxy for Dataset or DataArrary indexes.""" + def __init__(self, indexes): + """Not for public consumption. + + Parameters + ---------- + indexes : Dict[Any, pandas.Index] + Indexes held by this object. + """ + self._indexes = indexes + + def __iter__(self): + return iter(self._indexes) + + def __len__(self): + return len(self._indexes) + + def __contains__(self, key): + return key in self._indexes + + def __getitem__(self, key): + return self._indexes[key] + + def __unicode__(self): + return formatting.indexes_repr(self) + + +def default_indexes(coords, dims): + """Default indexes for a Dataset/DataArray. + + Parameters + ---------- + coords : Mapping[Any, xarray.Variable] + Coordinate variables from which to draw default indexes. + dims : iterable + Iterable of dimension names. + + Returns + ------- + Mapping[Any, pandas.Index] mapping indexing keys (levels/dimension names) + to indexes used for indexing along that dimension. + """ + return OrderedDict((key, coords[key].to_index()) + for key in dims if key in coords) From ee44478ed921ae3afdece9d16dc179a197727e8d Mon Sep 17 00:00:00 2001 From: Benjamin Root Date: Sat, 5 Jan 2019 01:46:34 -0500 Subject: [PATCH 049/108] Change an `==` to an `is`. Fix tests so that this won't happen again. (#2648) * Change an `==` to an `is`. Fix tests so that this won't happen again. Closes #2647 and re-affirms #1988. * Reuse the same _CONCAT_DIM_DEFAULT object --- xarray/backends/api.py | 8 +++----- xarray/core/combine.py | 2 +- xarray/tests/test_backends.py | 23 +++++++++++++++++++++++ 3 files changed, 27 insertions(+), 6 deletions(-) diff --git a/xarray/backends/api.py b/xarray/backends/api.py index 3cd62e8264a..5f88783bb2e 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -10,7 +10,8 @@ from .. import Dataset, backends, conventions from ..core import indexing -from ..core.combine import _auto_combine, _infer_concat_order_from_positions +from ..core.combine import ( + _CONCAT_DIM_DEFAULT, _auto_combine, _infer_concat_order_from_positions) from ..core.pycompat import basestring, path_type from ..core.utils import close_on_error, is_grib_path, is_remote_uri from .common import ArrayWriter @@ -483,9 +484,6 @@ def close(self): f.close() -_CONCAT_DIM_DEFAULT = '__infer_concat_dim__' - - def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, compat='no_conflicts', preprocess=None, engine=None, lock=None, data_vars='all', coords='different', @@ -606,7 +604,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, # Coerce 1D input into ND to maintain backwards-compatible API until API # for N-D combine decided # (see https://github.com/pydata/xarray/pull/2553/#issuecomment-445892746) - if concat_dim is None or concat_dim == _CONCAT_DIM_DEFAULT: + if concat_dim is None or concat_dim is _CONCAT_DIM_DEFAULT: concat_dims = concat_dim elif not isinstance(concat_dim, list): concat_dims = [concat_dim] diff --git a/xarray/core/combine.py b/xarray/core/combine.py index abb2e2c1306..e552d8d900c 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -368,7 +368,7 @@ def _auto_concat(datasets, dim=None, data_vars='all', coords='different'): return concat(datasets, dim=dim, data_vars=data_vars, coords=coords) -_CONCAT_DIM_DEFAULT = '__infer_concat_dim__' +_CONCAT_DIM_DEFAULT = utils.ReprObject('') def _infer_concat_order_from_positions(datasets, concat_dims): diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 02ac06903c9..57e875bb563 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -2367,6 +2367,29 @@ def test_open_single_dataset(self): with open_mfdataset([tmp], concat_dim=dim) as actual: assert_identical(expected, actual) + def test_open_multi_dataset(self): + # Test for issue GH #1988 and #2647. This makes sure that the + # concat_dim is utilized when specified in open_mfdataset(). + # The additional wrinkle is to ensure that a length greater + # than one is tested as well due to numpy's implicit casting + # of 1-length arrays to booleans in tests, which allowed + # #2647 to still pass the test_open_single_dataset(), + # which is itself still needed as-is because the original + # bug caused one-length arrays to not be used correctly + # in concatenation. + rnddata = np.random.randn(10) + original = Dataset({'foo': ('x', rnddata)}) + dim = DataArray([100, 150], name='baz', dims='baz') + expected = Dataset({'foo': (('baz', 'x'), + np.tile(rnddata[np.newaxis, :], (2, 1)))}, + {'baz': [100, 150]}) + with create_tmp_file() as tmp1, \ + create_tmp_file() as tmp2: + original.to_netcdf(tmp1) + original.to_netcdf(tmp2) + with open_mfdataset([tmp1, tmp2], concat_dim=dim) as actual: + assert_identical(expected, actual) + def test_dask_roundtrip(self): with create_tmp_file() as tmp: data = create_test_data() From 85f88e7ac363c55b77375af93ebfc8c15b75c129 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Sat, 5 Jan 2019 14:06:54 -0500 Subject: [PATCH 050/108] Convert ref_date to UTC in encode_cf_datetime (#2651) * Convert ref_date to UTC in encode_cf_datetime * Only convert ref_date if it is not timezone-naive --- doc/whats-new.rst | 5 ++++- xarray/coding/times.py | 5 +++++ xarray/tests/test_coding_times.py | 16 ++++++++++++++++ 3 files changed, 25 insertions(+), 1 deletion(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 27d0dc615d2..bfe6e57e3bc 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -39,7 +39,10 @@ Bug fixes as an argument to ``scipy.interpolate.interp1d``, allowing for interpolation from higher frequencies to lower frequencies. Datapoints outside the bounds of the original time coordinate are now filled with NaN (:issue:`2197`). By - `Spencer Clark `_. + `Spencer Clark `_. +- Saving files with times encoded with reference dates with timezones + (e.g. '2000-01-01T00:00:00-05:00') no longer raises an error + (:issue:`2649`). By `Spencer Clark `_. .. _whats-new.0.11.2: diff --git a/xarray/coding/times.py b/xarray/coding/times.py index 0f2045cf356..c337a42e3b4 100644 --- a/xarray/coding/times.py +++ b/xarray/coding/times.py @@ -359,6 +359,11 @@ def encode_cf_datetime(dates, units=None, calendar=None): time_delta = np.timedelta64(1, delta_units).astype('timedelta64[ns]') ref_date = pd.Timestamp(ref_date) + # If the ref_date Timestamp is timezone-aware, convert to UTC and + # make it timezone-naive (GH 2649). + if ref_date.tz is not None: + ref_date = ref_date.tz_convert(None) + # Wrap the dates in a DatetimeIndex to do the subtraction to ensure # an OverflowError is raised if the ref_date is too far away from # dates to be encoded (GH 2272). diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index d9a40c23add..198f40ae410 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -750,3 +750,19 @@ def test_encode_cf_datetime_pandas_min(): np.testing.assert_array_equal(num, expected_num) assert units == expected_units assert calendar == expected_calendar + + +def test_encode_cf_datetime_units_with_tz(): + # Regression test for GH 2649 + units = 'days since 2000-01-01T00:00:00-05:00' + calendar = 'proleptic_gregorian' + dates = pd.date_range('2000', periods=3, tz='US/Eastern').values + num, units, calendar = encode_cf_datetime(dates, + units=units, + calendar=calendar) + expected_num = np.array([0, 1, 2]) + expected_units = 'days since 2000-01-01T00:00:00-05:00' + expected_calendar = 'proleptic_gregorian' + np.testing.assert_array_equal(num, expected_num) + assert units == expected_units + assert calendar == expected_calendar From a0bbea89d5ce1399a24ca6c27b446283588ca2b4 Mon Sep 17 00:00:00 2001 From: Ryan Abernathey Date: Sun, 6 Jan 2019 01:31:57 +0100 Subject: [PATCH 051/108] revise top-level package description (#2430) * revise main package description * Update doc/index.rst Co-Authored-By: rabernat * Update doc/index.rst Co-Authored-By: rabernat * Update doc/index.rst Co-Authored-By: rabernat * next draft * add mention of netCDF * eliminate CDM reference * update README and setup.py * Split long paragraph, minor rewordings --- README.rst | 38 ++++++++++++++++++++++++++------------ doc/index.rst | 38 ++++++++++++++++++++++++++------------ setup.py | 32 +++++++++++++++++++++++--------- 3 files changed, 75 insertions(+), 33 deletions(-) diff --git a/README.rst b/README.rst index 0ac71d33954..a4c8f6d200b 100644 --- a/README.rst +++ b/README.rst @@ -18,20 +18,34 @@ xarray: N-D labeled arrays and datasets .. image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A :target: http://numfocus.org -**xarray** (formerly **xray**) is an open source project and Python package that aims to bring the -labeled data power of pandas_ to the physical sciences, by providing -N-dimensional variants of the core pandas data structures. - -Our goal is to provide a pandas-like and pandas-compatible toolkit for -analytics on multi-dimensional arrays, rather than the tabular data for which -pandas excels. Our approach adopts the `Common Data Model`_ for self- -describing scientific data in widespread use in the Earth sciences: -``xarray.Dataset`` is an in-memory representation of a netCDF file. - +**xarray** (formerly **xray**) is an open source project and Python package +that makes working with labelled multi-dimensional arrays simple, +efficient, and fun! + +Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called +"tensors") are an essential part of computational science. +They are encountered in a wide range of fields, including physics, astronomy, +geoscience, bioinformatics, engineering, finance, and deep learning. +In Python, NumPy_ provides the fundamental data structure and API for +working with raw ND arrays. +However, real-world datasets are usually more than just raw numbers; +they have labels which encode information about how the array values map +to locations in space, time, etc. + +By introducing *dimensions*, *coordinates*, and *attributes* on top of raw +NumPy-like arrays, xarray is able to understand these labels and use them to +provide a more intuitive, more concise, and less error-prone experience. +Xarray also provides a large and growing library of functions for advanced +analytics and visualization with these data structures. +Xarray was inspired by and borrows heavily from pandas_, the popular data +analysis package focused on labelled tabular data. +Xarray can read and write data from most common labeled ND-array storage +formats and is particularly tailored to working with netCDF_ files, which were +the source of xarray's data model. + +.. _NumPy: http://www.numpy.org/ .. _pandas: http://pandas.pydata.org -.. _Common Data Model: http://www.unidata.ucar.edu/software/thredds/current/netcdf-java/CDM .. _netCDF: http://www.unidata.ucar.edu/software/netcdf -.. _OPeNDAP: http://www.opendap.org/ Why xarray? ----------- diff --git a/doc/index.rst b/doc/index.rst index 45897f4bccb..fe6d2874953 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -2,19 +2,33 @@ xarray: N-D labeled arrays and datasets in Python ================================================= **xarray** (formerly **xray**) is an open source project and Python package -that aims to bring the labeled data power of pandas_ to the physical sciences, -by providing N-dimensional variants of the core pandas data structures. - -Our goal is to provide a pandas-like and pandas-compatible toolkit for -analytics on multi-dimensional arrays, rather than the tabular data for which -pandas excels. Our approach adopts the `Common Data Model`_ for self- -describing scientific data in widespread use in the Earth sciences: -``xarray.Dataset`` is an in-memory representation of a netCDF file. - +that makes working with labelled multi-dimensional arrays simple, +efficient, and fun! + +Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called +"tensors") are an essential part of computational science. +They are encountered in a wide range of fields, including physics, astronomy, +geoscience, bioinformatics, engineering, finance, and deep learning. +In Python, NumPy_ provides the fundamental data structure and API for +working with raw ND arrays. +However, real-world datasets are usually more than just raw numbers; +they have labels which encode information about how the array values map +to locations in space, time, etc. + +By introducing *dimensions*, *coordinates*, and *attributes* on top of raw +NumPy-like arrays, xarray is able to understand these labels and use them to +provide a more intuitive, more concise, and less error-prone experience. +Xarray also provides a large and growing library of functions for advanced +analytics and visualization with these data structures. +Xarray was inspired by and borrows heavily from pandas_, the popular data +analysis package focused on labelled tabular data. +Xarray can read and write data from most common labeled ND-array storage +formats and is particularly tailored to working with netCDF_ files, which were +the source of xarray's data model. + +.. _NumPy: http://www.numpy.org/ .. _pandas: http://pandas.pydata.org -.. _Common Data Model: http://www.unidata.ucar.edu/software/thredds/current/netcdf-java/CDM .. _netCDF: http://www.unidata.ucar.edu/software/netcdf -.. _OPeNDAP: http://www.opendap.org/ Documentation ------------- @@ -106,7 +120,7 @@ See also .. _2015 Unidata Users Workshop talk: https://www.youtube.com/watch?v=J9ypQOnt5l8 .. _tutorial: https://github.com/Unidata/unidata-users-workshop/blob/master/notebooks/xray-tutorial.ipynb .. _with answers: https://github.com/Unidata/unidata-users-workshop/blob/master/notebooks/xray-tutorial-with-answers.ipynb -.. _Nicolas Fauchereau's tutorial: http://nbviewer.ipython.org/github/nicolasfauchereau/metocean/blob/master/notebooks/xray.ipynb +.. _Nicolas Fauchereau's tutorial: http://nbviewer.iPython.org/github/nicolasfauchereau/metocean/blob/master/notebooks/xray.ipynb Get in touch ------------ diff --git a/setup.py b/setup.py index 458b161a510..8c0c98ab33d 100644 --- a/setup.py +++ b/setup.py @@ -35,19 +35,33 @@ DESCRIPTION = "N-D labeled arrays and datasets in Python" LONG_DESCRIPTION = """ **xarray** (formerly **xray**) is an open source project and Python package -that aims to bring the labeled data power of pandas_ to the physical sciences, -by providing N-dimensional variants of the core pandas data structures. +that makes working with labelled multi-dimensional arrays simple, +efficient, and fun! -Our goal is to provide a pandas-like and pandas-compatible toolkit for -analytics on multi-dimensional arrays, rather than the tabular data for which -pandas excels. Our approach adopts the `Common Data Model`_ for self- -describing scientific data in widespread use in the Earth sciences: -``xarray.Dataset`` is an in-memory representation of a netCDF file. +Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called +"tensors") are an essential part of computational science. +They are encountered in a wide range of fields, including physics, astronomy, +geoscience, bioinformatics, engineering, finance, and deep learning. +In Python, NumPy_ provides the fundamental data structure and API for +working with raw ND arrays. +However, real-world datasets are usually more than just raw numbers; +they have labels which encode information about how the array values map +to locations in space, time, etc. +By introducing *dimensions*, *coordinates*, and *attributes* on top of raw +NumPy-like arrays, xarray is able to understand these labels and use them to +provide a more intuitive, more concise, and less error-prone experience. +Xarray also provides a large and growing library of functions for advanced +analytics and visualization with these data structures. +Xarray was inspired by and borrows heavily from pandas_, the popular data +analysis package focused on labelled tabular data. +Xarray can read and write data from most common labeled ND-array storage +formats and is particularly tailored to working with netCDF_ files, which were +the source of xarray's data model. + +.. _NumPy: http://www.numpy.org/ .. _pandas: http://pandas.pydata.org -.. _Common Data Model: http://www.unidata.ucar.edu/software/thredds/current/netcdf-java/CDM .. _netCDF: http://www.unidata.ucar.edu/software/netcdf -.. _OPeNDAP: http://www.opendap.org/ Important links --------------- From dba299befbdf19b02612573b218bcc1e97d4e010 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Sat, 5 Jan 2019 19:55:21 -0500 Subject: [PATCH 052/108] Improve test for GH 2649 (#2654) --- xarray/tests/test_coding_times.py | 36 ++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 12 deletions(-) diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 198f40ae410..756d51e7997 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -12,6 +12,7 @@ _import_cftime, cftime_to_nptime, decode_cf_datetime, encode_cf_datetime) from xarray.conventions import _update_bounds_attributes from xarray.core.common import contains_cftime_datetimes +from xarray.testing import assert_equal from . import ( assert_array_equal, has_cftime, has_cftime_or_netCDF4, has_dask, @@ -752,17 +753,28 @@ def test_encode_cf_datetime_pandas_min(): assert calendar == expected_calendar -def test_encode_cf_datetime_units_with_tz(): +@pytest.mark.skipif(not has_cftime_or_netCDF4, reason='cftime not installed') +def test_time_units_with_timezone_roundtrip(calendar): # Regression test for GH 2649 - units = 'days since 2000-01-01T00:00:00-05:00' - calendar = 'proleptic_gregorian' - dates = pd.date_range('2000', periods=3, tz='US/Eastern').values - num, units, calendar = encode_cf_datetime(dates, - units=units, - calendar=calendar) - expected_num = np.array([0, 1, 2]) expected_units = 'days since 2000-01-01T00:00:00-05:00' - expected_calendar = 'proleptic_gregorian' - np.testing.assert_array_equal(num, expected_num) - assert units == expected_units - assert calendar == expected_calendar + expected_num_dates = np.array([1, 2, 3]) + dates = decode_cf_datetime(expected_num_dates, expected_units, calendar) + + # Check that dates were decoded to UTC; here the hours should all + # equal 5. + result_hours = DataArray(dates).dt.hour + expected_hours = DataArray([5, 5, 5]) + assert_equal(result_hours, expected_hours) + + # Check that the encoded values are accurately roundtripped. + result_num_dates, result_units, result_calendar = encode_cf_datetime( + dates, expected_units, calendar) + + if calendar in _STANDARD_CALENDARS: + np.testing.assert_array_equal(result_num_dates, expected_num_dates) + else: + # cftime datetime arithmetic is not quite exact. + np.testing.assert_allclose(result_num_dates, expected_num_dates) + + assert result_units == expected_units + assert result_calendar == calendar From ede3e0101bae2f45c3f4634a1e1ecb8e2ccd0258 Mon Sep 17 00:00:00 2001 From: Keisuke Fujii Date: Sun, 6 Jan 2019 10:13:45 +0100 Subject: [PATCH 053/108] Added Coarsen (#2612) * Added variable.coarsen * Added DataArray.coarsen and Dataset.coarsen * pep8 * a bugfix for mpa3 * Support mean for datatime dtype * nanmean for DateTime * API updatedd via comments * bug fix in tests * updated docs * use pd.isnull rather than isnat * support Variable in datetime_to_numeric * use pd.isnull instead of numpy.isnat in test * Added an example to doc. * coordinate_func -> coord_func. Support 0d-array mean with datetime * Added an two dimensional example * flake8 * flake8 * a potential bug fix * Update via comments * Always use datetime64[ns] in mean * Added tests for 2d coarsen with value check * update via comment * whats new * typo fix --- doc/api.rst | 2 + doc/computation.rst | 41 ++++++++ doc/whats-new.rst | 9 +- xarray/core/common.py | 60 ++++++++++++ xarray/core/dataarray.py | 1 + xarray/core/dataset.py | 1 + xarray/core/duck_array_ops.py | 23 ++++- xarray/core/missing.py | 4 +- xarray/core/ops.py | 26 +++++ xarray/core/rolling.py | 144 +++++++++++++++++++++++----- xarray/core/utils.py | 30 +++++- xarray/core/variable.py | 81 +++++++++++++++- xarray/tests/test_dataset.py | 42 ++++++++ xarray/tests/test_duck_array_ops.py | 20 ++++ xarray/tests/test_variable.py | 56 +++++++++++ 15 files changed, 507 insertions(+), 33 deletions(-) diff --git a/doc/api.rst b/doc/api.rst index 9a00630f88e..e1f70cfbdea 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -147,6 +147,7 @@ Computation Dataset.groupby Dataset.groupby_bins Dataset.rolling + Dataset.coarsen Dataset.resample Dataset.diff Dataset.quantile @@ -312,6 +313,7 @@ Computation DataArray.groupby DataArray.groupby_bins DataArray.rolling + DataArray.coarsen DataArray.dt DataArray.resample DataArray.get_axis_num diff --git a/doc/computation.rst b/doc/computation.rst index f1d1450a6dc..412f24eee6a 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -199,6 +199,47 @@ You can also use ``construct`` to compute a weighted rolling sum: To avoid this, use ``skipna=False`` as the above example. +.. _comput.coarsen: + +Coarsen large arrays +==================== + +``DataArray`` and ``Dataset`` objects include a +:py:meth:`~xarray.DataArray.coarsen` and :py:meth:`~xarray.Dataset.coarsen` +methods. This supports the block aggregation along multiple dimensions, + +.. ipython:: python + + x = np.linspace(0, 10, 300) + t = pd.date_range('15/12/1999', periods=364) + da = xr.DataArray(np.sin(x) * np.cos(np.linspace(0, 1, 364)[:, np.newaxis]), + dims=['time', 'x'], coords={'time': t, 'x': x}) + da + +In order to take a block mean for every 7 days along ``time`` dimension and +every 2 points along ``x`` dimension, + +.. ipython:: python + + da.coarsen(time=7, x=2).mean() + +:py:meth:`~xarray.DataArray.coarsen` raises an ``ValueError`` if the data +length is not a multiple of the corresponding window size. +You can choose ``boundary='trim'`` or ``boundary='pad'`` options for trimming +the excess entries or padding ``nan`` to insufficient entries, + +.. ipython:: python + + da.coarsen(time=30, x=2, boundary='trim').mean() + +If you want to apply a specific function to coordinate, you can pass the +function or method name to ``coord_func`` option, + +.. ipython:: python + + da.coarsen(time=7, x=2, coord_func={'time': 'min'}).mean() + + Computation using Coordinates ============================= diff --git a/doc/whats-new.rst b/doc/whats-new.rst index bfe6e57e3bc..b50df2af10e 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -28,6 +28,11 @@ Breaking changes Enhancements ~~~~~~~~~~~~ +- :py:meth:`~xarray.DataArray.coarsen` and + :py:meth:`~xarray.Dataset.coarsen` are newly added. + See :ref:`comput.coarsen` for details. + (:issue:`2525`) + By `Keisuke Fujii `_. - Upsampling an array via interpolation with resample is now dask-compatible, as long as the array is not chunked along the resampling dimension. By `Spencer Clark `_. @@ -76,8 +81,8 @@ Breaking changes - Minimum rasterio version increased from 0.36 to 1.0 (for ``open_rasterio``) - Time bounds variables are now also decoded according to CF conventions (:issue:`2565`). The previous behavior was to decode them only if they - had specific time attributes, now these attributes are copied - automatically from the corresponding time coordinate. This might + had specific time attributes, now these attributes are copied + automatically from the corresponding time coordinate. This might brake downstream code that was relying on these variables to be not decoded. By `Fabien Maussion `_. diff --git a/xarray/core/common.py b/xarray/core/common.py index 674c3b19b06..923d30aad11 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -590,6 +590,66 @@ def rolling(self, dim=None, min_periods=None, center=False, **dim_kwargs): return self._rolling_cls(self, dim, min_periods=min_periods, center=center) + def coarsen(self, dim=None, boundary='exact', side='left', + coord_func='mean', **dim_kwargs): + """ + Coarsen object. + + Parameters + ---------- + dim: dict, optional + Mapping from the dimension name to the window size. + dim : str + Name of the dimension to create the rolling iterator + along (e.g., `time`). + window : int + Size of the moving window. + boundary : 'exact' | 'trim' | 'pad' + If 'exact', a ValueError will be raised if dimension size is not a + multiple of the window size. If 'trim', the excess entries are + dropped. If 'pad', NA will be padded. + side : 'left' or 'right' or mapping from dimension to 'left' or 'right' + coord_func: function (name) that is applied to the coordintes, + or a mapping from coordinate name to function (name). + + Returns + ------- + Coarsen object (core.rolling.DataArrayCoarsen for DataArray, + core.rolling.DatasetCoarsen for Dataset.) + + Examples + -------- + Coarsen the long time series by averaging over every four days. + + >>> da = xr.DataArray(np.linspace(0, 364, num=364), + ... dims='time', + ... coords={'time': pd.date_range( + ... '15/12/1999', periods=364)}) + >>> da + + array([ 0. , 1.002755, 2.00551 , ..., 361.99449 , 362.997245, + 364. ]) + Coordinates: + * time (time) datetime64[ns] 1999-12-15 1999-12-16 ... 2000-12-12 + >>> + >>> da.coarsen(time=3, boundary='trim').mean() + + array([ 1.002755, 4.011019, 7.019284, ..., 358.986226, + 361.99449 ]) + Coordinates: + * time (time) datetime64[ns] 1999-12-16 1999-12-19 ... 2000-12-10 + >>> + + See Also + -------- + core.rolling.DataArrayCoarsen + core.rolling.DatasetCoarsen + """ + dim = either_dict_or_kwargs(dim, dim_kwargs, 'coarsen') + return self._coarsen_cls( + self, dim, boundary=boundary, side=side, + coord_func=coord_func) + def resample(self, indexer=None, skipna=None, closed=None, label=None, base=0, keep_attrs=None, loffset=None, **indexer_kwargs): """Returns a Resample object for performing resampling operations. diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 38aa1b42b92..a63b63b45bf 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -161,6 +161,7 @@ class DataArray(AbstractArray, DataWithCoords): """ _groupby_cls = groupby.DataArrayGroupBy _rolling_cls = rolling.DataArrayRolling + _coarsen_cls = rolling.DataArrayCoarsen _resample_cls = resample.DataArrayResample dt = property(DatetimeAccessor) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 21f98e24c1f..29178c9b13c 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -317,6 +317,7 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords, """ _groupby_cls = groupby.DatasetGroupBy _rolling_cls = rolling.DatasetRolling + _coarsen_cls = rolling.DatasetCoarsen _resample_cls = resample.DatasetResample def __init__(self, data_vars=None, coords=None, attrs=None, diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index ef89dba2ab8..b02eb4e899b 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -13,7 +13,7 @@ import numpy as np import pandas as pd -from . import dask_array_ops, dtypes, npcompat, nputils +from . import dask_array_ops, dtypes, npcompat, nputils, utils from .nputils import nanfirst, nanlast from .pycompat import dask_array_type @@ -261,8 +261,6 @@ def f(values, axis=None, skipna=None, **kwargs): sum = _create_nan_agg_method('sum') sum.numeric_only = True sum.available_min_count = True -mean = _create_nan_agg_method('mean') -mean.numeric_only = True std = _create_nan_agg_method('std') std.numeric_only = True var = _create_nan_agg_method('var') @@ -278,6 +276,25 @@ def f(values, axis=None, skipna=None, **kwargs): cumsum_1d.numeric_only = True +_mean = _create_nan_agg_method('mean') + + +def mean(array, axis=None, skipna=None, **kwargs): + """ inhouse mean that can handle datatime dtype """ + array = asarray(array) + if array.dtype.kind == 'M': + offset = min(array) + # xarray always uses datetime[ns] for datetime + dtype = 'timedelta64[ns]' + return _mean(utils.datetime_to_numeric(array, offset), axis=axis, + skipna=skipna, **kwargs).astype(dtype) + offset + else: + return _mean(array, axis=axis, skipna=skipna, **kwargs) + + +mean.numeric_only = True + + def _nd_cum_func(cum_func, array, axis, **kwargs): array = asarray(array) if axis is None: diff --git a/xarray/core/missing.py b/xarray/core/missing.py index 3f4e0fc3ac9..5624d9b5092 100644 --- a/xarray/core/missing.py +++ b/xarray/core/missing.py @@ -7,7 +7,7 @@ import numpy as np import pandas as pd -from . import rolling +from . import utils from .common import _contains_datetime_like_objects from .computation import apply_ufunc from .duck_array_ops import dask_array_type @@ -370,7 +370,7 @@ def _get_valid_fill_mask(arr, dim, limit): None''' kw = {dim: limit + 1} # we explicitly use construct method to avoid copy. - new_dim = rolling._get_new_dimname(arr.dims, '_window') + new_dim = utils.get_temp_dimname(arr.dims, '_window') return (arr.isnull().rolling(min_periods=1, **kw) .construct(new_dim, fill_value=False) .sum(new_dim, skipna=False)) <= limit diff --git a/xarray/core/ops.py b/xarray/core/ops.py index a0dd2212a8f..272a4eaf2f1 100644 --- a/xarray/core/ops.py +++ b/xarray/core/ops.py @@ -122,6 +122,20 @@ New {da_or_ds} object with `{name}` applied along its rolling dimnension. """ +_COARSEN_REDUCE_DOCSTRING_TEMPLATE = """\ +Coarsen this object by applying `{name}` along its dimensions. + +Parameters +---------- +**kwargs : dict + Additional keyword arguments passed on to `{name}`. + +Returns +------- +reduced : DataArray or Dataset + New object with `{name}` applied along its coasen dimnensions. +""" + def fillna(data, other, join="left", dataset_join="left"): """Fill missing values in this object with data from the other object. @@ -378,3 +392,15 @@ def inject_datasetrolling_methods(cls): func.__doc__ = _ROLLING_REDUCE_DOCSTRING_TEMPLATE.format( name=func.__name__, da_or_ds='Dataset') setattr(cls, 'count', func) + + +def inject_coarsen_methods(cls): + # standard numpy reduce methods + methods = [(name, getattr(duck_array_ops, name)) + for name in NAN_REDUCE_METHODS] + for name, f in methods: + func = cls._reduce_method(f) + func.__name__ = name + func.__doc__ = _COARSEN_REDUCE_DOCSTRING_TEMPLATE.format( + name=func.__name__) + setattr(cls, name, func) diff --git a/xarray/core/rolling.py b/xarray/core/rolling.py index 09b632e47a6..57463ef5987 100644 --- a/xarray/core/rolling.py +++ b/xarray/core/rolling.py @@ -5,32 +5,14 @@ import numpy as np -from . import dtypes +from . import dtypes, duck_array_ops, utils from .dask_array_ops import dask_rolling_wrapper from .ops import ( - bn, has_bottleneck, inject_bottleneck_rolling_methods, - inject_datasetrolling_methods) + bn, has_bottleneck, inject_coarsen_methods, + inject_bottleneck_rolling_methods, inject_datasetrolling_methods) from .pycompat import OrderedDict, dask_array_type, zip -def _get_new_dimname(dims, new_dim): - """ Get an new dimension name based on new_dim, that is not used in dims. - If the same name exists, we add an underscore(s) in the head. - - Example1: - dims: ['a', 'b', 'c'] - new_dim: ['_rolling'] - -> ['_rolling'] - Example2: - dims: ['a', 'b', 'c', '_rolling'] - new_dim: ['_rolling'] - -> ['__rolling'] - """ - while new_dim in dims: - new_dim = '_' + new_dim - return new_dim - - class Rolling(object): """A object that implements the moving window pattern. @@ -231,7 +213,7 @@ def reduce(self, func, **kwargs): reduced : DataArray Array with summarized data. """ - rolling_dim = _get_new_dimname(self.obj.dims, '_rolling_dim') + rolling_dim = utils.get_temp_dimname(self.obj.dims, '_rolling_dim') windows = self.construct(rolling_dim) result = windows.reduce(func, dim=rolling_dim, **kwargs) @@ -242,7 +224,7 @@ def reduce(self, func, **kwargs): def _counts(self): """ Number of non-nan entries in each rolling window. """ - rolling_dim = _get_new_dimname(self.obj.dims, '_rolling_dim') + rolling_dim = utils.get_temp_dimname(self.obj.dims, '_rolling_dim') # We use False as the fill_value instead of np.nan, since boolean # array is faster to be reduced than object array. # The use of skipna==False is also faster since it does not need to @@ -454,5 +436,121 @@ def construct(self, window_dim, stride=1, fill_value=dtypes.NA): **{self.dim: slice(None, None, stride)}) +class Coarsen(object): + """A object that implements the coarsen. + + See Also + -------- + Dataset.coarsen + DataArray.coarsen + """ + + _attributes = ['windows', 'side', 'trim_excess'] + + def __init__(self, obj, windows, boundary, side, coord_func): + """ + Moving window object. + + Parameters + ---------- + obj : Dataset or DataArray + Object to window. + windows : A mapping from a dimension name to window size + dim : str + Name of the dimension to create the rolling iterator + along (e.g., `time`). + window : int + Size of the moving window. + boundary : 'exact' | 'trim' | 'pad' + If 'exact', a ValueError will be raised if dimension size is not a + multiple of window size. If 'trim', the excess indexes are trimed. + If 'pad', NA will be padded. + side : 'left' or 'right' or mapping from dimension to 'left' or 'right' + coord_func: mapping from coordinate name to func. + + Returns + ------- + coarsen + """ + self.obj = obj + self.windows = windows + self.side = side + self.boundary = boundary + + if not utils.is_dict_like(coord_func): + coord_func = {d: coord_func for d in self.obj.dims} + for c in self.obj.coords: + if c not in coord_func: + coord_func[c] = duck_array_ops.mean + self.coord_func = coord_func + + def __repr__(self): + """provide a nice str repr of our coarsen object""" + + attrs = ["{k}->{v}".format(k=k, v=getattr(self, k)) + for k in self._attributes + if getattr(self, k, None) is not None] + return "{klass} [{attrs}]".format(klass=self.__class__.__name__, + attrs=','.join(attrs)) + + +class DataArrayCoarsen(Coarsen): + @classmethod + def _reduce_method(cls, func): + """ + Return a wrapped function for injecting numpy methods. + see ops.inject_coarsen_methods + """ + def wrapped_func(self, **kwargs): + from .dataarray import DataArray + + reduced = self.obj.variable.coarsen( + self.windows, func, self.boundary, self.side) + coords = {} + for c, v in self.obj.coords.items(): + if c == self.obj.name: + coords[c] = reduced + else: + if any(d in self.windows for d in v.dims): + coords[c] = v.variable.coarsen( + self.windows, self.coord_func[c], + self.boundary, self.side) + else: + coords[c] = v + return DataArray(reduced, dims=self.obj.dims, coords=coords) + + return wrapped_func + + +class DatasetCoarsen(Coarsen): + @classmethod + def _reduce_method(cls, func): + """ + Return a wrapped function for injecting numpy methods. + see ops.inject_coarsen_methods + """ + def wrapped_func(self, **kwargs): + from .dataset import Dataset + + reduced = OrderedDict() + for key, da in self.obj.data_vars.items(): + reduced[key] = da.variable.coarsen( + self.windows, func, self.boundary, self.side) + + coords = {} + for c, v in self.obj.coords.items(): + if any(d in self.windows for d in v.dims): + coords[c] = v.variable.coarsen( + self.windows, self.coord_func[c], + self.boundary, self.side) + else: + coords[c] = v.variable + return Dataset(reduced, coords=coords) + + return wrapped_func + + inject_bottleneck_rolling_methods(DataArrayRolling) inject_datasetrolling_methods(DatasetRolling) +inject_coarsen_methods(DataArrayCoarsen) +inject_coarsen_methods(DatasetCoarsen) diff --git a/xarray/core/utils.py b/xarray/core/utils.py index fbda658c23f..e961426195e 100644 --- a/xarray/core/utils.py +++ b/xarray/core/utils.py @@ -622,10 +622,36 @@ def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): ------- array """ + from . import duck_array_ops + if offset is None: offset = array.min() array = array - offset if datetime_unit: - return (array / np.timedelta64(1, datetime_unit)).astype(dtype) - return array.astype(dtype) + array = array / np.timedelta64(1, datetime_unit) + # convert np.NaT to np.nan + if array.dtype.kind in 'mM': + if hasattr(array, 'isnull'): + return np.where(array.isnull(), np.nan, array.astype(dtype)) + return np.where(duck_array_ops.isnull(array), np.nan, + array.astype(dtype)) + return array + + +def get_temp_dimname(dims, new_dim): + """ Get an new dimension name based on new_dim, that is not used in dims. + If the same name exists, we add an underscore(s) in the head. + + Example1: + dims: ['a', 'b', 'c'] + new_dim: ['_rolling'] + -> ['_rolling'] + Example2: + dims: ['a', 'b', 'c', '_rolling'] + new_dim: ['_rolling'] + -> ['__rolling'] + """ + while new_dim in dims: + new_dim = '_' + new_dim + return new_dim diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 243487db034..48acc8edff9 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -1019,7 +1019,7 @@ def pad_with_fill_value(self, pad_widths=None, fill_value=dtypes.NA, pad_widths = either_dict_or_kwargs(pad_widths, pad_widths_kwargs, 'pad') - if fill_value is dtypes.NA: # np.nan is passed + if fill_value is dtypes.NA: dtype, fill_value = dtypes.maybe_promote(self.dtype) else: dtype = self.dtype @@ -1641,6 +1641,85 @@ def rolling_window(self, dim, window, window_dim, center=False, array, axis=self.get_axis_num(dim), window=window, center=center, fill_value=fill_value)) + def coarsen(self, windows, func, boundary='exact', side='left'): + """ + Apply + """ + windows = {k: v for k, v in windows.items() if k in self.dims} + if not windows: + return self.copy() + + reshaped, axes = self._coarsen_reshape(windows, boundary, side) + if isinstance(func, basestring): + name = func + func = getattr(duck_array_ops, name, None) + if func is None: + raise NameError('{} is not a valid method.'.format(name)) + return type(self)(self.dims, func(reshaped, axis=axes), self._attrs) + + def _coarsen_reshape(self, windows, boundary, side): + """ + Construct a reshaped-array for corsen + """ + if not utils.is_dict_like(boundary): + boundary = {d: boundary for d in windows.keys()} + + if not utils.is_dict_like(side): + side = {d: side for d in windows.keys()} + + # remove unrelated dimensions + boundary = {k: v for k, v in boundary.items() if k in windows} + side = {k: v for k, v in side.items() if k in windows} + + for d, window in windows.items(): + if window <= 0: + raise ValueError('window must be > 0. Given {}'.format(window)) + + variable = self + for d, window in windows.items(): + # trim or pad the object + size = variable.shape[self._get_axis_num(d)] + n = int(size / window) + if boundary[d] == 'exact': + if n * window != size: + raise ValueError( + 'Could not coarsen a dimension of size {} with ' + 'window {}'.format(size, window)) + elif boundary[d] == 'trim': + if side[d] == 'left': + variable = variable.isel({d: slice(0, window * n)}) + else: + excess = size - window * n + variable = variable.isel({d: slice(excess, None)}) + elif boundary[d] == 'pad': # pad + pad = window * n - size + if pad < 0: + pad += window + if side[d] == 'left': + pad_widths = {d: (0, pad)} + else: + pad_widths = {d: (pad, 0)} + variable = variable.pad_with_fill_value(pad_widths) + else: + raise TypeError( + "{} is invalid for boundary. Valid option is 'exact', " + "'trim' and 'pad'".format(boundary[d])) + + shape = [] + axes = [] + axis_count = 0 + for i, d in enumerate(variable.dims): + if d in windows: + size = variable.shape[i] + shape.append(int(size / windows[d])) + shape.append(windows[d]) + axis_count += 1 + axes.append(i + axis_count) + else: + shape.append(variable.shape[i]) + + return variable.data.reshape(shape), tuple(axes) + @property def real(self): return type(self)(self.dims, self.data.real, self._attrs) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 6f6287efcac..e7e091efa4c 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -4432,6 +4432,48 @@ def ds(request): 'y': range(2)}) +@pytest.mark.parametrize('dask', [True, False]) +@pytest.mark.parametrize(('boundary', 'side'), [ + ('trim', 'left'), ('pad', 'right')]) +def test_coarsen(ds, dask, boundary, side): + if dask and has_dask: + ds = ds.chunk({'x': 4}) + + actual = ds.coarsen(time=2, x=3, boundary=boundary, side=side).max() + assert_equal( + actual['z1'], + ds['z1'].coarsen(time=2, x=3, boundary=boundary, side=side).max()) + # coordinate should be mean by default + assert_equal(actual['time'], ds['time'].coarsen( + time=2, x=3, boundary=boundary, side=side).mean()) + + +@pytest.mark.parametrize('dask', [True, False]) +def test_coarsen_coords(ds, dask): + if dask and has_dask: + ds = ds.chunk({'x': 4}) + + # check if coord_func works + actual = ds.coarsen(time=2, x=3, boundary='trim', + coord_func={'time': 'max'}).max() + assert_equal(actual['z1'], + ds['z1'].coarsen(time=2, x=3, boundary='trim').max()) + assert_equal(actual['time'], + ds['time'].coarsen(time=2, x=3, boundary='trim').max()) + + # raise if exact + with pytest.raises(ValueError): + ds.coarsen(x=3).mean() + # should be no error + ds.isel(x=slice(0, 3 * (len(ds['x']) // 3))).coarsen(x=3).mean() + + # working test with pd.time + da = xr.DataArray( + np.linspace(0, 365, num=364), dims='time', + coords={'time': pd.date_range('15/12/1999', periods=364)}) + actual = da.coarsen(time=2).mean() + + def test_rolling_properties(ds): # catching invalid args with pytest.raises(ValueError) as exception: diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index 5ea5b3d2a42..2a6a957e10f 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/xarray/tests/test_duck_array_ops.py @@ -251,6 +251,26 @@ def assert_dask_array(da, dask): assert isinstance(da.data, dask_array_type) +@pytest.mark.parametrize('dask', [False, True]) +def test_datetime_reduce(dask): + time = np.array(pd.date_range('15/12/1999', periods=11)) + time[8: 11] = np.nan + da = DataArray( + np.linspace(0, 365, num=11), dims='time', coords={'time': time}) + + if dask and has_dask: + chunks = {'time': 5} + da = da.chunk(chunks) + + actual = da['time'].mean() + assert not pd.isnull(actual) + actual = da['time'].mean(skipna=False) + assert pd.isnull(actual) + + # test for a 0d array + assert da['time'][0].mean() == da['time'][:1].mean() + + @pytest.mark.parametrize('dim_num', [1, 2]) @pytest.mark.parametrize('dtype', [float, int, np.float32, np.bool_]) @pytest.mark.parametrize('dask', [False, True]) diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 08cab4b3541..6dd50e11fd3 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -1684,6 +1684,58 @@ def assert_assigned_2d(array, key_x, key_y, values): expected = Variable(['x', 'y'], [[2, 3], [3, 4], [4, 5]]) assert_identical(v, expected) + def test_coarsen(self): + v = self.cls(['x'], [0, 1, 2, 3, 4]) + actual = v.coarsen({'x': 2}, boundary='pad', func='mean') + expected = self.cls(['x'], [0.5, 2.5, 4]) + assert_identical(actual, expected) + + actual = v.coarsen({'x': 2}, func='mean', boundary='pad', + side='right') + expected = self.cls(['x'], [0, 1.5, 3.5]) + assert_identical(actual, expected) + + actual = v.coarsen({'x': 2}, func=np.mean, side='right', + boundary='trim') + expected = self.cls(['x'], [1.5, 3.5]) + assert_identical(actual, expected) + + # working test + v = self.cls(['x', 'y', 'z'], + np.arange(40 * 30 * 2).reshape(40, 30, 2)) + for windows, func, side, boundary in [ + ({'x': 2}, np.mean, 'left', 'trim'), + ({'x': 2}, np.median, {'x': 'left'}, 'pad'), + ({'x': 2, 'y': 3}, np.max, 'left', {'x': 'pad', 'y': 'trim'})]: + v.coarsen(windows, func, boundary, side) + + def test_coarsen_2d(self): + # 2d-mean should be the same with the successive 1d-mean + v = self.cls(['x', 'y'], np.arange(6 * 12).reshape(6, 12)) + actual = v.coarsen({'x': 3, 'y': 4}, func='mean') + expected = v.coarsen({'x': 3}, func='mean').coarsen( + {'y': 4}, func='mean') + assert_equal(actual, expected) + + v = self.cls(['x', 'y'], np.arange(7 * 12).reshape(7, 12)) + actual = v.coarsen({'x': 3, 'y': 4}, func='mean', boundary='trim') + expected = v.coarsen({'x': 3}, func='mean', boundary='trim').coarsen( + {'y': 4}, func='mean', boundary='trim') + assert_equal(actual, expected) + + # if there is nan, the two should be different + v = self.cls(['x', 'y'], 1.0 * np.arange(6 * 12).reshape(6, 12)) + v[2, 4] = np.nan + v[3, 5] = np.nan + actual = v.coarsen({'x': 3, 'y': 4}, func='mean', boundary='trim') + expected = v.coarsen({'x': 3}, func='sum', boundary='trim').coarsen( + {'y': 4}, func='sum', boundary='trim') / 12 + assert not actual.equals(expected) + # adjusting the nan count + expected[0, 1] *= 12 / 11 + expected[1, 1] *= 12 / 11 + assert_allclose(actual, expected) + @requires_dask class TestVariableWithDask(VariableSubclassobjects): @@ -1838,6 +1890,10 @@ def test_pad(self): def test_rolling_window(self): super(TestIndexVariable, self).test_rolling_window() + @pytest.mark.xfail + def test_coarsen_2d(self): + super(TestIndexVariable, self).test_coarsen_2d() + class TestAsCompatibleData(object): def test_unchanged_types(self): From 6963164dbdc55f86f34b741073838f083a68a152 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Mon, 7 Jan 2019 23:21:41 -0800 Subject: [PATCH 054/108] Type checking with mypy (#2655) * Type checking with mypy The rest of the scientific Python stack doesn't seem to support type annotations yet, but that's OK -- we can use this incrementally in xarray when it seems appropriate, and may check a few bugs. I'm especially excited to use this for internal functions, where we don't always bother with full docstrings (e.g., what is the type of the ``variables`` argument?). This includes: 1. various minor fixes to ensure that "mypy xarray" passes. 2. adding "mypy xarray" to our lint check on Travis-CI. For reference, see "Using mypy with an existing codebase": https://mypy.readthedocs.io/en/stable/existing_code.html Question: are we OK with (2)? This means Travis-CI will fail if your code causes mypy to error. * Lint fix * DOC: document mypy, don't run it in travis * document how to run mypy * fix type annotation * Pin pytest to avoid pytest-cov failure see https://github.com/pytest-dev/pytest-cov/pull/253 * Revert pytest pinning * Revert "Revert pytest pinning" This reverts commit cd187a64eb97ca917476046a2f33c2a995a18680. * Revert "Pin pytest to avoid pytest-cov failure" This reverts commit 87ba452fad10f9f3715edae12abb1f28153ce99c. --- ci/requirements-py36.yml | 3 +- ci/requirements-py37.yml | 1 + doc/contributing.rst | 24 +++++---- setup.cfg | 58 ++++++++++++++++++++++ xarray/backends/file_manager.py | 3 +- xarray/backends/locks.py | 3 +- xarray/coding/cftime_offsets.py | 9 ++-- xarray/coding/variables.py | 12 +++-- xarray/core/alignment.py | 2 +- xarray/core/common.py | 4 +- xarray/core/computation.py | 42 +++++++++------- xarray/core/dataarray.py | 3 +- xarray/core/dataset.py | 19 ++++--- xarray/core/dtypes.py | 23 --------- xarray/core/duck_array_ops.py | 12 ++--- xarray/core/groupby.py | 4 +- xarray/core/merge.py | 19 ++++--- xarray/core/missing.py | 5 +- xarray/core/utils.py | 2 +- xarray/core/variable.py | 18 ++++--- xarray/tests/__init__.py | 7 +-- xarray/tests/test_backends.py | 14 ++---- xarray/tests/test_backends_file_manager.py | 6 +-- xarray/tests/test_backends_lru_cache.py | 6 +-- xarray/tests/test_cftime_offsets.py | 2 +- xarray/tests/test_cftimeindex.py | 2 +- xarray/tests/test_dataset.py | 5 +- xarray/tests/test_extensions.py | 7 +-- 28 files changed, 179 insertions(+), 136 deletions(-) diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index 2986dc33adb..311e4a275a8 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -14,7 +14,7 @@ dependencies: - pytest-cov - pytest-env - coveralls - - flake8 + - pycodestyle - numpy - pandas - scipy @@ -32,3 +32,4 @@ dependencies: - lxml - pip: - cfgrib>=0.9.2 + - mypy==0.650 diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index afd18e37a75..1a98e6b285c 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -29,3 +29,4 @@ dependencies: - pydap - pip: - cfgrib>=0.9.2 + - mypy==0.650 diff --git a/doc/contributing.rst b/doc/contributing.rst index ceba81d9319..da9c89234a3 100644 --- a/doc/contributing.rst +++ b/doc/contributing.rst @@ -345,19 +345,26 @@ the more common ``PEP8`` issues: - passing arguments should have spaces after commas, e.g. ``foo(arg1, arg2, kw1='bar')`` :ref:`Continuous Integration ` will run -the `flake8 `_ tool +the `pycodestyle `_ tool and report any stylistic errors in your code. Therefore, it is helpful before submitting code to run the check yourself:: - flake8 + pycodestyle xarray -If you install `isort `_ and -`flake8-isort `_, this will also show -any errors from incorrectly sorted imports. These aren't currently enforced in -CI. To automatically sort imports, you can run:: +Other recommended but optional tools for checking code quality (not currently +enforced in CI): - isort -y +- `mypy `_ performs static type checking, which can + make it easier to catch bugs. Please run ``mypy xarray`` if you annotate any + code with `type hints `_. +- `flake8 `_ includes a few more automated + checks than those enforced by pycodestyle. +- `isort `_ will highlight + incorrectly sorted imports. ``isort -y`` will automatically fix them. See + also `flake8-isort `_. +Note that your code editor probably supports extensions that can show results +of these checks inline as you type. Backwards Compatibility ~~~~~~~~~~~~~~~~~~~~~~~ @@ -365,8 +372,7 @@ Backwards Compatibility Please try to maintain backward compatibility. *xarray* has growing number of users with lots of existing code, so don't break it if at all possible. If you think breakage is required, clearly state why as part of the pull request. Also, be careful when changing -method signatures and add deprecation warnings where needed. Also, add the deprecated -sphinx directive to the deprecated functions or methods. +method signatures and add deprecation warnings where needed. .. _contributing.ci: diff --git a/setup.cfg b/setup.cfg index 21ba5ee8dec..c80ff300a60 100644 --- a/setup.cfg +++ b/setup.cfg @@ -20,6 +20,64 @@ default_section=THIRDPARTY known_first_party=xarray multi_line_output=4 +# Most of the numerical computing stack doesn't have type annotations yet. +[mypy-bottleneck.*] +ignore_missing_imports = True +[mypy-cdms2.*] +ignore_missing_imports = True +[mypy-cf_units.*] +ignore_missing_imports = True +[mypy-cfgrib.*] +ignore_missing_imports = True +[mypy-cftime.*] +ignore_missing_imports = True +[mypy-dask.*] +ignore_missing_imports = True +[mypy-distributed.*] +ignore_missing_imports = True +[mypy-h5netcdf.*] +ignore_missing_imports = True +[mypy-h5py.*] +ignore_missing_imports = True +[mypy-iris.*] +ignore_missing_imports = True +[mypy-matplotlib.*] +ignore_missing_imports = True +[mypy-Nio.*] +ignore_missing_imports = True +[mypy-numpy.*] +ignore_missing_imports = True +[mypy-netCDF4.*] +ignore_missing_imports = True +[mypy-netcdftime.*] +ignore_missing_imports = True +[mypy-pandas.*] +ignore_missing_imports = True +[mypy-PseudoNetCDF.*] +ignore_missing_imports = True +[mypy-pydap.*] +ignore_missing_imports = True +[mypy-pytest.*] +ignore_missing_imports = True +[mypy-rasterio.*] +ignore_missing_imports = True +[mypy-scipy.*] +ignore_missing_imports = True +[mypy-seaborn.*] +ignore_missing_imports = True +[mypy-toolz.*] +ignore_missing_imports = True +[mypy-zarr.*] +ignore_missing_imports = True + +# written by versioneer +[mypy-xarray._version] +ignore_errors = True +# version spanning code is hard to type annotate (and most of this module will +# be going away soon anyways) +[mypy-xarray.core.pycompat] +ignore_errors = True + [versioneer] VCS = git style = pep440 diff --git a/xarray/backends/file_manager.py b/xarray/backends/file_manager.py index d329f9e734f..d0efba86bf9 100644 --- a/xarray/backends/file_manager.py +++ b/xarray/backends/file_manager.py @@ -1,5 +1,6 @@ import contextlib import threading +from typing import Any, Dict import warnings from ..core import utils @@ -13,7 +14,7 @@ assert FILE_CACHE.maxsize, 'file cache must be at least size one' -REF_COUNTS = {} +REF_COUNTS = {} # type: Dict[Any, int] _DEFAULT_MODE = utils.ReprObject('') diff --git a/xarray/backends/locks.py b/xarray/backends/locks.py index 6c135fd1240..bca27a0bbc1 100644 --- a/xarray/backends/locks.py +++ b/xarray/backends/locks.py @@ -1,5 +1,6 @@ import multiprocessing import threading +from typing import Any, MutableMapping import weakref try: @@ -20,7 +21,7 @@ NETCDFC_LOCK = SerializableLock() -_FILE_LOCKS = weakref.WeakValueDictionary() +_FILE_LOCKS = weakref.WeakValueDictionary() # type: MutableMapping[Any, threading.Lock] # noqa def _get_threaded_lock(key): diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index f8e1cfa6718..98571c9a995 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -43,6 +43,7 @@ import re from datetime import timedelta from functools import partial +from typing import ClassVar, Optional import numpy as np @@ -74,7 +75,7 @@ def get_date_type(calendar): class BaseCFTimeOffset(object): - _freq = None + _freq = None # type: ClassVar[str] def __init__(self, n=1): if not isinstance(n, int): @@ -254,9 +255,9 @@ def onOffset(self, date): class YearOffset(BaseCFTimeOffset): - _freq = None - _day_option = None - _default_month = None + _freq = None # type: ClassVar[str] + _day_option = None # type: ClassVar[str] + _default_month = None # type: ClassVar[int] def __init__(self, n=1, month=None): BaseCFTimeOffset.__init__(self, n) diff --git a/xarray/coding/variables.py b/xarray/coding/variables.py index d5963b0e94f..d8453a95fad 100644 --- a/xarray/coding/variables.py +++ b/xarray/coding/variables.py @@ -1,6 +1,7 @@ """Coders for individual Variable objects.""" from __future__ import absolute_import, division, print_function +from typing import Any import warnings from functools import partial @@ -126,11 +127,12 @@ def pop_to(source, dest, key, name=None): return value -def _apply_mask(data, # type: np.ndarray - encoded_fill_values, # type: list - decoded_fill_value, # type: Any - dtype, # type: Any - ): # type: np.ndarray +def _apply_mask( + data: np.ndarray, + encoded_fill_values: list, + decoded_fill_value: Any, + dtype: Any, +) -> np.ndarray: """Mask all matching values in a NumPy arrays.""" data = np.asarray(data, dtype=dtype) condition = False diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index 33902abaf3e..789bea90b55 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -31,7 +31,7 @@ def _get_joiner(join): raise ValueError('invalid value for join: %s' % join) -_DEFAULT_EXCLUDE = frozenset() +_DEFAULT_EXCLUDE = frozenset() # type: frozenset def align(*objects, **kwargs): diff --git a/xarray/core/common.py b/xarray/core/common.py index 923d30aad11..d272115f492 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -24,7 +24,7 @@ def wrapped_func(self, dim=None, axis=None, skipna=None, return self.reduce(func, dim, axis, skipna=skipna, allow_lazy=True, **kwargs) else: - def wrapped_func(self, dim=None, axis=None, + def wrapped_func(self, dim=None, axis=None, # type: ignore **kwargs): return self.reduce(func, dim, axis, allow_lazy=True, **kwargs) @@ -56,7 +56,7 @@ def wrapped_func(self, dim=None, skipna=None, numeric_only=numeric_only, allow_lazy=True, **kwargs) else: - def wrapped_func(self, dim=None, **kwargs): + def wrapped_func(self, dim=None, **kwargs): # type: ignore return self.reduce(func, dim, numeric_only=numeric_only, allow_lazy=True, **kwargs) diff --git a/xarray/core/computation.py b/xarray/core/computation.py index 7998cc4f72f..bf9ab56bbb4 100644 --- a/xarray/core/computation.py +++ b/xarray/core/computation.py @@ -8,6 +8,10 @@ import operator from collections import Counter from distutils.version import LooseVersion +from typing import ( + AbstractSet, Any, Dict, Iterable, List, Mapping, Union, Tuple, + TYPE_CHECKING, TypeVar +) import numpy as np @@ -16,8 +20,11 @@ from .merge import expand_and_merge_variables from .pycompat import OrderedDict, basestring, dask_array_type from .utils import is_dict_like +from .variable import Variable +if TYPE_CHECKING: + from .dataset import Dataset -_DEFAULT_FROZEN_SET = frozenset() +_DEFAULT_FROZEN_SET = frozenset() # type: frozenset _NO_FILL_VALUE = utils.ReprObject('') _DEFAULT_NAME = utils.ReprObject('') _JOINS_WITHOUT_FILL_VALUES = frozenset({'inner', 'exact'}) @@ -111,8 +118,7 @@ def to_gufunc_string(self): return str(alt_signature) -def result_name(objects): - # type: List[object] -> Any +def result_name(objects: list) -> Any: # use the same naming heuristics as pandas: # https://github.com/blaze/blaze/issues/458#issuecomment-51936356 names = {getattr(obj, 'name', _DEFAULT_NAME) for obj in objects} @@ -138,10 +144,10 @@ def _get_coord_variables(args): def build_output_coords( - args, # type: list - signature, # type: _UFuncSignature - exclude_dims=frozenset(), # type: set -): + args: list, + signature: _UFuncSignature, + exclude_dims: AbstractSet = frozenset(), +) -> 'List[OrderedDict[Any, Variable]]': """Build output coordinates for an operation. Parameters @@ -159,7 +165,6 @@ def build_output_coords( ------- OrderedDict of Variable objects with merged coordinates. """ - # type: (...) -> List[OrderedDict[Any, Variable]] input_coords = _get_coord_variables(args) if exclude_dims: @@ -220,8 +225,7 @@ def apply_dataarray_ufunc(func, *args, **kwargs): return out -def ordered_set_union(all_keys): - # type: List[Iterable] -> Iterable +def ordered_set_union(all_keys: List[Iterable]) -> Iterable: result_dict = OrderedDict() for keys in all_keys: for key in keys: @@ -229,8 +233,7 @@ def ordered_set_union(all_keys): return result_dict.keys() -def ordered_set_intersection(all_keys): - # type: List[Iterable] -> Iterable +def ordered_set_intersection(all_keys: List[Iterable]) -> Iterable: intersection = set(all_keys[0]) for keys in all_keys[1:]: intersection.intersection_update(keys) @@ -284,9 +287,9 @@ def _as_variables_or_variable(arg): def _unpack_dict_tuples( result_vars, # type: Mapping[Any, Tuple[Variable]] - num_outputs, # type: int + num_outputs, # type: int ): - # type: (...) -> Tuple[Dict[Any, Variable]] + # type: (...) -> Tuple[Dict[Any, Variable], ...] out = tuple(OrderedDict() for _ in range(num_outputs)) for name, values in result_vars.items(): for value, results_dict in zip(values, out): @@ -438,8 +441,11 @@ def apply_groupby_ufunc(func, *args): return combined -def unified_dim_sizes(variables, exclude_dims=frozenset()): - # type: Iterable[Variable] -> OrderedDict[Any, int] +def unified_dim_sizes( + variables: Iterable[Variable], + exclude_dims: AbstractSet = frozenset(), +) -> 'OrderedDict[Any, int]': + dim_sizes = OrderedDict() for var in variables: @@ -460,11 +466,9 @@ def unified_dim_sizes(variables, exclude_dims=frozenset()): SLICE_NONE = slice(None) -# A = TypeVar('A', numpy.ndarray, dask.array.Array) - def broadcast_compat_data(variable, broadcast_dims, core_dims): - # type: (Variable[A], tuple, tuple) -> A + # type: (Variable, tuple, tuple) -> Any data = variable.data old_dims = variable.dims diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index a63b63b45bf..f27958b1c77 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -771,7 +771,8 @@ def __deepcopy__(self, memo=None): return self.copy(deep=True) # mutable objects should not be hashable - __hash__ = None + # https://github.com/python/mypy/issues/4266 + __hash__ = None # type: ignore @property def chunks(self): diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 29178c9b13c..2caf45ce954 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -6,6 +6,7 @@ from collections import Mapping, defaultdict from distutils.version import LooseVersion from numbers import Number +from typing import Any, Dict, List, Set, Tuple, Union import numpy as np import pandas as pd @@ -124,14 +125,14 @@ def merge_indexes( Not public API. Used in Dataset and DataArray set_index methods. """ - vars_to_replace = {} - vars_to_remove = [] + vars_to_replace = {} # Dict[Any, Variable] + vars_to_remove = [] # type: list for dim, var_names in indexes.items(): if isinstance(var_names, basestring): var_names = [var_names] - names, labels, levels = [], [], [] + names, labels, levels = [], [], [] # type: (list, list, list) current_index_variable = variables.get(dim) for n in var_names: @@ -195,7 +196,7 @@ def split_indexes( if isinstance(dims_or_levels, basestring): dims_or_levels = [dims_or_levels] - dim_levels = defaultdict(list) + dim_levels = defaultdict(list) # type: Dict[Any, list] dims = [] for k in dims_or_levels: if k in level_coords: @@ -1005,7 +1006,8 @@ def __delitem__(self, key): self._coord_names.discard(key) # mutable objects should not be hashable - __hash__ = None + # https://github.com/python/mypy/issues/4266 + __hash__ = None # type: ignore def _all_compat(self, other, compat_str): """Helper function for equals and identical""" @@ -1683,7 +1685,8 @@ def relevant_keys(mapping): if any(d in indexer_dims for d in v.dims)] coords = relevant_keys(self.coords) - indexers = [(k, np.asarray(v)) for k, v in iteritems(indexers)] + indexers = [(k, np.asarray(v)) # type: ignore + for k, v in iteritems(indexers)] indexers_dict = dict(indexers) non_indexed_dims = set(self.dims) - indexer_dims non_indexed_coords = set(self.coords) - set(coords) @@ -1693,9 +1696,9 @@ def relevant_keys(mapping): for k, v in indexers: if k not in self.dims: raise ValueError("dimension %s does not exist" % k) - if v.dtype.kind != 'i': + if v.dtype.kind != 'i': # type: ignore raise TypeError('Indexers must be integers') - if v.ndim != 1: + if v.ndim != 1: # type: ignore raise ValueError('Indexers must be 1 dimensional') # all the indexers should have the same length diff --git a/xarray/core/dtypes.py b/xarray/core/dtypes.py index a2f11728b4d..00ff7958183 100644 --- a/xarray/core/dtypes.py +++ b/xarray/core/dtypes.py @@ -42,29 +42,6 @@ def __eq__(self, other): ] -@functools.total_ordering -class AlwaysGreaterThan(object): - def __gt__(self, other): - return True - - def __eq__(self, other): - return isinstance(other, type(self)) - - -@functools.total_ordering -class AlwaysLessThan(object): - def __lt__(self, other): - return True - - def __eq__(self, other): - return isinstance(other, type(self)) - - -# Equivalence to np.inf (-np.inf) for object-type -INF = AlwaysGreaterThan() -NINF = AlwaysLessThan() - - def maybe_promote(dtype): """Simpler equivalent of pandas.core.common._maybe_promote diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index b02eb4e899b..54fd8881a56 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -6,9 +6,9 @@ from __future__ import absolute_import, division, print_function import contextlib +from functools import partial import inspect import warnings -from functools import partial import numpy as np import pandas as pd @@ -21,8 +21,8 @@ import dask.array as dask_array from . import dask_array_compat except ImportError: - dask_array = None - dask_array_compat = None + dask_array = None # type: ignore + dask_array_compat = None # type: ignore def _dask_or_eager_func(name, eager_module=np, dask_module=dask_array, @@ -43,10 +43,10 @@ def f(*args, **kwargs): (e, requires_dask)) else: wrapped = getattr(eager_module, name) - return wrapped(*args, ** kwargs) + return wrapped(*args, **kwargs) else: - def f(data, *args, **kwargs): - return getattr(eager_module, name)(data, *args, **kwargs) + def f(*args, **kwargs): + return getattr(eager_module, name)(*args, **kwargs) return f diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index ec8329d6805..aa8ced5adab 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -630,7 +630,7 @@ def wrapped_func(self, dim=DEFAULT_DIMS, axis=None, skipna=None, return self.reduce(func, dim, axis, keep_attrs=keep_attrs, skipna=skipna, allow_lazy=True, **kwargs) else: - def wrapped_func(self, dim=DEFAULT_DIMS, axis=None, + def wrapped_func(self, dim=DEFAULT_DIMS, axis=None, # type: ignore keep_attrs=None, **kwargs): return self.reduce(func, dim, axis, keep_attrs=keep_attrs, allow_lazy=True, **kwargs) @@ -748,7 +748,7 @@ def wrapped_func(self, dim=DEFAULT_DIMS, skipna=skipna, numeric_only=numeric_only, allow_lazy=True, **kwargs) else: - def wrapped_func(self, dim=DEFAULT_DIMS, + def wrapped_func(self, dim=DEFAULT_DIMS, # type: ignore **kwargs): return self.reduce(func, dim, numeric_only=numeric_only, allow_lazy=True, diff --git a/xarray/core/merge.py b/xarray/core/merge.py index 2a5e7acbb25..637a9cbda7f 100644 --- a/xarray/core/merge.py +++ b/xarray/core/merge.py @@ -1,11 +1,18 @@ from __future__ import absolute_import, division, print_function +from typing import ( + Any, Dict, List, Mapping, Optional, Set, Tuple, TYPE_CHECKING, Union, +) + import pandas as pd from .alignment import deep_align from .pycompat import OrderedDict, basestring from .utils import Frozen -from .variable import as_variable, assert_unique_multiindex_level_names +from .variable import ( + Variable, as_variable, assert_unique_multiindex_level_names) +if TYPE_CHECKING: + from .dataset import Dataset PANDAS_TYPES = (pd.Series, pd.DataFrame, pd.Panel) @@ -145,13 +152,13 @@ def merge_variables( # variables appear merged = OrderedDict() - for name, variables in lookup.items(): + for name, var_list in lookup.items(): if name in priority_vars: # one of these arguments (e.g., the first for in-place arithmetic # or the second for Dataset.update) takes priority merged[name] = priority_vars[name] else: - dim_variables = [var for var in variables if (name,) == var.dims] + dim_variables = [var for var in var_list if (name,) == var.dims] if dim_variables: # if there are dimension coordinates, these must be equal (or # identical), and they take priority over non-dimension @@ -159,7 +166,7 @@ def merge_variables( merged[name] = unique_variable(name, dim_variables, dim_compat) else: try: - merged[name] = unique_variable(name, variables, compat) + merged[name] = unique_variable(name, var_list, compat) except MergeError: if compat != 'minimal': # we need more than "minimal" compatibility (for which @@ -236,8 +243,8 @@ def determine_coords(list_of_variable_dicts): from .dataarray import DataArray from .dataset import Dataset - coord_names = set() - noncoord_names = set() + coord_names = set() # type: set + noncoord_names = set() # type: set for variables in list_of_variable_dicts: if isinstance(variables, Dataset): diff --git a/xarray/core/missing.py b/xarray/core/missing.py index 5624d9b5092..ff0e63801bc 100644 --- a/xarray/core/missing.py +++ b/xarray/core/missing.py @@ -3,6 +3,7 @@ import warnings from collections import Iterable from functools import partial +from typing import Any, Dict import numpy as np import pandas as pd @@ -18,8 +19,8 @@ class BaseInterpolator(object): '''gerneric interpolator class for normalizing interpolation methods''' - cons_kwargs = {} - call_kwargs = {} + cons_kwargs = {} # type: Dict[str, Any] + call_kwargs = {} # type: Dict[str, Any] f = None method = None diff --git a/xarray/core/utils.py b/xarray/core/utils.py index e961426195e..085eaaa5ed1 100644 --- a/xarray/core/utils.py +++ b/xarray/core/utils.py @@ -488,7 +488,7 @@ def __repr__(self): class ReprObject(object): """Object that prints as the given value, for use with sentinel values.""" - def __init__(self, value): # type: str + def __init__(self, value: str): self._value = value def __repr__(self): diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 48acc8edff9..8bd7225efc3 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -4,6 +4,7 @@ import itertools from collections import defaultdict from datetime import timedelta +from typing import Tuple, Type import numpy as np import pandas as pd @@ -28,7 +29,8 @@ NON_NUMPY_SUPPORTED_ARRAY_TYPES = ( indexing.ExplicitlyIndexed, pd.Index) + dask_array_type -BASIC_INDEXING_TYPES = integer_types + (slice,) +# https://github.com/python/mypy/issues/224 +BASIC_INDEXING_TYPES = integer_types + (slice,) # type: ignore class MissingDimensionsError(ValueError): @@ -414,6 +416,10 @@ def dims(self): """ return self._dims + @dims.setter + def dims(self, value): + self._dims = self._parse_dimensions(value) + def _parse_dimensions(self, dims): if isinstance(dims, basestring): dims = (dims,) @@ -424,10 +430,6 @@ def _parse_dimensions(self, dims): % (dims, self.ndim)) return dims - @dims.setter - def dims(self, value): - self._dims = self._parse_dimensions(value) - def _item_key_to_tuple(self, key): if utils.is_dict_like(key): return tuple(key.get(dim, slice(None)) for dim in self.dims) @@ -816,7 +818,8 @@ def __deepcopy__(self, memo=None): return self.copy(deep=True) # mutable objects should not be hashable - __hash__ = None + # https://github.com/python/mypy/issues/4266 + __hash__ = None # type: ignore @property def chunks(self): @@ -1801,7 +1804,8 @@ def load(self): # data is already loaded into memory for IndexVariable return self - @Variable.data.setter + # https://github.com/python/mypy/issues/1465 + @Variable.data.setter # type: ignore def data(self, data): Variable.data.fset(self, data) if not isinstance(self._data, PandasIndexAdapter): diff --git a/xarray/tests/__init__.py b/xarray/tests/__init__.py index 52345396ffa..58f76596822 100644 --- a/xarray/tests/__init__.py +++ b/xarray/tests/__init__.py @@ -6,6 +6,7 @@ from distutils import version import re import importlib +from unittest import mock import numpy as np from numpy.testing import assert_array_equal # noqa: F401 @@ -25,12 +26,6 @@ # old location, for pandas < 0.20 from pandas.util.testing import assert_frame_equal # noqa: F401 - -try: - from unittest import mock -except ImportError: - import mock # noqa: F401 - # import mpl and change the backend before other mpl imports try: import matplotlib as mpl diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 57e875bb563..d3c8599b21b 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -4,10 +4,12 @@ import itertools import math import os.path +from pathlib import Path import pickle import shutil import sys import tempfile +from typing import Optional import warnings from io import BytesIO @@ -47,14 +49,6 @@ except ImportError: pass -try: - from pathlib import Path -except ImportError: - try: - from pathlib2 import Path - except ImportError: - pass - ON_WINDOWS = sys.platform == 'win32' @@ -172,8 +166,8 @@ class NetCDF3Only(object): class DatasetIOBase(object): - engine = None - file_format = None + engine = None # type: Optional[str] + file_format = None # type: Optional[str] def create_store(self): raise NotImplementedError diff --git a/xarray/tests/test_backends_file_manager.py b/xarray/tests/test_backends_file_manager.py index 9c4c1cf815c..4405454e216 100644 --- a/xarray/tests/test_backends_file_manager.py +++ b/xarray/tests/test_backends_file_manager.py @@ -1,6 +1,7 @@ import gc import pickle import threading +from unittest import mock import pytest @@ -8,11 +9,6 @@ from xarray.backends.lru_cache import LRUCache from xarray.core.options import set_options -try: - from unittest import mock -except ImportError: - import mock # noqa: F401 - @pytest.fixture(params=[1, 2, 3, None]) def file_cache(request): diff --git a/xarray/tests/test_backends_lru_cache.py b/xarray/tests/test_backends_lru_cache.py index 03eb6dcf208..d64d718f2f7 100644 --- a/xarray/tests/test_backends_lru_cache.py +++ b/xarray/tests/test_backends_lru_cache.py @@ -1,8 +1,4 @@ -try: - from unittest import mock -except ImportError: - import mock # noqa: F401 - +from unittest import mock import pytest from xarray.backends.lru_cache import LRUCache diff --git a/xarray/tests/test_cftime_offsets.py b/xarray/tests/test_cftime_offsets.py index dfb46df21e3..b9d2cf520a8 100644 --- a/xarray/tests/test_cftime_offsets.py +++ b/xarray/tests/test_cftime_offsets.py @@ -141,7 +141,7 @@ def test_to_offset_sub_annual(freq, expected): @pytest.mark.parametrize(('month_int', 'month_label'), - list(_MONTH_ABBREVIATIONS.items()) + [('', '')]) + list(_MONTH_ABBREVIATIONS.items()) + [(0, '')]) @pytest.mark.parametrize('multiple', [None, 2]) @pytest.mark.parametrize('offset_str', ['AS', 'A']) def test_to_offset_annual(month_label, month_int, multiple, offset_str): diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 271cacb5ca0..3c4fc67c5eb 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -384,7 +384,7 @@ def test_resample_error(da): SEL_STRING_OR_LIST_TESTS = { 'string': '0001', - 'string-slice': slice('0001-01-01', '0001-12-30'), + 'string-slice': slice('0001-01-01', '0001-12-30'), # type: ignore 'bool-list': [True, True, False, False] } diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index e7e091efa4c..e55caf1bf13 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -5,6 +5,7 @@ import warnings from copy import copy, deepcopy from io import StringIO +import pickle from textwrap import dedent import numpy as np @@ -26,10 +27,6 @@ raises_regex, requires_bottleneck, requires_dask, requires_scipy, source_ndarray) -try: - import cPickle as pickle -except ImportError: - import pickle try: import dask.array as da except ImportError: diff --git a/xarray/tests/test_extensions.py b/xarray/tests/test_extensions.py index ffefa78aa34..608ec798ca1 100644 --- a/xarray/tests/test_extensions.py +++ b/xarray/tests/test_extensions.py @@ -1,16 +1,13 @@ from __future__ import absolute_import, division, print_function +import pickle + import pytest import xarray as xr from . import raises_regex -try: - import cPickle as pickle -except ImportError: - import pickle - @xr.register_dataset_accessor('example_accessor') @xr.register_dataarray_accessor('example_accessor') From 6795fd06a70b0e7e5b748e2ad8d17d980a5f6b8e Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Tue, 8 Jan 2019 10:33:59 -0800 Subject: [PATCH 055/108] Remove broken Travis-CI builds (#2661) * Remove broken Travis-CI builds Remove the optional condaforge-rc, netcdf4-dev and pynio-dev builds. These have been continuously failing (due to broken installs), so we shouldn't waste time/energy running them. * Install latest miniconda * Make appveyor default to python 3 miniconda --- .travis.yml | 19 +----------------- ci/install_python.ps1 | 8 ++++---- ci/requirements-py35.yml | 2 +- ci/requirements-py36-bottleneck-dev.yml | 2 +- ci/requirements-py36-condaforge-rc.yml | 23 ---------------------- ci/requirements-py36-dask-dev.yml | 2 +- ci/requirements-py36-hypothesis.yml | 2 +- ci/requirements-py36-netcdf4-dev.yml | 23 ---------------------- ci/requirements-py36-pandas-dev.yml | 2 +- ci/requirements-py36-pynio-dev.yml | 26 ------------------------- ci/requirements-py36-rasterio.yml | 2 +- ci/requirements-py36-zarr-dev.yml | 2 +- 12 files changed, 12 insertions(+), 101 deletions(-) delete mode 100644 ci/requirements-py36-condaforge-rc.yml delete mode 100644 ci/requirements-py36-netcdf4-dev.yml delete mode 100644 ci/requirements-py36-pynio-dev.yml diff --git a/.travis.yml b/.travis.yml index 337447dbf69..8e1866de8d4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,17 +17,9 @@ matrix: - env: - CONDA_ENV=py36 - EXTRA_FLAGS="--run-flaky --run-network-tests" - - env: CONDA_ENV=py36-netcdf4-dev - addons: - apt_packages: - - libhdf5-serial-dev - - netcdf-bin - - libnetcdf-dev - env: CONDA_ENV=py36-dask-dev - env: CONDA_ENV=py36-pandas-dev - env: CONDA_ENV=py36-bottleneck-dev - - env: CONDA_ENV=py36-condaforge-rc - - env: CONDA_ENV=py36-pynio-dev - env: CONDA_ENV=py36-rasterio - env: CONDA_ENV=py36-zarr-dev - env: CONDA_ENV=docs @@ -38,25 +30,16 @@ matrix: - env: - CONDA_ENV=py36 - EXTRA_FLAGS="--run-flaky --run-network-tests" - - env: CONDA_ENV=py36-netcdf4-dev - addons: - apt_packages: - - libhdf5-serial-dev - - netcdf-bin - - libnetcdf-dev - env: CONDA_ENV=py36-pandas-dev - env: CONDA_ENV=py36-bottleneck-dev - - env: CONDA_ENV=py36-condaforge-rc - - env: CONDA_ENV=py36-pynio-dev - env: CONDA_ENV=py36-zarr-dev before_install: - - wget http://repo.continuum.io/miniconda/Miniconda3-3.16.0-Linux-x86_64.sh -O miniconda.sh; + - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh; - bash miniconda.sh -b -p $HOME/miniconda - export PATH="$HOME/miniconda/bin:$PATH" - hash -r - conda config --set always_yes yes --set changeps1 no --set show_channel_urls true - - conda update -q conda - conda info -a install: diff --git a/ci/install_python.ps1 b/ci/install_python.ps1 index 63c476e65e5..e9cfae01bde 100644 --- a/ci/install_python.ps1 +++ b/ci/install_python.ps1 @@ -2,16 +2,16 @@ # Authors: Olivier Grisel, Jonathan Helmus and Kyle Kastner # License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/ -$MINICONDA_URL = "http://repo.continuum.io/miniconda/" +$MINICONDA_URL = "https://repo.anaconda.com/miniconda/" $BASE_URL = "https://www.python.org/ftp/python/" function DownloadMiniconda ($python_version, $platform_suffix) { $webclient = New-Object System.Net.WebClient - if ($python_version -match "3.6") { - $filename = "Miniconda3-latest-Windows-" + $platform_suffix + ".exe" - } else { + if ($python_version -match "2.7") { $filename = "Miniconda2-latest-Windows-" + $platform_suffix + ".exe" + } else { + $filename = "Miniconda3-latest-Windows-" + $platform_suffix + ".exe" } $url = $MINICONDA_URL + $filename diff --git a/ci/requirements-py35.yml b/ci/requirements-py35.yml index 29f4bb020fc..a71434865cc 100644 --- a/ci/requirements-py35.yml +++ b/ci/requirements-py35.yml @@ -10,8 +10,8 @@ dependencies: - matplotlib=1.5 - netcdf4 - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - flake8 - numpy diff --git a/ci/requirements-py36-bottleneck-dev.yml b/ci/requirements-py36-bottleneck-dev.yml index bdf0349b5c0..3f08648be32 100644 --- a/ci/requirements-py36-bottleneck-dev.yml +++ b/ci/requirements-py36-bottleneck-dev.yml @@ -11,8 +11,8 @@ dependencies: - matplotlib - netcdf4 - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - flake8 - numpy diff --git a/ci/requirements-py36-condaforge-rc.yml b/ci/requirements-py36-condaforge-rc.yml deleted file mode 100644 index ba980deeeea..00000000000 --- a/ci/requirements-py36-condaforge-rc.yml +++ /dev/null @@ -1,23 +0,0 @@ -name: test_env -channels: - - conda-forge/label/rc - - conda-forge -dependencies: - - python=3.6 - - cftime - - dask - - distributed - - h5py - - h5netcdf - - matplotlib - - netcdf4 - - pytest - - pytest-env - - pytest-cov - - coveralls - - flake8 - - numpy - - pandas - - seaborn - - scipy - - toolz diff --git a/ci/requirements-py36-dask-dev.yml b/ci/requirements-py36-dask-dev.yml index 20b10fe29ee..32d01765439 100644 --- a/ci/requirements-py36-dask-dev.yml +++ b/ci/requirements-py36-dask-dev.yml @@ -9,8 +9,8 @@ dependencies: - matplotlib - netcdf4 - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - flake8 - numpy diff --git a/ci/requirements-py36-hypothesis.yml b/ci/requirements-py36-hypothesis.yml index c5c228095a4..8066a53b6bc 100644 --- a/ci/requirements-py36-hypothesis.yml +++ b/ci/requirements-py36-hypothesis.yml @@ -10,8 +10,8 @@ dependencies: - matplotlib - netcdf4 - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - hypothesis - flake8 diff --git a/ci/requirements-py36-netcdf4-dev.yml b/ci/requirements-py36-netcdf4-dev.yml deleted file mode 100644 index 2616a113fa4..00000000000 --- a/ci/requirements-py36-netcdf4-dev.yml +++ /dev/null @@ -1,23 +0,0 @@ -name: test_env -channels: - - conda-forge -dependencies: - - python=3.6 - - cython - - dask - - distributed - - h5py - - h5netcdf - - matplotlib - - pytest - - pytest-env - - pytest-cov - - coveralls - - flake8 - - numpy - - pandas - - scipy - - toolz - - pip: - - git+https://github.com/Unidata/netcdf4-python.git - - git+https://github.com/Unidata/cftime.git diff --git a/ci/requirements-py36-pandas-dev.yml b/ci/requirements-py36-pandas-dev.yml index 2b914f746ab..bc0e5d0de09 100644 --- a/ci/requirements-py36-pandas-dev.yml +++ b/ci/requirements-py36-pandas-dev.yml @@ -12,8 +12,8 @@ dependencies: - matplotlib - netcdf4 - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - flake8 - numpy diff --git a/ci/requirements-py36-pynio-dev.yml b/ci/requirements-py36-pynio-dev.yml deleted file mode 100644 index b8987611a6e..00000000000 --- a/ci/requirements-py36-pynio-dev.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: test_env -channels: - - conda-forge - - conda-forge/label/dev -dependencies: - - python=3.6 - - cftime - - dask - - distributed - - h5py - - h5netcdf - - matplotlib - - netcdf4 - - pynio=dev - - pytest - - pytest-env - - pytest-cov - - coveralls - - numpy - - pandas - - scipy - - seaborn - - toolz - - rasterio - - bottleneck - - pydap diff --git a/ci/requirements-py36-rasterio.yml b/ci/requirements-py36-rasterio.yml index dda9ea8cd29..e5ef1d29777 100644 --- a/ci/requirements-py36-rasterio.yml +++ b/ci/requirements-py36-rasterio.yml @@ -11,8 +11,8 @@ dependencies: - matplotlib - netcdf4 - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - numpy - pandas diff --git a/ci/requirements-py36-zarr-dev.yml b/ci/requirements-py36-zarr-dev.yml index 9966cf74815..94bdc50fbfe 100644 --- a/ci/requirements-py36-zarr-dev.yml +++ b/ci/requirements-py36-zarr-dev.yml @@ -8,8 +8,8 @@ dependencies: - distributed - matplotlib - pytest - - pytest-env - pytest-cov + - pytest-env - coveralls - flake8 - numpy From d4c46829b283ab7e7b7db8b86dae77861ce68f3c Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Thu, 10 Jan 2019 17:06:10 -0800 Subject: [PATCH 056/108] DOC: refresh "Why xarray" and shorten top-level description (#2657) * DOC: refresh "Why xarray" and shorten top-level description This documentation revamp builds upon rabernat's rewrite in GH2430. The main change is that the three paragraph description felt too long to me, so I moved the background paragraph on multi-dimensional arrays into the next section, on "Why xarray". I also ended up rewriting most of that page, and made a few adjustments to the FAQ and related projects pages. * 'why xarray' in setup.py, too * Updates per review --- README.rst | 84 ++++++++++++---------------------------- doc/faq.rst | 14 ++++--- doc/index.rst | 30 ++++++-------- doc/related-projects.rst | 18 ++++++--- doc/why-xarray.rst | 76 ++++++++++++++++++++++-------------- setup.py | 51 ++++++++++++++++-------- 6 files changed, 139 insertions(+), 134 deletions(-) diff --git a/README.rst b/README.rst index a4c8f6d200b..f30d9dde8bb 100644 --- a/README.rst +++ b/README.rst @@ -9,49 +9,47 @@ xarray: N-D labeled arrays and datasets :target: https://coveralls.io/r/pydata/xarray .. image:: https://readthedocs.org/projects/xray/badge/?version=latest :target: http://xarray.pydata.org/ -.. image:: https://img.shields.io/pypi/v/xarray.svg - :target: https://pypi.python.org/pypi/xarray/ -.. image:: https://zenodo.org/badge/13221727.svg - :target: https://zenodo.org/badge/latestdoi/13221727 .. image:: http://img.shields.io/badge/benchmarked%20by-asv-green.svg?style=flat :target: http://pandas.pydata.org/speed/xarray/ -.. image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A - :target: http://numfocus.org +.. image:: https://img.shields.io/pypi/v/xarray.svg + :target: https://pypi.python.org/pypi/xarray/ **xarray** (formerly **xray**) is an open source project and Python package that makes working with labelled multi-dimensional arrays simple, efficient, and fun! -Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called -"tensors") are an essential part of computational science. -They are encountered in a wide range of fields, including physics, astronomy, -geoscience, bioinformatics, engineering, finance, and deep learning. -In Python, NumPy_ provides the fundamental data structure and API for -working with raw ND arrays. -However, real-world datasets are usually more than just raw numbers; -they have labels which encode information about how the array values map -to locations in space, time, etc. +Xarray introduces labels in the form of dimensions, coordinates and +attributes on top of raw NumPy_-like arrays, which allows for a more +intuitive, more concise, and less error-prone developer experience. +The package includes a large and growing library of domain-agnostic functions +for advanced analytics and visualization with these data structures. -By introducing *dimensions*, *coordinates*, and *attributes* on top of raw -NumPy-like arrays, xarray is able to understand these labels and use them to -provide a more intuitive, more concise, and less error-prone experience. -Xarray also provides a large and growing library of functions for advanced -analytics and visualization with these data structures. Xarray was inspired by and borrows heavily from pandas_, the popular data analysis package focused on labelled tabular data. -Xarray can read and write data from most common labeled ND-array storage -formats and is particularly tailored to working with netCDF_ files, which were -the source of xarray's data model. +It is particularly tailored to working with netCDF_ files, which were the +source of xarray's data model, and integrates tightly with dask_ for parallel +computing. -.. _NumPy: http://www.numpy.org/ +.. _NumPy: http://www.numpy.org .. _pandas: http://pandas.pydata.org +.. _dask: http://dask.org .. _netCDF: http://www.unidata.ucar.edu/software/netcdf Why xarray? ----------- -Adding dimensions names and coordinate indexes to numpy's ndarray_ makes many -powerful array operations possible: +Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called +"tensors") are an essential part of computational science. +They are encountered in a wide range of fields, including physics, astronomy, +geoscience, bioinformatics, engineering, finance, and deep learning. +In Python, NumPy_ provides the fundamental data structure and API for +working with raw ND arrays. +However, real-world datasets are usually more than just raw numbers; +they have labels which encode information about how the array values map +to locations in space, time, etc. + +Xarray doesn't just keep track of labels on arrays -- it uses them to provide a +powerful and concise interface. For example: - Apply operations over dimensions by name: ``x.sum('time')``. - Select values by label instead of integer location: @@ -65,42 +63,10 @@ powerful array operations possible: - Keep track of arbitrary metadata in the form of a Python dictionary: ``x.attrs``. -pandas_ provides many of these features, but it does not make use of dimension -names, and its core data structures are fixed dimensional arrays. - -Why isn't pandas enough? ------------------------- - -pandas_ excels at working with tabular data. That suffices for many statistical -analyses, but physical scientists rely on N-dimensional arrays -- which is -where xarray comes in. - -xarray aims to provide a data analysis toolkit as powerful as pandas_ but -designed for working with homogeneous N-dimensional arrays -instead of tabular data. When possible, we copy the pandas API and rely on -pandas's highly optimized internals (in particular, for fast indexing). - -Why netCDF? ------------ - -Because xarray implements the same data model as the netCDF_ file format, -xarray datasets have a natural and portable serialization format. But it is also -easy to robustly convert an xarray ``DataArray`` to and from a numpy ``ndarray`` -or a pandas ``DataFrame`` or ``Series``, providing compatibility with the full -`PyData ecosystem `__. - -Our target audience is anyone who needs N-dimensional labeled arrays, but we -are particularly focused on the data analysis needs of physical scientists -- -especially geoscientists who already know and love netCDF_. - -.. _ndarray: http://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html -.. _pandas: http://pandas.pydata.org -.. _netCDF: http://www.unidata.ucar.edu/software/netcdf - Documentation ------------- -The official documentation is hosted on ReadTheDocs at http://xarray.pydata.org/ +Learn more about xarray in its official documentation at http://xarray.pydata.org/ Contributing ------------ diff --git a/doc/faq.rst b/doc/faq.rst index 44bc021024b..465a5a6d250 100644 --- a/doc/faq.rst +++ b/doc/faq.rst @@ -18,8 +18,9 @@ pandas is a fantastic library for analysis of low-dimensional labelled data - if it can be sensibly described as "rows and columns", pandas is probably the right choice. However, sometimes we want to use higher dimensional arrays (`ndim > 2`), or arrays for which the order of dimensions (e.g., columns vs -rows) shouldn't really matter. For example, climate and weather data is often -natively expressed in 4 or more dimensions: time, x, y and z. +rows) shouldn't really matter. For example, the images of a movie can be +natively represented as an array with four dimensions: time, row, column and +color. Pandas has historically supported N-dimensional panels, but deprecated them in version 0.20 in favor of Xarray data structures. There are now built-in methods @@ -39,9 +40,8 @@ if you were using Panels: xarray ``Dataset``. You can :ref:`read about switching from Panels to Xarray here `. -Pandas gets a lot of things right, but scientific users need fully multi- -dimensional data structures. - +Pandas gets a lot of things right, but many science, engineering and complex +analytics use cases need fully multi-dimensional data structures. How do xarray data structures differ from those found in pandas? ---------------------------------------------------------------- @@ -65,7 +65,9 @@ multi-dimensional data-structures. That said, you should only bother with xarray if some aspect of data is fundamentally multi-dimensional. If your data is unstructured or -one-dimensional, stick with pandas. +one-dimensional, pandas is usually the right choice: it has better performance +for common operations such as ``groupby`` and you'll find far more usage +examples online. Why don't aggregations return Python scalars? diff --git a/doc/index.rst b/doc/index.rst index fe6d2874953..dbe911011cd 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -5,29 +5,21 @@ xarray: N-D labeled arrays and datasets in Python that makes working with labelled multi-dimensional arrays simple, efficient, and fun! -Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called -"tensors") are an essential part of computational science. -They are encountered in a wide range of fields, including physics, astronomy, -geoscience, bioinformatics, engineering, finance, and deep learning. -In Python, NumPy_ provides the fundamental data structure and API for -working with raw ND arrays. -However, real-world datasets are usually more than just raw numbers; -they have labels which encode information about how the array values map -to locations in space, time, etc. - -By introducing *dimensions*, *coordinates*, and *attributes* on top of raw -NumPy-like arrays, xarray is able to understand these labels and use them to -provide a more intuitive, more concise, and less error-prone experience. -Xarray also provides a large and growing library of functions for advanced -analytics and visualization with these data structures. +Xarray introduces labels in the form of dimensions, coordinates and +attributes on top of raw NumPy_-like arrays, which allows for a more +intuitive, more concise, and less error-prone developer experience. +The package includes a large and growing library of domain-agnostic functions +for advanced analytics and visualization with these data structures. + Xarray was inspired by and borrows heavily from pandas_, the popular data analysis package focused on labelled tabular data. -Xarray can read and write data from most common labeled ND-array storage -formats and is particularly tailored to working with netCDF_ files, which were -the source of xarray's data model. +It is particularly tailored to working with netCDF_ files, which were the +source of xarray's data model, and integrates tightly with dask_ for parallel +computing. -.. _NumPy: http://www.numpy.org/ +.. _NumPy: http://www.numpy.org .. _pandas: http://pandas.pydata.org +.. _dask: http://dask.org .. _netCDF: http://www.unidata.ucar.edu/software/netcdf Documentation diff --git a/doc/related-projects.rst b/doc/related-projects.rst index cf89c715bc7..c89e324ff7c 100644 --- a/doc/related-projects.rst +++ b/doc/related-projects.rst @@ -3,7 +3,7 @@ Xarray related projects ----------------------- -Here below is a list of several existing libraries that build +Here below is a list of existing open source projects that build functionality upon xarray. See also section :ref:`internals` for more details on how to build xarray extensions. @@ -39,11 +39,16 @@ Geosciences Machine Learning ~~~~~~~~~~~~~~~~ -- `cesium `_: machine learning for time series analysis +- `ArviZ `_: Exploratory analysis of Bayesian models, built on top of xarray. - `Elm `_: Parallel machine learning on xarray data structures - `sklearn-xarray (1) `_: Combines scikit-learn and xarray (1). - `sklearn-xarray (2) `_: Combines scikit-learn and xarray (2). +Other domains +~~~~~~~~~~~~~ +- `ptsa `_: EEG Time Series Analysis +- `pycalphad `_: Computational Thermodynamics in Python + Extend xarray capabilities ~~~~~~~~~~~~~~~~~~~~~~~~~~ - `Collocate `_: Collocate xarray trajectories in arbitrary physical dimensions @@ -61,9 +66,10 @@ Visualization - `hvplot `_ : A high-level plotting API for the PyData ecosystem built on HoloViews. - `psyplot `_: Interactive data visualization with python. -Other -~~~~~ -- `ptsa `_: EEG Time Series Analysis -- `pycalphad `_: Computational Thermodynamics in Python +Non-Python projects +~~~~~~~~~~~~~~~~~~~ +- `xframe `_: C++ data structures inspired by xarray. +- `AxisArrays `_ and + `NamedArrays `_: similar data structures for Julia. More projects can be found at the `"xarray" Github topic `_. diff --git a/doc/why-xarray.rst b/doc/why-xarray.rst index e9f30fe25be..d0a6c591b29 100644 --- a/doc/why-xarray.rst +++ b/doc/why-xarray.rst @@ -1,11 +1,21 @@ Overview: Why xarray? ===================== -Features --------- - -Adding dimensions names and coordinate indexes to numpy's ndarray_ makes many -powerful array operations possible: +What labels enable +------------------ + +Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called +"tensors") are an essential part of computational science. +They are encountered in a wide range of fields, including physics, astronomy, +geoscience, bioinformatics, engineering, finance, and deep learning. +In Python, NumPy_ provides the fundamental data structure and API for +working with raw ND arrays. +However, real-world datasets are usually more than just raw numbers; +they have labels which encode information about how the array values map +to locations in space, time, etc. + +Xarray doesn't just keep track of labels on arrays -- it uses them to provide a +powerful and concise interface. For example: - Apply operations over dimensions by name: ``x.sum('time')``. - Select values by label instead of integer location: @@ -19,9 +29,6 @@ powerful array operations possible: - Keep track of arbitrary metadata in the form of a Python dictionary: ``x.attrs``. -pandas_ provides many of these features, but it does not make use of dimension -names, and its core data structures are fixed dimensional arrays. - The N-dimensional nature of xarray's data structures makes it suitable for dealing with multi-dimensional scientific data, and its use of dimension names instead of axis labels (``dim='time'`` instead of ``axis=0``) makes such @@ -29,10 +36,15 @@ arrays much more manageable than the raw numpy ndarray: with xarray, you don't need to keep track of the order of arrays dimensions or insert dummy dimensions (e.g., ``np.newaxis``) to align arrays. +The immediate payoff of using xarray is that you'll write less code. The +long-term payoff is that you'll understand what you were thinking when you come +back to look at it weeks or months later. + Core data structures -------------------- -xarray has two core data structures. Both are fundamentally N-dimensional: +xarray has two core data structures, which build upon and extend the core +strengths of NumPy_ and pandas_. Both are fundamentally N-dimensional: - :py:class:`~xarray.DataArray` is our implementation of a labeled, N-dimensional array. It is an N-D generalization of a :py:class:`pandas.Series`. The name @@ -43,8 +55,6 @@ xarray has two core data structures. Both are fundamentally N-dimensional: shared dimensions, and serves a similar purpose in xarray to the :py:class:`pandas.DataFrame`. -.. _datarray: https://github.com/fperez/datarray - The value of attaching labels to numpy's :py:class:`numpy.ndarray` may be fairly obvious, but the dataset may need more motivation. @@ -69,23 +79,33 @@ metadata once, not every time you save a file. Goals and aspirations --------------------- -pandas_ excels at working with tabular data. That suffices for many statistical -analyses, but physical scientists rely on N-dimensional arrays -- which is -where xarray comes in. +Xarray contributes domain-agnostic data-structures and tools for labeled +multi-dimensional arrays to Python's SciPy_ ecosystem for numerical computing. +In particular, xarray builds upon and integrates with NumPy_ and pandas_: + +- Our user-facing interfaces aim to be more explicit verisons of those found in + NumPy/pandas. +- Compatibility with the broader ecosystem is a major goal: it should be easy + to get your data in and out. +- We try to keep a tight focus on functionality and interfaces related to + labeled data, and leverage other Python libraries for everything else, e.g., + NumPy/pandas for fast arrays/indexing (xarray itself contains no compiled + code), Dask_ for parallel computing, matplotlib_ for plotting, etc. + +Xarray is a collaborative and community driven project, run entirely on +volunteer effort (see :ref:`contributing`). +Our target audience is anyone who needs N-dimensional labeled arrays in Python. +Originally, development was driven by the data analysis needs of physical +scientists (especially geoscientists who already know and love +netCDF_), but it has become a much more broadly useful tool, and is still +under active development. +See our technical :ref:`roadmap` for more details, and feel free to reach out +with questions about whether xarray is the right tool for your needs. -xarray aims to provide a data analysis toolkit as powerful as pandas_ but -designed for working with homogeneous N-dimensional arrays -instead of tabular data. When possible, we copy the pandas API and rely on -pandas's highly optimized internals (in particular, for fast indexing). - -Importantly, xarray has robust support for converting its objects to and -from a numpy ``ndarray`` or a pandas ``DataFrame`` or ``Series``, providing -compatibility with the full `PyData ecosystem `__. - -Our target audience is anyone who needs N-dimensional labeled arrays, but we -are particularly focused on the data analysis needs of physical scientists -- -especially geoscientists who already know and love netCDF_. - -.. _ndarray: http://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html +.. _datarray: https://github.com/fperez/datarray +.. _Dask: http://dask.org +.. _matplotlib: http://matplotlib.org .. _netCDF: http://www.unidata.ucar.edu/software/netcdf +.. _NumPy: http://www.numpy.org .. _pandas: http://pandas.pydata.org +.. _SciPy: http://www.scipy.org diff --git a/setup.py b/setup.py index 8c0c98ab33d..ff667d7a113 100644 --- a/setup.py +++ b/setup.py @@ -38,6 +38,25 @@ that makes working with labelled multi-dimensional arrays simple, efficient, and fun! +Xarray introduces labels in the form of dimensions, coordinates and +attributes on top of raw NumPy_-like arrays, which allows for a more +intuitive, more concise, and less error-prone developer experience. +The package includes a large and growing library of domain-agnostic functions +for advanced analytics and visualization with these data structures. + +Xarray was inspired by and borrows heavily from pandas_, the popular data +analysis package focused on labelled tabular data. +It is particularly tailored to working with netCDF_ files, which were the +source of xarray's data model, and integrates tightly with dask_ for parallel +computing. + +.. _NumPy: http://www.numpy.org/ +.. _pandas: http://pandas.pydata.org +.. _netCDF: http://www.unidata.ucar.edu/software/netcdf + +Why xarray? +----------- + Multi-dimensional (a.k.a. N-dimensional, ND) arrays (sometimes called "tensors") are an essential part of computational science. They are encountered in a wide range of fields, including physics, astronomy, @@ -48,25 +67,25 @@ they have labels which encode information about how the array values map to locations in space, time, etc. -By introducing *dimensions*, *coordinates*, and *attributes* on top of raw -NumPy-like arrays, xarray is able to understand these labels and use them to -provide a more intuitive, more concise, and less error-prone experience. -Xarray also provides a large and growing library of functions for advanced -analytics and visualization with these data structures. -Xarray was inspired by and borrows heavily from pandas_, the popular data -analysis package focused on labelled tabular data. -Xarray can read and write data from most common labeled ND-array storage -formats and is particularly tailored to working with netCDF_ files, which were -the source of xarray's data model. +Xarray doesn't just keep track of labels on arrays -- it uses them to provide a +powerful and concise interface. For example: -.. _NumPy: http://www.numpy.org/ -.. _pandas: http://pandas.pydata.org -.. _netCDF: http://www.unidata.ucar.edu/software/netcdf +- Apply operations over dimensions by name: ``x.sum('time')``. +- Select values by label instead of integer location: + ``x.loc['2014-01-01']`` or ``x.sel(time='2014-01-01')``. +- Mathematical operations (e.g., ``x - y``) vectorize across multiple + dimensions (array broadcasting) based on dimension names, not shape. +- Flexible split-apply-combine operations with groupby: + ``x.groupby('time.dayofyear').mean()``. +- Database like alignment based on coordinate labels that smoothly + handles missing values: ``x, y = xr.align(x, y, join='outer')``. +- Keep track of arbitrary metadata in the form of a Python dictionary: + ``x.attrs``. -Important links ---------------- +Learn more +---------- -- HTML documentation: http://xarray.pydata.org +- Documentation: http://xarray.pydata.org - Issue tracker: http://github.com/pydata/xarray/issues - Source code: http://github.com/pydata/xarray - SciPy2015 talk: https://www.youtube.com/watch?v=X0pAhJgySxk From 44a8c97b1a1938992aa32a6f885e22251fcd36ce Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sun, 13 Jan 2019 19:07:18 +0200 Subject: [PATCH 057/108] xfail cftimeindex multiindex test (#2669) It was a nice idea to support CFTimeIndex in a pandas.MultiIndex, but pandas seems to have inadvertently broken this, see https://github.com/pandas-dev/pandas/issues/24263 --- xarray/tests/test_cftimeindex.py | 1 + 1 file changed, 1 insertion(+) diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 3c4fc67c5eb..3fe014bdaba 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -799,6 +799,7 @@ def test_to_datetimeindex_feb_29(calendar): @pytest.mark.skipif(not has_cftime, reason='cftime not installed') +@pytest.mark.xfail(reason='https://github.com/pandas-dev/pandas/issues/24263') def test_multiindex(): index = xr.cftime_range('2001-01-01', periods=100, calendar='360_day') mindex = pd.MultiIndex.from_arrays([index]) From f13536c965d02bb2845da31e909899a90754b375 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Tue, 15 Jan 2019 13:19:58 +0200 Subject: [PATCH 058/108] Fix test failures with numpy=1.16 (#2675) Fixes https://github.com/pydata/xarray/issues/2673 Note that these were only test failures, not a real bug. --- xarray/tests/test_variable.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 6dd50e11fd3..fdcc184eec4 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -140,8 +140,8 @@ def _assertIndexedLikeNDArray(self, variable, expected_value0, # check value is equal for both ndarray and Variable with warnings.catch_warnings(): warnings.filterwarnings('ignore', "In the future, 'NAT == x'") - assert variable.values[0] == expected_value0 - assert variable[0].values == expected_value0 + np.testing.assert_equal(variable.values[0], expected_value0) + np.testing.assert_equal(variable[0].values, expected_value0) # check type or dtype is consistent for both ndarray and Variable if expected_dtype is None: # check output type instead of array dtype From 5a96460dcba1bdfcedb3f2950628edca8a939e87 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Wed, 16 Jan 2019 10:35:51 +0100 Subject: [PATCH 059/108] Update README.rst (#2682) --- README.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index f30d9dde8bb..f69f7d95c31 100644 --- a/README.rst +++ b/README.rst @@ -114,7 +114,7 @@ __ http://climate.com/ License ------- -Copyright 2014-2018, xarray Developers +Copyright 2014-2019, xarray Developers Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. From dc87dea52351835af472d131f70a7f7603b3100e Mon Sep 17 00:00:00 2001 From: Tom Nicholas <35968931+TomNicholas@users.noreply.github.com> Date: Thu, 17 Jan 2019 13:05:42 +0000 Subject: [PATCH 060/108] Hotfix for #2662 (#2678) * Hotfix for #2662 * Separate keyfunc * Added a test, and made others slightly stricter * Comment explaining test better --- xarray/core/combine.py | 9 +++++++-- xarray/tests/test_combine.py | 16 ++++++++++++++-- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/xarray/core/combine.py b/xarray/core/combine.py index e552d8d900c..0327a65ab1b 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -493,16 +493,21 @@ def _auto_combine_all_along_first_dim(combined_ids, dim, data_vars, return new_combined_ids +def vars_as_keys(ds): + return tuple(sorted(ds)) + + def _auto_combine_1d(datasets, concat_dim=_CONCAT_DIM_DEFAULT, compat='no_conflicts', data_vars='all', coords='different'): # This is just the old auto_combine function (which only worked along 1D) if concat_dim is not None: dim = None if concat_dim is _CONCAT_DIM_DEFAULT else concat_dim - grouped = itertools.groupby(datasets, key=lambda ds: tuple(sorted(ds))) + sorted_datasets = sorted(datasets, key=vars_as_keys) + grouped_by_vars = itertools.groupby(sorted_datasets, key=vars_as_keys) concatenated = [_auto_concat(list(ds_group), dim=dim, data_vars=data_vars, coords=coords) - for id, ds_group in grouped] + for id, ds_group in grouped_by_vars] else: concatenated = datasets merged = merge(concatenated, compat=compat) diff --git a/xarray/tests/test_combine.py b/xarray/tests/test_combine.py index 9ea38e7d5f2..e978350d322 100644 --- a/xarray/tests/test_combine.py +++ b/xarray/tests/test_combine.py @@ -650,7 +650,7 @@ def test_merge_one_dim_concat_another(self): expected = Dataset({'foo': ('x', [0, 1, 2, 3]), 'bar': ('x', [10, 20, 30, 40])}) - actual = auto_combine(objs, concat_dim=['x', None]) + actual = auto_combine(objs, concat_dim=['x', None], compat='equals') assert_identical(expected, actual) actual = auto_combine(objs) @@ -661,7 +661,19 @@ def test_merge_one_dim_concat_another(self): Dataset({'foo': ('x', [2, 3])})], [Dataset({'bar': ('x', [10, 20])}), Dataset({'bar': ('x', [30, 40])})]] - actual = auto_combine(objs, concat_dim=[None, 'x']) + actual = auto_combine(objs, concat_dim=[None, 'x'], compat='equals') + assert_identical(expected, actual) + + def test_internal_ordering(self): + # This gives a MergeError if _auto_combine_1d is not sorting by + # data_vars correctly, see GH #2662 + objs = [Dataset({'foo': ('x', [0, 1])}), + Dataset({'bar': ('x', [10, 20])}), + Dataset({'foo': ('x', [2, 3])}), + Dataset({'bar': ('x', [30, 40])})] + actual = auto_combine(objs, concat_dim='x', compat='equals') + expected = Dataset({'foo': ('x', [0, 1, 2, 3]), + 'bar': ('x', [10, 20, 30, 40])}) assert_identical(expected, actual) def test_combine_concat_over_redundant_nesting(self): From 1d0a2bc4970d9e7337fe307f4519bd936f7d7d89 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Fri, 18 Jan 2019 10:16:30 +0100 Subject: [PATCH 061/108] Detailed report for testing.assert_equal and testing.assert_identical (#1507) * more detailed AssertionError message for assert_identical * print differing dimensions/data/variables/attributes * minor tweaks * add what's new entry * add tests for diff_array_repr and diff_dataset_repr * pep8 * add differing dimensions in diff_array_repr * fix tests (explicit numpy dtypes) * fix tests (dtype shown / not shown in array repr) * minor tweaks --- doc/whats-new.rst | 5 ++ xarray/core/formatting.py | 146 ++++++++++++++++++++++++++++++-- xarray/testing.py | 15 ++-- xarray/tests/test_formatting.py | 117 +++++++++++++++++++++++++ 4 files changed, 272 insertions(+), 11 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index b50df2af10e..4a351716fab 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -36,6 +36,11 @@ Enhancements - Upsampling an array via interpolation with resample is now dask-compatible, as long as the array is not chunked along the resampling dimension. By `Spencer Clark `_. +- :py:func:`xarray.testing.assert_equal` and + :py:func:`xarray.testing.assert_identical` now provide a more detailed + report showing what exactly differs between the two objects (dimensions / + coordinates / variables / attributes) (:issue:`1507`). + By `Benoit Bovy `_. Bug fixes ~~~~~~~~~ diff --git a/xarray/core/formatting.py b/xarray/core/formatting.py index 5dd3cf06025..50fa64c9987 100644 --- a/xarray/core/formatting.py +++ b/xarray/core/formatting.py @@ -13,6 +13,7 @@ import numpy as np import pandas as pd +from .duck_array_ops import array_equiv from .options import OPTIONS from .pycompat import ( PY2, bytes_type, dask_array_type, unicode_type, zip_longest) @@ -411,6 +412,15 @@ def short_dask_repr(array, show_dtype=True): return 'dask.array' % (array.shape, chunksize) +def short_data_repr(array): + if isinstance(getattr(array, 'variable', array)._data, dask_array_type): + return short_dask_repr(array) + elif array._in_memory or array.size < 1e5: + return short_array_repr(array.values) + else: + return u'[%s values with dtype=%s]' % (array.size, array.dtype) + + def array_repr(arr): # used for DataArray, Variable and IndexVariable if hasattr(arr, 'name') and arr.name is not None: @@ -421,12 +431,7 @@ def array_repr(arr): summary = [u'' % (type(arr).__name__, name_str, dim_summary(arr))] - if isinstance(getattr(arr, 'variable', arr)._data, dask_array_type): - summary.append(short_dask_repr(arr)) - elif arr._in_memory or arr.size < 1e5: - summary.append(short_array_repr(arr.values)) - else: - summary.append(u'[%s values with dtype=%s]' % (arr.size, arr.dtype)) + summary.append(short_data_repr(arr)) if hasattr(arr, 'coords'): if arr.coords: @@ -463,3 +468,132 @@ def dataset_repr(ds): summary.append(attrs_repr(ds.attrs)) return u'\n'.join(summary) + + +def diff_dim_summary(a, b): + if a.dims != b.dims: + return "Differing dimensions:\n ({}) != ({})".format( + dim_summary(a), dim_summary(b)) + else: + return "" + + +def _diff_mapping_repr(a_mapping, b_mapping, compat, + title, summarizer, col_width=None): + + def extra_items_repr(extra_keys, mapping, ab_side): + extra_repr = [summarizer(k, mapping[k], col_width) for k in extra_keys] + if extra_repr: + header = "{} only on the {} object:".format(title, ab_side) + return [header] + extra_repr + else: + return [] + + a_keys = set(a_mapping) + b_keys = set(b_mapping) + + summary = [] + + diff_items = [] + + for k in a_keys & b_keys: + try: + # compare xarray variable + compatible = getattr(a_mapping[k], compat)(b_mapping[k]) + is_variable = True + except AttributeError: + # compare attribute value + compatible = a_mapping[k] == b_mapping[k] + is_variable = False + + if not compatible: + temp = [summarizer(k, vars[k], col_width) + for vars in (a_mapping, b_mapping)] + + if compat == 'identical' and is_variable: + attrs_summary = [] + + for m in (a_mapping, b_mapping): + attr_s = "\n".join([summarize_attr(ak, av) + for ak, av in m[k].attrs.items()]) + attrs_summary.append(attr_s) + + temp = ["\n".join([var_s, attr_s]) if attr_s else var_s + for var_s, attr_s in zip(temp, attrs_summary)] + + diff_items += [ab_side + s[1:] + for ab_side, s in zip(('L', 'R'), temp)] + + if diff_items: + summary += ["Differing {}:".format(title.lower())] + diff_items + + summary += extra_items_repr(a_keys - b_keys, a_mapping, "left") + summary += extra_items_repr(b_keys - a_keys, b_mapping, "right") + + return "\n".join(summary) + + +diff_coords_repr = functools.partial(_diff_mapping_repr, + title="Coordinates", + summarizer=summarize_coord) + + +diff_data_vars_repr = functools.partial(_diff_mapping_repr, + title="Data variables", + summarizer=summarize_datavar) + + +diff_attrs_repr = functools.partial(_diff_mapping_repr, + title="Attributes", + summarizer=summarize_attr) + + +def _compat_to_str(compat): + if compat == "equals": + return "equal" + else: + return compat + + +def diff_array_repr(a, b, compat): + # used for DataArray, Variable and IndexVariable + summary = ["Left and right {} objects are not {}" + .format(type(a).__name__, _compat_to_str(compat))] + + summary.append(diff_dim_summary(a, b)) + + if not array_equiv(a.data, b.data): + temp = [wrap_indent(short_array_repr(obj), start=' ') + for obj in (a, b)] + diff_data_repr = [ab_side + "\n" + ab_data_repr + for ab_side, ab_data_repr in zip(('L', 'R'), temp)] + summary += ["Differing values:"] + diff_data_repr + + if hasattr(a, 'coords'): + col_width = _calculate_col_width(set(a.coords) | set(b.coords)) + summary.append(diff_coords_repr(a.coords, b.coords, compat, + col_width=col_width)) + + if compat == 'identical': + summary.append(diff_attrs_repr(a.attrs, b.attrs, compat)) + + return "\n".join(summary) + + +def diff_dataset_repr(a, b, compat): + summary = ["Left and right {} objects are not {}" + .format(type(a).__name__, _compat_to_str(compat))] + + col_width = _calculate_col_width( + set(_get_col_items(a.variables) + _get_col_items(b.variables))) + + summary.append(diff_dim_summary(a, b)) + summary.append(diff_coords_repr(a.coords, b.coords, compat, + col_width=col_width)) + summary.append(diff_data_vars_repr(a.data_vars, b.data_vars, compat, + col_width=col_width)) + + if compat == 'identical': + summary.append(diff_attrs_repr(a.attrs, b.attrs, compat)) + + return "\n".join(summary) diff --git a/xarray/testing.py b/xarray/testing.py index c2bb5044ef4..418f1a08668 100644 --- a/xarray/testing.py +++ b/xarray/testing.py @@ -4,6 +4,7 @@ import numpy as np from xarray.core import duck_array_ops +from xarray.core import formatting def _decode_string_data(data): @@ -49,8 +50,10 @@ def assert_equal(a, b): import xarray as xr __tracebackhide__ = True # noqa: F841 assert type(a) == type(b) # noqa - if isinstance(a, (xr.Variable, xr.DataArray, xr.Dataset)): - assert a.equals(b), '{}\n{}'.format(a, b) + if isinstance(a, (xr.Variable, xr.DataArray)): + assert a.equals(b), formatting.diff_array_repr(a, b, 'equals') + elif isinstance(a, xr.Dataset): + assert a.equals(b), formatting.diff_dataset_repr(a, b, 'equals') else: raise TypeError('{} not supported by assertion comparison' .format(type(a))) @@ -76,11 +79,13 @@ def assert_identical(a, b): import xarray as xr __tracebackhide__ = True # noqa: F841 assert type(a) == type(b) # noqa - if isinstance(a, xr.DataArray): + if isinstance(a, xr.Variable): + assert a.identical(b), formatting.diff_array_repr(a, b, 'identical') + elif isinstance(a, xr.DataArray): assert a.name == b.name - assert_identical(a._to_temp_dataset(), b._to_temp_dataset()) + assert a.identical(b), formatting.diff_array_repr(a, b, 'identical') elif isinstance(a, (xr.Dataset, xr.Variable)): - assert a.identical(b), '{}\n{}'.format(a, b) + assert a.identical(b), formatting.diff_dataset_repr(a, b, 'identical') else: raise TypeError('{} not supported by assertion comparison' .format(type(a))) diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index 024c669bed9..6ca5e6f5363 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -1,9 +1,12 @@ # -*- coding: utf-8 -*- from __future__ import absolute_import, division, print_function +from textwrap import dedent + import numpy as np import pandas as pd +import xarray as xr from xarray.core import formatting from xarray.core.pycompat import PY3 @@ -190,6 +193,120 @@ def test_attribute_repr(self): assert u'\n' not in newlines assert u'\t' not in tabs + def test_diff_array_repr(self): + da_a = xr.DataArray( + np.array([[1, 2, 3], [4, 5, 6]], dtype='int64'), + dims=('x', 'y'), + coords={'x': np.array(['a', 'b'], dtype='U1'), + 'y': np.array([1, 2, 3], dtype='int64')}, + attrs={'units': 'm', 'description': 'desc'}) + + da_b = xr.DataArray( + np.array([1, 2], dtype='int64'), + dims='x', + coords={'x': np.array(['a', 'c'], dtype='U1'), + 'label': ('x', np.array([1, 2], dtype='int64'))}, + attrs={'units': 'kg'}) + + expected = dedent("""\ + Left and right DataArray objects are not identical + Differing dimensions: + (x: 2, y: 3) != (x: 2) + Differing values: + L + array([[1, 2, 3], + [4, 5, 6]], dtype=int64) + R + array([1, 2], dtype=int64) + Differing coordinates: + L * x (x) Date: Fri, 18 Jan 2019 13:47:43 -0800 Subject: [PATCH 062/108] try no rasterio in py36 env (#2691) * try no rasterio in py36 env * no pynio or iris either * pin min gdal version in doc build --- .travis.yml | 2 +- ci/requirements-py36.yml | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 8e1866de8d4..a21d4d94413 100644 --- a/.travis.yml +++ b/.travis.yml @@ -60,7 +60,7 @@ script: - python --version - python -OO -c "import xarray" - if [[ "$CONDA_ENV" == "docs" ]]; then - conda install -c conda-forge sphinx sphinx_rtd_theme sphinx-gallery numpydoc; + conda install -c conda-forge --override-channels sphinx sphinx_rtd_theme sphinx-gallery numpydoc "gdal>2.2.4"; sphinx-build -n -j auto -b html -d _build/doctrees doc _build/html; elif [[ "$CONDA_ENV" == "lint" ]]; then pycodestyle xarray ; diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index 311e4a275a8..0ed6dd78c3a 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -20,14 +20,14 @@ dependencies: - scipy - seaborn - toolz - - rasterio + # - rasterio # xref #2683 - bottleneck - zarr - pseudonetcdf>=3.0.1 - eccodes - cdms2 - - pynio - - iris>=1.10 + # - pynio # xref #2683 + # - iris>=1.10 # xref #2683 - pydap - lxml - pip: From ec255eba7cce749c25e1d7b6f0a7fc537ff61841 Mon Sep 17 00:00:00 2001 From: Tom Augspurger Date: Sat, 19 Jan 2019 11:45:19 -0600 Subject: [PATCH 063/108] Update asv.conf.json (#2693) --- asv_bench/asv.conf.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/asv_bench/asv.conf.json b/asv_bench/asv.conf.json index e3933b400e6..11a779ae376 100644 --- a/asv_bench/asv.conf.json +++ b/asv_bench/asv.conf.json @@ -40,7 +40,7 @@ // The Pythons you'd like to test against. If not provided, defaults // to the current version of Python used to run `asv`. - "pythons": ["2.7", "3.6"], + "pythons": ["3.6"], // The matrix of dependencies to test. Each key is the name of a // package (in PyPI) and the values are version numbers. An empty From a7d55b9bcd0cc19330b5784842d51af5309d07ee Mon Sep 17 00:00:00 2001 From: Ryan Abernathey Date: Tue, 22 Jan 2019 00:25:55 +0100 Subject: [PATCH 064/108] to_dict without data (#2659) * add data=False to to_dict methods * doc and whats-new * fix pep8 errors * small tweaks * added shape and dtype --- doc/io.rst | 12 +++++++++++- doc/whats-new.rst | 2 ++ xarray/core/dataarray.py | 22 ++++++++++------------ xarray/core/dataset.py | 21 +++++++++------------ xarray/core/variable.py | 13 ++++++++++++- xarray/tests/test_dataarray.py | 9 +++++++++ xarray/tests/test_dataset.py | 20 +++++++++++++++++--- 7 files changed, 70 insertions(+), 29 deletions(-) diff --git a/doc/io.rst b/doc/io.rst index 151f5eb740f..0dc5181f9b8 100644 --- a/doc/io.rst +++ b/doc/io.rst @@ -81,6 +81,16 @@ require external libraries and dicts can easily be pickled, or converted to json, or geojson. All the values are converted to lists, so dicts might be quite large. +To export just the dataset schema, without the data itself, use the +``data=False`` option: + +.. ipython:: python + + ds.to_dict(data=False) + +This can be useful for generating indices of dataset contents to expose to +search indices or other automated data discovery tools. + .. _io.netcdf: netCDF @@ -665,7 +675,7 @@ To read a consolidated store, pass the ``consolidated=True`` option to :py:func:`~xarray.open_zarr`:: ds = xr.open_zarr('foo.zarr', consolidated=True) - + Xarray can't perform consolidation on pre-existing zarr datasets. This should be done directly from zarr, as described in the `zarr docs `_. diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 4a351716fab..c408306ffdb 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -28,6 +28,8 @@ Breaking changes Enhancements ~~~~~~~~~~~~ +- Add ``data=False`` option to ``to_dict()`` methods. (:issue:`2656`) + By `Ryan Abernathey `_ - :py:meth:`~xarray.DataArray.coarsen` and :py:meth:`~xarray.Dataset.coarsen` are newly added. See :ref:`comput.coarsen` for details. diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index f27958b1c77..aa6c35394fb 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -1760,7 +1760,7 @@ def to_netcdf(self, *args, **kwargs): return dataset.to_netcdf(*args, **kwargs) - def to_dict(self): + def to_dict(self, data=True): """ Convert this xarray.DataArray into a dictionary following xarray naming conventions. @@ -1769,22 +1769,20 @@ def to_dict(self): Useful for coverting to json. To avoid datetime incompatibility use decode_times=False kwarg in xarrray.open_dataset. + Parameters + ---------- + data : bool, optional + Whether to include the actual data in the dictionary. When set to + False, returns just the schema. + See also -------- DataArray.from_dict """ - d = {'coords': {}, 'attrs': decode_numpy_dict_values(self.attrs), - 'dims': self.dims} - + d = self.variable.to_dict(data=data) + d.update({'coords': {}, 'name': self.name}) for k in self.coords: - data = ensure_us_time_resolution(self[k].values).tolist() - d['coords'].update({ - k: {'data': data, - 'dims': self[k].dims, - 'attrs': decode_numpy_dict_values(self[k].attrs)}}) - - d.update({'data': ensure_us_time_resolution(self.values).tolist(), - 'name': self.name}) + d['coords'][k] = self.coords[k].variable.to_dict(data=data) return d @classmethod diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 2caf45ce954..3f1c038fc11 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -3221,7 +3221,7 @@ def to_dask_dataframe(self, dim_order=None, set_index=False): return df - def to_dict(self): + def to_dict(self, data=True): """ Convert this dataset to a dictionary following xarray naming conventions. @@ -3230,25 +3230,22 @@ def to_dict(self): Useful for coverting to json. To avoid datetime incompatibility use decode_times=False kwarg in xarrray.open_dataset. + Parameters + ---------- + data : bool, optional + Whether to include the actual data in the dictionary. When set to + False, returns just the schema. + See also -------- Dataset.from_dict """ d = {'coords': {}, 'attrs': decode_numpy_dict_values(self.attrs), 'dims': dict(self.dims), 'data_vars': {}} - for k in self.coords: - data = ensure_us_time_resolution(self[k].values).tolist() - d['coords'].update({ - k: {'data': data, - 'dims': self[k].dims, - 'attrs': decode_numpy_dict_values(self[k].attrs)}}) + d['coords'].update({k: self[k].variable.to_dict(data=data)}) for k in self.data_vars: - data = ensure_us_time_resolution(self[k].values).tolist() - d['data_vars'].update({ - k: {'data': data, - 'dims': self[k].dims, - 'attrs': decode_numpy_dict_values(self[k].attrs)}}) + d['data_vars'].update({k: self[k].variable.to_dict(data=data)}) return d @classmethod diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 8bd7225efc3..a71b148baf3 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -19,7 +19,8 @@ from .options import _get_keep_attrs from .pycompat import ( OrderedDict, basestring, dask_array_type, integer_types, zip) -from .utils import OrderedSet, either_dict_or_kwargs +from .utils import (OrderedSet, either_dict_or_kwargs, + decode_numpy_dict_values, ensure_us_time_resolution) try: import dask.array as da @@ -410,6 +411,16 @@ def to_index(self): """Convert this variable to a pandas.Index""" return self.to_index_variable().to_index() + def to_dict(self, data=True): + """Dictionary representation of variable.""" + item = {'dims': self.dims, + 'attrs': decode_numpy_dict_values(self.attrs)} + if data: + item['data'] = ensure_us_time_resolution(self.values).tolist() + else: + item.update({'dtype': str(self.dtype), 'shape': self.shape}) + return item + @property def dims(self): """Tuple of dimension names with which this variable is associated. diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index aa02e802fc5..8995fca2f95 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2909,6 +2909,15 @@ def test_to_and_from_dict(self): ValueError, "cannot convert dict without the key 'data'"): DataArray.from_dict(d) + # check the data=False option + expected_no_data = expected.copy() + del expected_no_data['data'] + del expected_no_data['coords']['x']['data'] + expected_no_data['coords']['x'].update({'dtype': ' Date: Tue, 22 Jan 2019 21:49:59 -0500 Subject: [PATCH 065/108] Config for closing stale issues (#2684) * stale settings * one month before close * exempt assignees --- .github/stale.yml | 58 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 .github/stale.yml diff --git a/.github/stale.yml b/.github/stale.yml new file mode 100644 index 00000000000..b969da0c6b4 --- /dev/null +++ b/.github/stale.yml @@ -0,0 +1,58 @@ +# Configuration for probot-stale - https://github.com/probot/stale + +# Number of days of inactivity before an Issue or Pull Request becomes stale +daysUntilStale: 700 # start with a large number and reduce shortly + +# Number of days of inactivity before an Issue or Pull Request with the stale label is closed. +# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale. +daysUntilClose: 30 + +# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable +exemptLabels: + - pinned + - security + - "[Status] Maybe Later" + +# Set to true to ignore issues in a project (defaults to false) +exemptProjects: false + +# Set to true to ignore issues in a milestone (defaults to false) +exemptMilestones: false + +# Set to true to ignore issues with an assignee (defaults to false) +exemptAssignees: true + +# Label to use when marking as stale +staleLabel: closed_as_stale + +# Comment to post when marking as stale. Set to `false` to disable +markComment: > + In order to maintain a list of currently relevant issues, we mark issues as stale after a period of inactivity + If this issue remains relevant, please comment here; otherwise it will be marked as closed automatically + +# Comment to post when removing the stale label. +# unmarkComment: > +# Your comment here. + +# Comment to post when closing a stale Issue or Pull Request. +# closeComment: > +# Your comment here. + +# Limit the number of actions per hour, from 1-30. Default is 30 +limitPerRun: 1 # start with a small number + + +# Limit to only `issues` or `pulls` +# only: issues + +# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls': +# pulls: +# daysUntilStale: 30 +# markComment: > +# This pull request has been automatically marked as stale because it has not had +# recent activity. It will be closed if no further activity occurs. Thank you +# for your contributions. + +# issues: +# exemptLabels: +# - confirmed \ No newline at end of file From e53f21ce6c9ad8c74b1f6cc9dd00d374688ca0fe Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Wed, 23 Jan 2019 11:17:35 -0500 Subject: [PATCH 066/108] add line break to message posted (#2698) --- .github/stale.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/stale.yml b/.github/stale.yml index b969da0c6b4..099645333ec 100644 --- a/.github/stale.yml +++ b/.github/stale.yml @@ -23,10 +23,10 @@ exemptMilestones: false exemptAssignees: true # Label to use when marking as stale -staleLabel: closed_as_stale +staleLabel: # Comment to post when marking as stale. Set to `false` to disable -markComment: > +markComment: | In order to maintain a list of currently relevant issues, we mark issues as stale after a period of inactivity If this issue remains relevant, please comment here; otherwise it will be marked as closed automatically From ddacf405fb256714ce01e1c4c464f829e1cc5058 Mon Sep 17 00:00:00 2001 From: waderoberts123 <32141163+waderoberts123@users.noreply.github.com> Date: Wed, 23 Jan 2019 14:09:41 -0700 Subject: [PATCH 067/108] Update indexing.rst (#2700) Grammar error --- doc/indexing.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/indexing.rst b/doc/indexing.rst index 3878d983cf6..77ec7428991 100644 --- a/doc/indexing.rst +++ b/doc/indexing.rst @@ -371,7 +371,7 @@ Vectorized indexing also works with ``isel``, ``loc``, and ``sel``: ind = xr.DataArray([['a', 'b'], ['b', 'a']], dims=['a', 'b']) da.loc[:, ind] # same as da.sel(y=ind) -These methods may and also be applied to ``Dataset`` objects +These methods may also be applied to ``Dataset`` objects .. ipython:: python From 79fa060dd6b567e8aa3606b8b8cc0c54d1b14acb Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Wed, 23 Jan 2019 20:08:46 -0500 Subject: [PATCH 068/108] stale requires a label (#2701) --- .github/stale.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/stale.yml b/.github/stale.yml index 099645333ec..5a8f6596d69 100644 --- a/.github/stale.yml +++ b/.github/stale.yml @@ -23,7 +23,7 @@ exemptMilestones: false exemptAssignees: true # Label to use when marking as stale -staleLabel: +staleLabel: stale # Comment to post when marking as stale. Set to `false` to disable markComment: | From aabda43c54c6336dc62cc9ec3c2050c9c656cff6 Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Fri, 25 Jan 2019 08:38:45 -0800 Subject: [PATCH 069/108] Remove py2 compat (#2645) * strip out PY2 compat code from pycompat.py * isort * remove 2 unused imports * remove extra import * no more future * no unicode literals * no more ReprMixin * cleanup merge * remove deprecated imports from collections * 2 more cleanups from shoyer --- setup.py | 2 - xarray/__init__.py | 3 - xarray/backends/api.py | 32 ++-- xarray/backends/cfgrib_.py | 2 - xarray/backends/common.py | 15 +- xarray/backends/h5netcdf_.py | 14 +- xarray/backends/lru_cache.py | 4 +- xarray/backends/memory.py | 4 +- xarray/backends/netCDF4_.py | 16 +- xarray/backends/netcdf3.py | 10 +- xarray/backends/pseudonetcdf_.py | 3 +- xarray/backends/pydap_.py | 2 - xarray/backends/pynio_.py | 2 - xarray/backends/rasterio_.py | 1 + xarray/backends/scipy_.py | 16 +- xarray/backends/zarr.py | 7 +- xarray/coding/cftime_offsets.py | 3 +- xarray/coding/cftimeindex.py | 9 +- xarray/coding/strings.py | 10 +- xarray/coding/times.py | 6 - xarray/coding/variables.py | 2 - xarray/conventions.py | 18 +-- xarray/convert.py | 5 +- xarray/core/accessors.py | 2 - xarray/core/alignment.py | 12 +- xarray/core/arithmetic.py | 8 +- xarray/core/combine.py | 11 +- xarray/core/common.py | 16 +- xarray/core/computation.py | 8 +- xarray/core/coordinates.py | 9 +- xarray/core/dask_array_compat.py | 4 +- xarray/core/dask_array_ops.py | 2 - xarray/core/dataarray.py | 22 ++- xarray/core/dataset.py | 105 ++++++------ xarray/core/duck_array_ops.py | 2 - xarray/core/extensions.py | 9 +- xarray/core/formatting.py | 118 ++++++-------- xarray/core/groupby.py | 4 +- xarray/core/indexes.py | 10 +- xarray/core/indexing.py | 18 +-- xarray/core/merge.py | 5 +- xarray/core/missing.py | 7 +- xarray/core/nanops.py | 2 - xarray/core/npcompat.py | 2 - xarray/core/nputils.py | 2 - xarray/core/ops.py | 5 - xarray/core/options.py | 2 - xarray/core/pycompat.py | 240 +--------------------------- xarray/core/resample.py | 2 - xarray/core/rolling.py | 5 +- xarray/core/utils.py | 14 +- xarray/core/variable.py | 17 +- xarray/plot/__init__.py | 3 - xarray/plot/facetgrid.py | 6 +- xarray/plot/plot.py | 7 +- xarray/plot/utils.py | 5 +- xarray/testing.py | 2 - xarray/tests/__init__.py | 3 - xarray/tests/test_accessors.py | 2 - xarray/tests/test_backends.py | 48 +++--- xarray/tests/test_backends_api.py | 1 - xarray/tests/test_cftimeindex.py | 7 +- xarray/tests/test_coding.py | 3 +- xarray/tests/test_coding_strings.py | 29 ++-- xarray/tests/test_coding_times.py | 4 +- xarray/tests/test_combine.py | 8 +- xarray/tests/test_conventions.py | 4 +- xarray/tests/test_dask.py | 5 +- xarray/tests/test_dataarray.py | 6 +- xarray/tests/test_dataset.py | 40 +++-- xarray/tests/test_distributed.py | 1 - xarray/tests/test_dtypes.py | 2 - xarray/tests/test_duck_array_ops.py | 2 - xarray/tests/test_extensions.py | 2 - xarray/tests/test_formatting.py | 24 ++- xarray/tests/test_groupby.py | 2 - xarray/tests/test_indexing.py | 7 +- xarray/tests/test_interp.py | 2 - xarray/tests/test_merge.py | 2 - xarray/tests/test_missing.py | 2 - xarray/tests/test_options.py | 2 - xarray/tests/test_plot.py | 4 +- xarray/tests/test_testing.py | 2 - xarray/tests/test_tutorial.py | 4 +- xarray/tests/test_ufuncs.py | 2 - xarray/tests/test_utils.py | 4 +- xarray/tests/test_variable.py | 25 ++- xarray/tutorial.py | 8 +- xarray/ufuncs.py | 2 - xarray/util/print_versions.py | 1 - 90 files changed, 338 insertions(+), 794 deletions(-) diff --git a/setup.py b/setup.py index ff667d7a113..3921d0c3472 100644 --- a/setup.py +++ b/setup.py @@ -15,8 +15,6 @@ 'Operating System :: OS Independent', 'Intended Audience :: Science/Research', 'Programming Language :: Python', - 'Programming Language :: Python :: 2', - 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', diff --git a/xarray/__init__.py b/xarray/__init__.py index 59a961c6b56..773dfe19d01 100644 --- a/xarray/__init__.py +++ b/xarray/__init__.py @@ -1,7 +1,4 @@ # flake8: noqa -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function from ._version import get_versions __version__ = get_versions()['version'] diff --git a/xarray/backends/api.py b/xarray/backends/api.py index 5f88783bb2e..e52f47a0841 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -1,10 +1,9 @@ -from __future__ import absolute_import, division, print_function - import os.path import warnings from glob import glob from io import BytesIO from numbers import Number +from pathlib import Path import numpy as np @@ -12,7 +11,6 @@ from ..core import indexing from ..core.combine import ( _CONCAT_DIM_DEFAULT, _auto_combine, _infer_concat_order_from_positions) -from ..core.pycompat import basestring, path_type from ..core.utils import close_on_error, is_grib_path, is_remote_uri from .common import ArrayWriter from .locks import _get_scheduler @@ -99,7 +97,7 @@ def _normalize_path(path): def _validate_dataset_names(dataset): """DataArray.name and Dataset keys must be a string or None""" def check_name(name): - if isinstance(name, basestring): + if isinstance(name, str): if not name: raise ValueError('Invalid name for DataArray or Dataset key: ' 'string must be length 1 or greater for ' @@ -117,7 +115,7 @@ def _validate_attrs(dataset): a string, an ndarray or a list/tuple of numbers/strings. """ def check_attr(name, value): - if isinstance(name, basestring): + if isinstance(name, str): if not name: raise ValueError('Invalid name for attr: string must be ' 'length 1 or greater for serialization to ' @@ -126,7 +124,7 @@ def check_attr(name, value): raise TypeError("Invalid name for attr: {} must be a string for " "serialization to netCDF files".format(name)) - if not isinstance(value, (basestring, Number, np.ndarray, np.number, + if not isinstance(value, (str, Number, np.ndarray, np.number, list, tuple)): raise TypeError('Invalid value for attr: {} must be a number, ' 'a string, an ndarray or a list/tuple of ' @@ -279,7 +277,7 @@ def maybe_decode_store(store, lock=False): from dask.base import tokenize # if passed an actual file path, augment the token with # the file modification time - if (isinstance(filename_or_obj, basestring) and + if (isinstance(filename_or_obj, str) and not is_remote_uri(filename_or_obj)): mtime = os.path.getmtime(filename_or_obj) else: @@ -295,13 +293,13 @@ def maybe_decode_store(store, lock=False): return ds2 - if isinstance(filename_or_obj, path_type): + if isinstance(filename_or_obj, Path): filename_or_obj = str(filename_or_obj) if isinstance(filename_or_obj, backends.AbstractDataStore): store = filename_or_obj ds = maybe_decode_store(store) - elif isinstance(filename_or_obj, basestring): + elif isinstance(filename_or_obj, str): if (isinstance(filename_or_obj, bytes) and filename_or_obj.startswith(b'\x89HDF')): @@ -310,7 +308,7 @@ def maybe_decode_store(store, lock=False): filename_or_obj.startswith(b'CDF')): # netCDF3 file images are handled by scipy pass - elif isinstance(filename_or_obj, basestring): + elif isinstance(filename_or_obj, str): filename_or_obj = _normalize_path(filename_or_obj) if engine is None: @@ -352,7 +350,7 @@ def maybe_decode_store(store, lock=False): # Ensure source filename always stored in dataset object (GH issue #2550) if 'source' not in ds.encoding: - if isinstance(filename_or_obj, basestring): + if isinstance(filename_or_obj, str): ds.encoding['source'] = filename_or_obj return ds @@ -588,7 +586,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, .. [1] http://xarray.pydata.org/en/stable/dask.html .. [2] http://xarray.pydata.org/en/stable/dask.html#chunking-and-performance """ # noqa - if isinstance(paths, basestring): + if isinstance(paths, str): if is_remote_uri(paths): raise ValueError( 'cannot do wild-card matching for paths that are remote URLs: ' @@ -596,7 +594,7 @@ def open_mfdataset(paths, chunks=None, concat_dim=_CONCAT_DIM_DEFAULT, .format(paths)) paths = sorted(glob(paths)) else: - paths = [str(p) if isinstance(p, path_type) else p for p in paths] + paths = [str(p) if isinstance(p, Path) else p for p in paths] if not paths: raise IOError('no files to open') @@ -681,7 +679,7 @@ def to_netcdf(dataset, path_or_file=None, mode='w', format=None, group=None, The ``multifile`` argument is only for the private use of save_mfdataset. """ - if isinstance(path_or_file, path_type): + if isinstance(path_or_file, Path): path_or_file = str(path_or_file) if encoding is None: @@ -698,7 +696,7 @@ def to_netcdf(dataset, path_or_file=None, mode='w', format=None, group=None, raise NotImplementedError( 'to_netcdf() with compute=False is not yet implemented when ' 'returning bytes') - elif isinstance(path_or_file, basestring): + elif isinstance(path_or_file, str): if engine is None: engine = _get_default_engine(path_or_file) path_or_file = _normalize_path(path_or_file) @@ -733,7 +731,7 @@ def to_netcdf(dataset, path_or_file=None, mode='w', format=None, group=None, if unlimited_dims is None: unlimited_dims = dataset.encoding.get('unlimited_dims', None) - if isinstance(unlimited_dims, basestring): + if isinstance(unlimited_dims, str): unlimited_dims = [unlimited_dims] writer = ArrayWriter() @@ -896,7 +894,7 @@ def to_zarr(dataset, store=None, mode='w-', synchronizer=None, group=None, See `Dataset.to_zarr` for full API docs. """ - if isinstance(store, path_type): + if isinstance(store, Path): store = str(store) if encoding is None: encoding = {} diff --git a/xarray/backends/cfgrib_.py b/xarray/backends/cfgrib_.py index 96095b7b858..51c3318e794 100644 --- a/xarray/backends/cfgrib_.py +++ b/xarray/backends/cfgrib_.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np from .. import Variable diff --git a/xarray/backends/common.py b/xarray/backends/common.py index 405d989f4af..a52daaaa65c 100644 --- a/xarray/backends/common.py +++ b/xarray/backends/common.py @@ -1,16 +1,15 @@ -from __future__ import absolute_import, division, print_function - import logging import time import traceback import warnings -from collections import Mapping, OrderedDict +from collections import OrderedDict +from collections.abc import Mapping import numpy as np from ..conventions import cf_encoder from ..core import indexing -from ..core.pycompat import dask_array_type, iteritems +from ..core.pycompat import dask_array_type from ..core.utils import FrozenOrderedDict, NdimSizeLenMixin # Create a logger object, but don't add any handlers. Leave that to user code. @@ -109,9 +108,9 @@ class SuffixAppendingDataStore(AbstractDataStore): def load(self): variables, attributes = AbstractDataStore.load(self) variables = {'%s_suffix' % k: v - for k, v in iteritems(variables)} + for k, v in variables.items()} attributes = {'%s_suffix' % k: v - for k, v in iteritems(attributes)} + for k, v in attributes.items()} return variables, attributes This function will be called anytime variables or attributes @@ -275,7 +274,7 @@ def set_attributes(self, attributes): attributes : dict-like Dictionary of key/value (attribute name / attribute) pairs """ - for k, v in iteritems(attributes): + for k, v in attributes.items(): self.set_attribute(k, v) def set_variables(self, variables, check_encoding_set, writer, @@ -297,7 +296,7 @@ def set_variables(self, variables, check_encoding_set, writer, dimensions. """ - for vn, v in iteritems(variables): + for vn, v in variables.items(): name = _encode_variable_name(vn) check = vn in check_encoding_set target, source = self.prepare_variable( diff --git a/xarray/backends/h5netcdf_.py b/xarray/backends/h5netcdf_.py index 0564df5b167..b3c4d088913 100644 --- a/xarray/backends/h5netcdf_.py +++ b/xarray/backends/h5netcdf_.py @@ -1,12 +1,10 @@ -from __future__ import absolute_import, division, print_function - import functools +from collections import OrderedDict import numpy as np from .. import Variable from ..core import indexing -from ..core.pycompat import OrderedDict, bytes_type, iteritems, unicode_type from ..core.utils import FrozenOrderedDict, close_on_error from .common import WritableCFDataStore from .file_manager import CachingFileManager @@ -32,7 +30,7 @@ def _getitem(self, key): def maybe_decode_bytes(txt): - if isinstance(txt, bytes_type): + if isinstance(txt, bytes): return txt.decode('utf-8') else: return txt @@ -124,7 +122,7 @@ def open_store_variable(self, name, var): encoding['original_shape'] = var.shape vlen_dtype = h5py.check_dtype(vlen=var.dtype) - if vlen_dtype is unicode_type: + if vlen_dtype is str: encoding['dtype'] = str elif vlen_dtype is not None: # pragma: no cover # xarray doesn't support writing arbitrary vlen dtypes yet. @@ -136,7 +134,7 @@ def open_store_variable(self, name, var): def get_variables(self): return FrozenOrderedDict((k, self.open_store_variable(k, v)) - for k, v in iteritems(self.ds.variables)) + for k, v in self.ds.variables.items()) def get_attrs(self): return FrozenOrderedDict(_read_attributes(self.ds)) @@ -182,7 +180,7 @@ def prepare_variable(self, name, variable, check_encoding=False, 'NC_CHAR type.' % name) if dtype is str: - dtype = h5py.special_dtype(vlen=unicode_type) + dtype = h5py.special_dtype(vlen=str) encoding = _extract_h5nc_encoding(variable, raise_on_invalid=check_encoding) @@ -221,7 +219,7 @@ def prepare_variable(self, name, variable, check_encoding=False, else: nc4_var = self.ds[name] - for k, v in iteritems(attrs): + for k, v in attrs.items(): nc4_var.attrs[k] = v target = H5NetCDFArrayWrapper(name, self) diff --git a/xarray/backends/lru_cache.py b/xarray/backends/lru_cache.py index 321a1ca4da4..e407c384aaf 100644 --- a/xarray/backends/lru_cache.py +++ b/xarray/backends/lru_cache.py @@ -1,8 +1,6 @@ import collections import threading -from ..core.pycompat import move_to_end - class LRUCache(collections.MutableMapping): """Thread-safe LRUCache based on an OrderedDict. @@ -41,7 +39,7 @@ def __getitem__(self, key): # record recent use of the key by moving it to the front of the list with self._lock: value = self._cache[key] - move_to_end(self._cache, key) + self._cache.move_to_end(key) return value def _enforce_size_limit(self, capacity): diff --git a/xarray/backends/memory.py b/xarray/backends/memory.py index 195d4647534..b7161065da8 100644 --- a/xarray/backends/memory.py +++ b/xarray/backends/memory.py @@ -1,10 +1,8 @@ -from __future__ import absolute_import, division, print_function - import copy +from collections import OrderedDict import numpy as np -from ..core.pycompat import OrderedDict from ..core.variable import Variable from .common import AbstractWritableDataStore diff --git a/xarray/backends/netCDF4_.py b/xarray/backends/netCDF4_.py index 9306b24a2fc..92e990f76d5 100644 --- a/xarray/backends/netCDF4_.py +++ b/xarray/backends/netCDF4_.py @@ -1,8 +1,8 @@ -from __future__ import absolute_import, division, print_function - import functools import operator import warnings +from collections import OrderedDict +from contextlib import suppress from distutils.version import LooseVersion import numpy as np @@ -10,7 +10,6 @@ from .. import Variable, coding from ..coding.variables import pop_to from ..core import indexing -from ..core.pycompat import PY3, OrderedDict, basestring, iteritems, suppress from ..core.utils import FrozenOrderedDict, close_on_error, is_remote_uri from .common import ( BackendArray, WritableCFDataStore, find_root, robust_getitem) @@ -81,9 +80,6 @@ def _getitem(self, key): msg = ('The indexing operation you are attempting to perform ' 'is not valid on netCDF4.Variable object. Try loading ' 'your data into memory first by calling .load().') - if not PY3: - import traceback - msg += '\n\nOriginal traceback:\n' + traceback.format_exc() raise IndexError(msg) return array @@ -141,7 +137,7 @@ def _nc4_require_group(ds, group, mode, create_group=_netcdf4_create_group): return ds else: # make sure it's a string - if not isinstance(group, basestring): + if not isinstance(group, str): raise ValueError('group must be a string or None') # support path-like syntax path = group.strip('/').split('/') @@ -392,7 +388,7 @@ def open_store_variable(self, name, var): def get_variables(self): dsvars = FrozenOrderedDict((k, self.open_store_variable(k, v)) for k, v in - iteritems(self.ds.variables)) + self.ds.variables.items()) return dsvars def get_attrs(self): @@ -402,7 +398,7 @@ def get_attrs(self): def get_dimensions(self): dims = FrozenOrderedDict((k, len(v)) - for k, v in iteritems(self.ds.dimensions)) + for k, v in self.ds.dimensions.items()) return dims def get_encoding(self): @@ -467,7 +463,7 @@ def prepare_variable(self, name, variable, check_encoding=False, fill_value=fill_value) _disable_auto_decode_variable(nc4_var) - for k, v in iteritems(attrs): + for k, v in attrs.items(): # set attributes one-by-one since netCDF4<1.0.10 can't handle # OrderedDict as the input to setncatts _set_nc_attribute(nc4_var, k, v) diff --git a/xarray/backends/netcdf3.py b/xarray/backends/netcdf3.py index a6084649442..7f5c8d4b1a7 100644 --- a/xarray/backends/netcdf3.py +++ b/xarray/backends/netcdf3.py @@ -1,11 +1,9 @@ -from __future__ import absolute_import, division, print_function - import unicodedata +from collections import OrderedDict import numpy as np from .. import Variable, coding -from ..core.pycompat import OrderedDict, basestring, unicode_type # Special characters that are permitted in netCDF names except in the # 0th position of the string @@ -50,7 +48,7 @@ def coerce_nc3_dtype(arr): def encode_nc3_attr_value(value): if isinstance(value, bytes): pass - elif isinstance(value, unicode_type): + elif isinstance(value, str): value = value.encode(STRING_ENCODING) else: value = coerce_nc3_dtype(np.atleast_1d(value)) @@ -99,9 +97,9 @@ def is_valid_nc3_name(s): names. Names that have trailing space characters are also not permitted. """ - if not isinstance(s, basestring): + if not isinstance(s, str): return False - if not isinstance(s, unicode_type): + if not isinstance(s, str): s = s.decode('utf-8') num_bytes = len(s.encode('utf-8')) return ((unicodedata.normalize('NFC', s) == s) and diff --git a/xarray/backends/pseudonetcdf_.py b/xarray/backends/pseudonetcdf_.py index 81b5722db78..35b14b10672 100644 --- a/xarray/backends/pseudonetcdf_.py +++ b/xarray/backends/pseudonetcdf_.py @@ -1,10 +1,9 @@ -from __future__ import absolute_import, division, print_function +from collections import OrderedDict import numpy as np from .. import Variable from ..core import indexing -from ..core.pycompat import OrderedDict from ..core.utils import Frozen, FrozenOrderedDict from .common import AbstractDataStore, BackendArray from .file_manager import CachingFileManager diff --git a/xarray/backends/pydap_.py b/xarray/backends/pydap_.py index 71ea4841b71..b555c35c859 100644 --- a/xarray/backends/pydap_.py +++ b/xarray/backends/pydap_.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np from .. import Variable diff --git a/xarray/backends/pynio_.py b/xarray/backends/pynio_.py index 03507ab6c2c..0995a39019d 100644 --- a/xarray/backends/pynio_.py +++ b/xarray/backends/pynio_.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np from .. import Variable diff --git a/xarray/backends/rasterio_.py b/xarray/backends/rasterio_.py index 26d408d50f6..b7726611597 100644 --- a/xarray/backends/rasterio_.py +++ b/xarray/backends/rasterio_.py @@ -2,6 +2,7 @@ import warnings from collections import OrderedDict from distutils.version import LooseVersion + import numpy as np from .. import DataArray diff --git a/xarray/backends/scipy_.py b/xarray/backends/scipy_.py index 5739c1a8617..1111f30c139 100644 --- a/xarray/backends/scipy_.py +++ b/xarray/backends/scipy_.py @@ -1,6 +1,5 @@ -from __future__ import absolute_import, division, print_function - import warnings +from collections import OrderedDict from distutils.version import LooseVersion from io import BytesIO @@ -8,7 +7,6 @@ from .. import Variable from ..core.indexing import NumpyIndexingAdapter -from ..core.pycompat import OrderedDict, basestring, iteritems from ..core.utils import Frozen, FrozenOrderedDict from .common import BackendArray, WritableCFDataStore from .file_manager import CachingFileManager, DummyFileManager @@ -27,7 +25,7 @@ def _decode_attrs(d): # don't decode _FillValue from bytes -> unicode, because we want to ensure # that its type matches the data exactly return OrderedDict((k, v if k == '_FillValue' else _decode_string(v)) - for (k, v) in iteritems(d)) + for (k, v) in d.items()) class ScipyArrayWrapper(BackendArray): @@ -70,7 +68,7 @@ def _open_scipy_netcdf(filename, mode, mmap, version): import gzip # if the string ends with .gz, then gunzip and open as netcdf file - if isinstance(filename, basestring) and filename.endswith('.gz'): + if isinstance(filename, str) and filename.endswith('.gz'): try: return scipy.io.netcdf_file(gzip.open(filename), mode=mode, mmap=mmap, version=version) @@ -139,12 +137,12 @@ def __init__(self, filename_or_obj, mode='r', format=None, group=None, % format) if (lock is None and mode != 'r' and - isinstance(filename_or_obj, basestring)): + isinstance(filename_or_obj, str)): lock = get_write_lock(filename_or_obj) self.lock = ensure_lock(lock) - if isinstance(filename_or_obj, basestring): + if isinstance(filename_or_obj, str): manager = CachingFileManager( _open_scipy_netcdf, filename_or_obj, mode=mode, lock=lock, kwargs=dict(mmap=mmap, version=version)) @@ -165,7 +163,7 @@ def open_store_variable(self, name, var): def get_variables(self): return FrozenOrderedDict((k, self.open_store_variable(k, v)) - for k, v in iteritems(self.ds.variables)) + for k, v in self.ds.variables.items()) def get_attrs(self): return Frozen(_decode_attrs(self.ds._attributes)) @@ -213,7 +211,7 @@ def prepare_variable(self, name, variable, check_encoding=False, if name not in self.ds.variables: self.ds.createVariable(name, data.dtype, variable.dims) scipy_var = self.ds.variables[name] - for k, v in iteritems(variable.attrs): + for k, v in variable.attrs.items(): self._validate_attr_key(k) setattr(scipy_var, k, v) diff --git a/xarray/backends/zarr.py b/xarray/backends/zarr.py index feefaf1735f..ee77e0833c4 100644 --- a/xarray/backends/zarr.py +++ b/xarray/backends/zarr.py @@ -1,12 +1,11 @@ -from __future__ import absolute_import, division, print_function - +from collections import OrderedDict from distutils.version import LooseVersion import numpy as np from .. import Variable, coding, conventions from ..core import indexing -from ..core.pycompat import OrderedDict, integer_types, iteritems +from ..core.pycompat import integer_types from ..core.utils import FrozenOrderedDict, HiddenKeyDict from .common import AbstractWritableDataStore, BackendArray @@ -331,7 +330,7 @@ def prepare_variable(self, name, variable, check_encoding=False, encoded_attrs = OrderedDict() # the magic for storing the hidden dimension data encoded_attrs[_DIMENSION_KEY] = dims - for k, v in iteritems(attrs): + for k, v in attrs.items(): encoded_attrs[k] = self.encode_attribute(v) zarr_array = self.ds.create(name, shape=shape, dtype=dtype, diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index 98571c9a995..a373aeff747 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -47,7 +47,6 @@ import numpy as np -from ..core.pycompat import basestring from .cftimeindex import CFTimeIndex, _parse_iso8601_with_reso from .times import format_cftime_datetime @@ -452,7 +451,7 @@ def to_offset(freq): def to_cftime_datetime(date_str_or_date, calendar=None): import cftime - if isinstance(date_str_or_date, basestring): + if isinstance(date_str_or_date, str): if calendar is None: raise ValueError( 'If converting a string to a cftime.datetime object, ' diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index af22a3219ad..1861d49a1d4 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -39,8 +39,6 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -from __future__ import absolute_import - import re import warnings from datetime import timedelta @@ -49,7 +47,6 @@ import numpy as np import pandas as pd -from xarray.core import pycompat from xarray.core.utils import is_scalar from .times import _STANDARD_CALENDARS, cftime_to_nptime, infer_calendar_name @@ -314,7 +311,7 @@ def _get_string_slice(self, key): def get_loc(self, key, method=None, tolerance=None): """Adapted from pandas.tseries.index.DatetimeIndex.get_loc""" - if isinstance(key, pycompat.basestring): + if isinstance(key, str): return self._get_string_slice(key) else: return pd.Index.get_loc(self, key, method=method, @@ -323,7 +320,7 @@ def get_loc(self, key, method=None, tolerance=None): def _maybe_cast_slice_bound(self, label, side, kind): """Adapted from pandas.tseries.index.DatetimeIndex._maybe_cast_slice_bound""" - if isinstance(label, pycompat.basestring): + if isinstance(label, str): parsed, resolution = _parse_iso8601_with_reso(self.date_type, label) start, end = _parsed_string_to_bounds(self.date_type, resolution, @@ -393,7 +390,7 @@ def shift(self, n, freq): raise TypeError("'n' must be an int, got {}.".format(n)) if isinstance(freq, timedelta): return self + n * freq - elif isinstance(freq, pycompat.basestring): + elif isinstance(freq, str): return self + n * to_offset(freq) else: raise TypeError( diff --git a/xarray/coding/strings.py b/xarray/coding/strings.py index 3502fd773d7..205d285cd81 100644 --- a/xarray/coding/strings.py +++ b/xarray/coding/strings.py @@ -1,12 +1,10 @@ """Coders for strings.""" -from __future__ import absolute_import, division, print_function - from functools import partial import numpy as np from ..core import indexing -from ..core.pycompat import bytes_type, dask_array_type, unicode_type +from ..core.pycompat import dask_array_type from ..core.variable import Variable from .variables import ( VariableCoder, lazy_elemwise_func, pop_to, safe_setitem, @@ -26,11 +24,11 @@ def check_vlen_dtype(dtype): def is_unicode_dtype(dtype): - return dtype.kind == 'U' or check_vlen_dtype(dtype) == unicode_type + return dtype.kind == 'U' or check_vlen_dtype(dtype) == str def is_bytes_dtype(dtype): - return dtype.kind == 'S' or check_vlen_dtype(dtype) == bytes_type + return dtype.kind == 'S' or check_vlen_dtype(dtype) == bytes class EncodedStringCoder(VariableCoder): @@ -90,7 +88,7 @@ def encode_string_array(string_array, encoding='utf-8'): def ensure_fixed_length_bytes(var): """Ensure that a variable with vlen bytes is converted to fixed width.""" dims, data, attrs, encoding = unpack_for_encoding(var) - if check_vlen_dtype(data.dtype) == bytes_type: + if check_vlen_dtype(data.dtype) == bytes: # TODO: figure out how to handle this with dask data = np.asarray(data, dtype=np.string_) return Variable(dims, data, attrs, encoding) diff --git a/xarray/coding/times.py b/xarray/coding/times.py index c337a42e3b4..459e9e0956d 100644 --- a/xarray/coding/times.py +++ b/xarray/coding/times.py @@ -1,7 +1,4 @@ -from __future__ import absolute_import, division, print_function - import re -import traceback import warnings from datetime import datetime from functools import partial @@ -12,7 +9,6 @@ from ..core import indexing from ..core.common import contains_cftime_datetimes from ..core.formatting import first_n_items, format_timestamp, last_item -from ..core.pycompat import PY3 from ..core.variable import Variable from .variables import ( SerializationWarning, VariableCoder, lazy_elemwise_func, pop_to, @@ -126,8 +122,6 @@ def _decode_cf_datetime_dtype(data, units, calendar): msg = ('unable to decode time units %r with %s. Try ' 'opening your dataset with decode_times=False.' % (units, calendar_msg)) - if not PY3: - msg += ' Full traceback:\n' + traceback.format_exc() raise ValueError(msg) else: dtype = getattr(result, 'dtype', np.dtype('object')) diff --git a/xarray/coding/variables.py b/xarray/coding/variables.py index d8453a95fad..1f74181f3b3 100644 --- a/xarray/coding/variables.py +++ b/xarray/coding/variables.py @@ -1,6 +1,4 @@ """Coders for individual Variable objects.""" -from __future__ import absolute_import, division, print_function - from typing import Any import warnings from functools import partial diff --git a/xarray/conventions.py b/xarray/conventions.py index ea85a6d5b74..c1c95a6b60e 100644 --- a/xarray/conventions.py +++ b/xarray/conventions.py @@ -1,7 +1,5 @@ -from __future__ import absolute_import, division, print_function - import warnings -from collections import defaultdict +from collections import OrderedDict, defaultdict import numpy as np import pandas as pd @@ -9,9 +7,7 @@ from .coding import strings, times, variables from .coding.variables import SerializationWarning from .core import duck_array_ops, indexing -from .core.pycompat import ( - OrderedDict, basestring, bytes_type, dask_array_type, iteritems, - unicode_type) +from .core.pycompat import dask_array_type from .core.variable import IndexVariable, Variable, as_variable @@ -127,7 +123,7 @@ def _infer_dtype(array, name=None): return np.dtype(float) element = array[(0,) * array.ndim] - if isinstance(element, (bytes_type, unicode_type)): + if isinstance(element, (bytes, str)): return strings.create_vlen_dtype(type(element)) dtype = np.array(element).dtype @@ -372,7 +368,7 @@ def stackable(dim): coord_names = set() - if isinstance(drop_variables, basestring): + if isinstance(drop_variables, str): drop_variables = [drop_variables] elif drop_variables is None: drop_variables = [] @@ -383,7 +379,7 @@ def stackable(dim): _update_bounds_attributes(variables) new_vars = OrderedDict() - for k, v in iteritems(variables): + for k, v in variables.items(): if k in drop_variables: continue stack_char_dim = (concat_characters and v.dtype == 'S1' and @@ -507,7 +503,7 @@ def _encode_coordinates(variables, attributes, non_dim_coord_names): non_dim_coord_names = set(non_dim_coord_names) for name in list(non_dim_coord_names): - if isinstance(name, basestring) and ' ' in name: + if isinstance(name, str) and ' ' in name: warnings.warn( 'coordinate {!r} has a space in its name, which means it ' 'cannot be marked as a coordinate on disk and will be ' @@ -602,5 +598,5 @@ def cf_encoder(variables, attributes): See also: encode_cf_variable """ new_vars = OrderedDict((k, encode_cf_variable(v, name=k)) - for k, v in iteritems(variables)) + for k, v in variables.items()) return new_vars, attributes diff --git a/xarray/convert.py b/xarray/convert.py index 6cff72103ff..efcdd079a9f 100644 --- a/xarray/convert.py +++ b/xarray/convert.py @@ -1,8 +1,6 @@ """Functions for converting to and from xarray objects """ -from __future__ import absolute_import, division, print_function - -from collections import Counter +from collections import Counter, OrderedDict import numpy as np import pandas as pd @@ -12,7 +10,6 @@ from .core import duck_array_ops from .core.dataarray import DataArray from .core.dtypes import get_fill_value -from .core.pycompat import OrderedDict, range cdms2_ignored_attrs = {'name', 'tileIndex'} iris_forbidden_keys = {'standard_name', 'long_name', 'units', 'bounds', 'axis', diff --git a/xarray/core/accessors.py b/xarray/core/accessors.py index 72791ed73ec..10c900c4ad1 100644 --- a/xarray/core/accessors.py +++ b/xarray/core/accessors.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np import pandas as pd diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index 789bea90b55..278548cca8c 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -1,15 +1,13 @@ -from __future__ import absolute_import, division, print_function - import functools import operator import warnings -from collections import defaultdict +from collections import OrderedDict, defaultdict +from contextlib import suppress import numpy as np from . import utils from .indexing import get_indexer_nd -from .pycompat import OrderedDict, iteritems, suppress from .utils import is_dict_like, is_full_slice from .variable import IndexVariable @@ -116,7 +114,7 @@ def align(*objects, **kwargs): # pandas). This is useful, e.g., for overwriting such duplicate indexes. joiner = _get_joiner(join) joined_indexes = {} - for dim, matching_indexes in iteritems(all_indexes): + for dim, matching_indexes in all_indexes.items(): if dim in indexes: index = utils.safe_cast_to_index(indexes[dim]) if (any(not index.equals(other) for other in matching_indexes) or @@ -315,7 +313,7 @@ def reindex_variables(variables, sizes, indexes, indexers, method=None, # size of reindexed dimensions new_sizes = {} - for name, index in iteritems(indexes): + for name, index in indexes.items(): if name in indexers: if not index.is_unique: raise ValueError( @@ -366,7 +364,7 @@ def reindex_variables(variables, sizes, indexes, indexers, method=None, args = () reindexed[dim] = IndexVariable((dim,), indexers[dim], *args) - for name, var in iteritems(variables): + for name, var in variables.items(): if name not in indexers: key = tuple(slice(None) if d in unchanged_dims diff --git a/xarray/core/arithmetic.py b/xarray/core/arithmetic.py index a3bb135af24..39901f0befd 100644 --- a/xarray/core/arithmetic.py +++ b/xarray/core/arithmetic.py @@ -1,12 +1,10 @@ """Base classes implementing arithmetic for xarray objects.""" -from __future__ import absolute_import, division, print_function - import numbers import numpy as np from .options import OPTIONS -from .pycompat import bytes_type, dask_array_type, unicode_type +from .pycompat import dask_array_type from .utils import not_implemented @@ -21,8 +19,8 @@ class SupportsArithmetic(object): # numpy.lib.mixins.NDArrayOperatorsMixin. # TODO: allow extending this with some sort of registration system - _HANDLED_TYPES = (np.ndarray, np.generic, numbers.Number, bytes_type, - unicode_type) + dask_array_type + _HANDLED_TYPES = (np.ndarray, np.generic, numbers.Number, bytes, + str) + dask_array_type def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): from .computation import apply_ufunc diff --git a/xarray/core/combine.py b/xarray/core/combine.py index 0327a65ab1b..11961dff520 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -1,15 +1,12 @@ -from __future__ import absolute_import, division, print_function - import itertools import warnings -from collections import Counter +from collections import Counter, OrderedDict import pandas as pd from . import utils from .alignment import align from .merge import merge -from .pycompat import OrderedDict, basestring, iteritems from .variable import IndexVariable, Variable, as_variable from .variable import concat as concat_vars @@ -129,7 +126,7 @@ def _calc_concat_dim_coord(dim): """ from .dataarray import DataArray - if isinstance(dim, basestring): + if isinstance(dim, str): coord = None elif not isinstance(dim, (DataArray, Variable)): dim_name = getattr(dim, 'name', None) @@ -162,7 +159,7 @@ def _calc_concat_over(datasets, dim, data_vars, coords): if dim in v.dims) def process_subset_opt(opt, subset): - if isinstance(opt, basestring): + if isinstance(opt, str): if opt == 'different': # all nonindexes that are not the same in each dataset for k in getattr(datasets[0], subset): @@ -253,7 +250,7 @@ def insert_result_variable(k, v): if (compat == 'identical' and not utils.dict_equiv(ds.attrs, result_attrs)): raise ValueError('dataset global attributes not equal') - for k, v in iteritems(ds.variables): + for k, v in ds.variables.items(): if k not in result_vars and k not in concat_over: raise ValueError('encountered unexpected variable %r' % k) elif (k in result_coord_names) != (k in ds.coords): diff --git a/xarray/core/common.py b/xarray/core/common.py index d272115f492..f50b5bfedf4 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -1,5 +1,5 @@ -from __future__ import absolute_import, division, print_function - +from collections import OrderedDict +from contextlib import suppress from textwrap import dedent import numpy as np @@ -8,7 +8,7 @@ from . import dtypes, duck_array_ops, formatting, ops from .arithmetic import SupportsArithmetic from .options import _get_keep_attrs -from .pycompat import OrderedDict, basestring, dask_array_type, suppress +from .pycompat import dask_array_type from .utils import Frozen, ReprObject, SortedKeysDict, either_dict_or_kwargs # Used as a sentinel value to indicate a all dimensions @@ -75,7 +75,7 @@ def wrapped_func(self, dim=None, **kwargs): # type: ignore and 'axis' arguments can be supplied.""" -class AbstractArray(ImplementsArrayReduce, formatting.ReprMixin): +class AbstractArray(ImplementsArrayReduce): """Shared base class for DataArray and Variable.""" def __bool__(self): @@ -128,7 +128,7 @@ def get_axis_num(self, dim): int or tuple of int Axis number or numbers corresponding to the given dimensions. """ - if isinstance(dim, basestring): + if isinstance(dim, str): return self._get_axis_num(dim) else: return tuple(self._get_axis_num(d) for d in dim) @@ -199,7 +199,7 @@ def __dir__(self): extra_attrs = [item for sublist in self._attr_sources for item in sublist - if isinstance(item, basestring)] + if isinstance(item, str)] return sorted(set(dir(type(self)) + extra_attrs)) def _ipython_key_completions_(self): @@ -210,7 +210,7 @@ def _ipython_key_completions_(self): item_lists = [item for sublist in self._item_sources for item in sublist - if isinstance(item, basestring)] + if isinstance(item, str)] return list(set(item_lists)) @@ -223,7 +223,7 @@ def get_squeeze_dims(xarray_obj, dim, axis=None): if dim is None and axis is None: dim = [d for d, s in xarray_obj.sizes.items() if s == 1] else: - if isinstance(dim, basestring): + if isinstance(dim, str): dim = [dim] if isinstance(axis, int): axis = (axis, ) diff --git a/xarray/core/computation.py b/xarray/core/computation.py index bf9ab56bbb4..b9303a5681d 100644 --- a/xarray/core/computation.py +++ b/xarray/core/computation.py @@ -1,12 +1,10 @@ """ Functions for applying functions that act on arrays to xarray's labeled data. """ -from __future__ import absolute_import, division, print_function - import functools import itertools import operator -from collections import Counter +from collections import Counter, OrderedDict from distutils.version import LooseVersion from typing import ( AbstractSet, Any, Dict, Iterable, List, Mapping, Union, Tuple, @@ -18,7 +16,7 @@ from . import duck_array_ops, utils from .alignment import deep_align from .merge import expand_and_merge_variables -from .pycompat import OrderedDict, basestring, dask_array_type +from .pycompat import dask_array_type from .utils import is_dict_like from .variable import Variable if TYPE_CHECKING: @@ -1043,7 +1041,7 @@ def dot(*arrays, **kwargs): if len(arrays) == 0: raise TypeError('At least one array should be given.') - if isinstance(dims, basestring): + if isinstance(dims, str): dims = (dims, ) common_dims = set.intersection(*[set(arr.dims) for arr in arrays]) diff --git a/xarray/core/coordinates.py b/xarray/core/coordinates.py index 820937dae6a..7c62d5fd7b5 100644 --- a/xarray/core/coordinates.py +++ b/xarray/core/coordinates.py @@ -1,6 +1,4 @@ -from __future__ import absolute_import, division, print_function - -from collections import Mapping +from collections import Mapping, OrderedDict from contextlib import contextmanager import pandas as pd @@ -8,7 +6,6 @@ from . import formatting, indexing from .merge import ( expand_and_merge_variables, merge_coords, merge_coords_for_inplace_math) -from .pycompat import OrderedDict from .utils import Frozen, ReprObject, either_dict_or_kwargs from .variable import Variable @@ -17,7 +14,7 @@ _THIS_ARRAY = ReprObject('') -class AbstractCoordinates(Mapping, formatting.ReprMixin): +class AbstractCoordinates(Mapping): def __getitem__(self, key): raise NotImplementedError @@ -47,7 +44,7 @@ def __len__(self): def __contains__(self, key): return key in self._names - def __unicode__(self): + def __repr__(self): return formatting.coords_repr(self) @property diff --git a/xarray/core/dask_array_compat.py b/xarray/core/dask_array_compat.py index 6b53dcffe6e..d8f6c0d8a11 100644 --- a/xarray/core/dask_array_compat.py +++ b/xarray/core/dask_array_compat.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - from distutils.version import LooseVersion import dask.array as da @@ -35,7 +33,7 @@ def isin(element, test_elements, assume_unique=False, invert=False): return result -if LooseVersion(dask_version) > LooseVersion('1.19.2'): +if LooseVersion(dask_version) > LooseVersion('0.19.2'): gradient = da.gradient else: # pragma: no cover diff --git a/xarray/core/dask_array_ops.py b/xarray/core/dask_array_ops.py index 25c572edd54..7e72c93da27 100644 --- a/xarray/core/dask_array_ops.py +++ b/xarray/core/dask_array_ops.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - from distutils.version import LooseVersion import numpy as np diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index aa6c35394fb..3c8344f4514 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -1,7 +1,6 @@ -from __future__ import absolute_import, division, print_function - import functools import warnings +from collections import OrderedDict import numpy as np import pandas as pd @@ -19,7 +18,6 @@ from .formatting import format_item from .indexes import default_indexes, Indexes from .options import OPTIONS -from .pycompat import OrderedDict, basestring, iteritems, range, zip from .utils import ( _check_inplace, decode_numpy_dict_values, either_dict_or_kwargs, ensure_us_time_resolution) @@ -37,7 +35,7 @@ def _infer_coords_and_dims(shape, coords, dims): 'which does not match the %s dimensions of the ' 'data' % (len(coords), len(shape))) - if isinstance(dims, basestring): + if isinstance(dims, str): dims = (dims,) if dims is None: @@ -57,7 +55,7 @@ def _infer_coords_and_dims(shape, coords, dims): dims = tuple(dims) else: for d in dims: - if not isinstance(d, basestring): + if not isinstance(d, str): raise TypeError('dimension %s is not a string' % d) new_coords = OrderedDict() @@ -475,14 +473,14 @@ def _getitem_coord(self, key): return self._replace_maybe_drop_dims(var, name=key) def __getitem__(self, key): - if isinstance(key, basestring): + if isinstance(key, str): return self._getitem_coord(key) else: # xarray-style array indexing return self.isel(indexers=self._item_key_to_dict(key)) def __setitem__(self, key, value): - if isinstance(key, basestring): + if isinstance(key, str): self.coords[key] = value else: # Coordinates in key, value and self[key] should be consistent. @@ -1313,9 +1311,9 @@ def stack(self, dimensions=None, **dimensions_kwargs): * y (y) int64 0 1 2 >>> stacked = arr.stack(z=('x', 'y')) >>> stacked.indexes['z'] - MultiIndex(levels=[[u'a', u'b'], [0, 1, 2]], + MultiIndex(levels=[['a', 'b'], [0, 1, 2]], labels=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]], - names=[u'x', u'y']) + names=['x', 'y']) See also -------- @@ -1356,9 +1354,9 @@ def unstack(self, dim=None): * y (y) int64 0 1 2 >>> stacked = arr.stack(z=('x', 'y')) >>> stacked.indexes['z'] - MultiIndex(levels=[[u'a', u'b'], [0, 1, 2]], + MultiIndex(levels=[['a', 'b'], [0, 1, 2]], labels=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]], - names=[u'x', u'y']) + names=['x', 'y']) >>> roundtripped = stacked.unstack() >>> arr.identical(roundtripped) True @@ -2041,7 +2039,7 @@ def _title_for_slice(self, truncate=50): """ one_dims = [] - for dim, coord in iteritems(self.coords): + for dim, coord in self.coords.items(): if coord.size == 1: one_dims.append('{dim} = {v}'.format( dim=dim, v=format_item(coord.values))) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 3f1c038fc11..711dfcdce71 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -1,9 +1,8 @@ -from __future__ import absolute_import, division, print_function - import functools import sys import warnings -from collections import Mapping, defaultdict +from collections import OrderedDict, defaultdict +from collections.abc import Mapping from distutils.version import LooseVersion from numbers import Number from typing import Any, Dict, List, Set, Tuple, Union @@ -29,8 +28,7 @@ dataset_merge_method, dataset_update_method, merge_data_and_coords, merge_variables) from .options import OPTIONS, _get_keep_attrs -from .pycompat import ( - OrderedDict, basestring, dask_array_type, iteritems, range) +from .pycompat import dask_array_type from .utils import ( Frozen, SortedKeysDict, _check_inplace, datetime_to_numeric, decode_numpy_dict_values, either_dict_or_kwargs, ensure_us_time_resolution, @@ -58,7 +56,7 @@ def _get_virtual_variable(variables, key, level_vars=None, dim_sizes=None): variable = IndexVariable((key,), data) return key, key, variable - if not isinstance(key, basestring): + if not isinstance(key, str): raise KeyError(key) split_key = key.split('.', 1) @@ -97,8 +95,8 @@ def calculate_dimensions(variables): """ dims = OrderedDict() last_used = {} - scalar_vars = set(k for k, v in iteritems(variables) if not v.dims) - for k, var in iteritems(variables): + scalar_vars = set(k for k, v in variables.items() if not v.dims) + for k, var in variables.items(): for dim, size in zip(var.dims, var.shape): if dim in scalar_vars: raise ValueError('dimension %r already exists as a scalar ' @@ -129,7 +127,7 @@ def merge_indexes( vars_to_remove = [] # type: list for dim, var_names in indexes.items(): - if isinstance(var_names, basestring): + if isinstance(var_names, str): var_names = [var_names] names, labels, levels = [], [], [] # type: (list, list, list) @@ -171,7 +169,7 @@ def merge_indexes( vars_to_replace[dim] = IndexVariable(dim, idx) vars_to_remove.extend(var_names) - new_variables = OrderedDict([(k, v) for k, v in iteritems(variables) + new_variables = OrderedDict([(k, v) for k, v in variables.items() if k not in vars_to_remove]) new_variables.update(vars_to_replace) new_coord_names = coord_names | set(vars_to_replace) @@ -193,7 +191,7 @@ def split_indexes( Not public API. Used in Dataset and DataArray reset_index methods. """ - if isinstance(dims_or_levels, basestring): + if isinstance(dims_or_levels, str): dims_or_levels = [dims_or_levels] dim_levels = defaultdict(list) # type: Dict[Any, list] @@ -257,7 +255,7 @@ def as_dataset(obj): return obj -class DataVariables(Mapping, formatting.ReprMixin): +class DataVariables(Mapping): def __init__(self, dataset): self._dataset = dataset @@ -278,7 +276,7 @@ def __getitem__(self, key): else: raise KeyError(key) - def __unicode__(self): + def __repr__(self): return formatting.data_vars_repr(self) @property @@ -302,8 +300,7 @@ def __getitem__(self, key): return self.dataset.sel(**key) -class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords, - formatting.ReprMixin): +class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): """A multi-dimensional, in memory, array database. A dataset resembles an in-memory representation of a NetCDF file, and @@ -825,7 +822,7 @@ def copy(self, deep=False, data=None): """ # noqa if data is None: variables = OrderedDict((k, v.copy(deep=deep)) - for k, v in iteritems(self._variables)) + for k, v in self._variables.items()) elif not utils.is_dict_like(data): raise ValueError('Data must be dict-like') else: @@ -844,7 +841,7 @@ def copy(self, deep=False, data=None): 'dataset. Data is missing {}' .format(keys_missing_from_data)) variables = OrderedDict((k, v.copy(deep=deep, data=data.get(k))) - for k, v in iteritems(self._variables)) + for k, v in self._variables.items()) # skip __init__ to avoid costly validation return self._construct_direct(variables, self._coord_names.copy(), @@ -1119,7 +1116,7 @@ def set_coords(self, names, inplace=None): # nb. check in self._variables, not self.data_vars to insure that the # operation is idempotent inplace = _check_inplace(inplace) - if isinstance(names, basestring): + if isinstance(names, str): names = [names] self._assert_all_in_dataset(names) obj = self if inplace else self.copy() @@ -1149,7 +1146,7 @@ def reset_coords(self, names=None, drop=False, inplace=None): if names is None: names = self._coord_names - set(self.dims) else: - if isinstance(names, basestring): + if isinstance(names, str): names = [names] self._assert_all_in_dataset(names) bad_coords = set(names) & set(self.dims) @@ -1290,7 +1287,7 @@ def to_zarr(self, store=None, mode='w-', synchronizer=None, group=None, group=group, encoding=encoding, compute=compute, consolidated=consolidated) - def __unicode__(self): + def __repr__(self): return formatting.dataset_repr(self) def info(self, buf=None): @@ -1311,24 +1308,24 @@ def info(self, buf=None): buf = sys.stdout lines = [] - lines.append(u'xarray.Dataset {') - lines.append(u'dimensions:') + lines.append('xarray.Dataset {') + lines.append('dimensions:') for name, size in self.dims.items(): - lines.append(u'\t{name} = {size} ;'.format(name=name, size=size)) - lines.append(u'\nvariables:') + lines.append('\t{name} = {size} ;'.format(name=name, size=size)) + lines.append('\nvariables:') for name, da in self.variables.items(): - dims = u', '.join(da.dims) - lines.append(u'\t{type} {name}({dims}) ;'.format( + dims = ', '.join(da.dims) + lines.append('\t{type} {name}({dims}) ;'.format( type=da.dtype, name=name, dims=dims)) for k, v in da.attrs.items(): - lines.append(u'\t\t{name}:{k} = {v} ;'.format(name=name, k=k, - v=v)) - lines.append(u'\n// global attributes:') + lines.append('\t\t{name}:{k} = {v} ;'.format(name=name, k=k, + v=v)) + lines.append('\n// global attributes:') for k, v in self.attrs.items(): - lines.append(u'\t:{k} = {v} ;'.format(k=k, v=v)) - lines.append(u'}') + lines.append('\t:{k} = {v} ;'.format(k=k, v=v)) + lines.append('}') - buf.write(u'\n'.join(lines)) + buf.write('\n'.join(lines)) @property def chunks(self): @@ -1424,7 +1421,7 @@ def _validate_indexers(self, indexers): # all indexers should be int, slice, np.ndarrays, or Variable indexers_list = [] - for k, v in iteritems(indexers): + for k, v in indexers.items(): if isinstance(v, (slice, Variable)): pass elif isinstance(v, DataArray): @@ -1537,7 +1534,7 @@ def isel(self, indexers=None, drop=False, **indexers_kwargs): indexers_list = self._validate_indexers(indexers) variables = OrderedDict() - for name, var in iteritems(self._variables): + for name, var in self._variables.items(): var_indexers = {k: v for k, v in indexers_list if k in var.dims} new_var = var.isel(indexers=var_indexers) if not (drop and name in var_indexers): @@ -1686,7 +1683,7 @@ def relevant_keys(mapping): coords = relevant_keys(self.coords) indexers = [(k, np.asarray(v)) # type: ignore - for k, v in iteritems(indexers)] + for k, v in indexers.items()] indexers_dict = dict(indexers) non_indexed_dims = set(self.dims) - indexer_dims non_indexed_coords = set(self.coords) - set(coords) @@ -1707,7 +1704,7 @@ def relevant_keys(mapping): raise ValueError('All indexers must be the same length') # Existing dimensions are not valid choices for the dim argument - if isinstance(dim, basestring): + if isinstance(dim, str): if dim in self.dims: # dim is an invalid string raise ValueError('Existing dimension names are not valid ' @@ -1999,7 +1996,7 @@ def _validate_interp_indexer(x, new_x): return (x, new_x) variables = OrderedDict() - for name, var in iteritems(obj._variables): + for name, var in obj._variables.items(): if name not in indexers: if var.dtype.kind in 'uifc': var_indexers = {k: _validate_interp_indexer( @@ -2115,7 +2112,7 @@ def rename(self, name_dict=None, inplace=None, **names): variables = OrderedDict() coord_names = set() - for k, v in iteritems(self._variables): + for k, v in self._variables.items(): name = name_dict.get(k, k) dims = tuple(name_dict.get(dim, dim) for dim in v.dims) var = v.copy(deep=False) @@ -2173,7 +2170,7 @@ def swap_dims(self, dims_dict, inplace=None): coord_names = self._coord_names.copy() coord_names.update(dims_dict.values()) - for k, v in iteritems(self.variables): + for k, v in self.variables.items(): dims = tuple(dims_dict.get(dim, dim) for dim in v.dims) if k in result_dims: var = v.to_index_variable() @@ -2212,7 +2209,7 @@ def expand_dims(self, dim, axis=None): if isinstance(dim, int): raise ValueError('dim should be str or sequence of strs or dict') - if isinstance(dim, basestring): + if isinstance(dim, str): dim = [dim] if axis is not None and not isinstance(axis, (list, tuple)): axis = [axis] @@ -2236,7 +2233,7 @@ def expand_dims(self, dim, axis=None): raise ValueError('dims should not contain duplicate values.') variables = OrderedDict() - for k, v in iteritems(self._variables): + for k, v in self._variables.items(): if k not in dim: if k in self._coord_names: # Do not change coordinates variables[k] = v @@ -2501,7 +2498,7 @@ def unstack(self, dim=None): dims = [d for d in self.dims if isinstance(self.get_index(d), pd.MultiIndex)] else: - dims = [dim] if isinstance(dim, basestring) else dim + dims = [dim] if isinstance(dim, str) else dim missing_dims = [d for d in dims if d not in self.dims] if missing_dims: @@ -2644,7 +2641,7 @@ def drop(self, labels, dim=None): def _drop_vars(self, names): self._assert_all_in_dataset(names) drop = set(names) - variables = OrderedDict((k, v) for k, v in iteritems(self._variables) + variables = OrderedDict((k, v) for k, v in self._variables.items() if k not in drop) coord_names = set(k for k in self._coord_names if k in variables) return self._replace_vars_and_dims(variables, coord_names) @@ -2683,7 +2680,7 @@ def transpose(self, *dims): 'permuted dataset dimensions (%s)' % (dims, tuple(self.dims))) ds = self.copy() - for name, var in iteritems(self._variables): + for name, var in self._variables.items(): var_dims = tuple(dim for dim in dims if dim in var.dims) ds._variables[name] = var.transpose(*var_dims) return ds @@ -2920,7 +2917,7 @@ def reduce(self, func, dim=None, keep_attrs=None, numeric_only=False, """ if dim is ALL_DIMS: dim = None - if isinstance(dim, basestring): + if isinstance(dim, str): dims = set([dim]) elif dim is None: dims = set(self.dims) @@ -2936,7 +2933,7 @@ def reduce(self, func, dim=None, keep_attrs=None, numeric_only=False, keep_attrs = _get_keep_attrs(default=False) variables = OrderedDict() - for name, var in iteritems(self._variables): + for name, var in self._variables.items(): reduce_dims = [d for d in var.dims if d in dims] if name in self.coords: if not reduce_dims: @@ -3007,7 +3004,7 @@ def apply(self, func, keep_attrs=None, args=(), **kwargs): """ # noqa variables = OrderedDict( (k, maybe_wrap_array(v, func(v, *args, **kwargs))) - for k, v in iteritems(self.data_vars)) + for k, v in self.data_vars.items()) if keep_attrs is None: keep_attrs = _get_keep_attrs(default=False) attrs = self.attrs if keep_attrs else None @@ -3140,7 +3137,7 @@ def from_dataframe(cls, dataframe): obj[dims[0]] = (dims, idx) shape = -1 - for name, series in iteritems(dataframe): + for name, series in dataframe.items(): data = np.asarray(series).reshape(shape) obj[name] = (dims, data) return obj @@ -3471,7 +3468,7 @@ def diff(self, dim, n=1, label='upper'): variables = OrderedDict() - for name, var in iteritems(self.variables): + for name, var in self.variables.items(): if dim in var.dims: if name in self.data_vars: variables[name] = (var.isel(**kwargs_end) - @@ -3534,7 +3531,7 @@ def shift(self, shifts=None, fill_value=dtypes.NA, **shifts_kwargs): raise ValueError("dimensions %r do not exist" % invalid) variables = OrderedDict() - for name, var in iteritems(self.variables): + for name, var in self.variables.items(): if name in self.data_vars: var_shifts = {k: v for k, v in shifts.items() if k in var.dims} @@ -3603,7 +3600,7 @@ def roll(self, shifts=None, roll_coords=None, **shifts_kwargs): unrolled_vars = () if roll_coords else self.coords variables = OrderedDict() - for k, v in iteritems(self.variables): + for k, v in self.variables.items(): if k not in unrolled_vars: variables[k] = v.roll(**{k: s for k, s in shifts.items() if k in v.dims}) @@ -3719,7 +3716,7 @@ def quantile(self, q, dim=None, interpolation='linear', numpy.nanpercentile, pandas.Series.quantile, DataArray.quantile """ - if isinstance(dim, basestring): + if isinstance(dim, str): dims = set([dim]) elif dim is None: dims = set(self.dims) @@ -3732,7 +3729,7 @@ def quantile(self, q, dim=None, interpolation='linear', q = np.asarray(q, dtype=np.float64) variables = OrderedDict() - for name, var in iteritems(self.variables): + for name, var in self.variables.items(): reduce_dims = [d for d in var.dims if d in dims] if reduce_dims or not var.dims: if name not in self.coords: @@ -3795,7 +3792,7 @@ def rank(self, dim, pct=False, keep_attrs=None): 'Dataset does not contain the dimension: %s' % dim) variables = OrderedDict() - for name, var in iteritems(self.variables): + for name, var in self.variables.items(): if name in self.data_vars: if dim in var.dims: variables[name] = var.rank(dim, pct=pct) diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index 54fd8881a56..eb1e928b58e 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -3,8 +3,6 @@ Currently, this means Dask or NumPy arrays. None of these functions should accept or return xarray objects. """ -from __future__ import absolute_import, division, print_function - import contextlib from functools import partial import inspect diff --git a/xarray/core/extensions.py b/xarray/core/extensions.py index 8070e07a5ef..574c05f1a6b 100644 --- a/xarray/core/extensions.py +++ b/xarray/core/extensions.py @@ -1,11 +1,7 @@ -from __future__ import absolute_import, division, print_function - -import traceback import warnings from .dataarray import DataArray from .dataset import Dataset -from .pycompat import PY2 class AccessorRegistrationWarning(Warning): @@ -29,10 +25,7 @@ def __get__(self, obj, cls): # __getattr__ on data object will swallow any AttributeErrors # raised when initializing the accessor, so we need to raise as # something else (GH933): - msg = 'error initializing %r accessor.' % self._name - if PY2: - msg += ' Full traceback:\n' + traceback.format_exc() - raise RuntimeError(msg) + raise RuntimeError('error initializing %r accessor.' % self._name) # Replace the property with the accessor object. Inspired by: # http://www.pydanny.com/cached-property.html # We need to use object.__setattr__ because we overwrite __setattr__ on diff --git a/xarray/core/formatting.py b/xarray/core/formatting.py index 50fa64c9987..f3fcc1ecb37 100644 --- a/xarray/core/formatting.py +++ b/xarray/core/formatting.py @@ -1,22 +1,16 @@ """String formatting routines for __repr__. - -For the sake of sanity, we only do internal formatting with unicode, which can -be returned by the __unicode__ special method. We use ReprMixin to provide the -__repr__ method so that things can work on Python 2. """ -from __future__ import absolute_import, division, print_function - import contextlib import functools from datetime import datetime, timedelta +from itertools import zip_longest import numpy as np import pandas as pd from .duck_array_ops import array_equiv from .options import OPTIONS -from .pycompat import ( - PY2, bytes_type, dask_array_type, unicode_type, zip_longest) +from .pycompat import dask_array_type try: from pandas.errors import OutOfBoundsDatetime @@ -35,9 +29,9 @@ def pretty_print(x, numchars): def maybe_truncate(obj, maxlen=500): - s = unicode_type(obj) + s = str(obj) if len(s) > maxlen: - s = s[:(maxlen - 3)] + u'...' + s = s[:(maxlen - 3)] + '...' return s @@ -48,24 +42,6 @@ def wrap_indent(text, start='', length=None): return start + indent.join(x for x in text.splitlines()) -def ensure_valid_repr(string): - """Ensure that the given value is valid for the result of __repr__. - - On Python 2, this means we need to convert unicode to bytes. We won't need - this function once we drop Python 2.7 support. - """ - if PY2 and isinstance(string, unicode_type): - string = string.encode('utf-8') - return string - - -class ReprMixin(object): - """Mixin that defines __repr__ for a class that already has __unicode__.""" - - def __repr__(self): - return ensure_valid_repr(self.__unicode__()) - - def _get_indexer_at_least_n_items(shape, n_desired, from_end): assert 0 < n_desired <= np.prod(shape) cum_items = np.cumprod(shape[::-1]) @@ -127,9 +103,9 @@ def format_timestamp(t): """Cast given object to a Timestamp and return a nicely formatted string""" # Timestamp is only valid for 1678 to 2262 try: - datetime_str = unicode_type(pd.Timestamp(t)) + datetime_str = str(pd.Timestamp(t)) except OutOfBoundsDatetime: - datetime_str = unicode_type(t) + datetime_str = str(t) try: date_str, time_str = datetime_str.split() @@ -145,7 +121,7 @@ def format_timestamp(t): def format_timedelta(t, timedelta_format=None): """Cast given object to a Timestamp and return a nicely formatted string""" - timedelta_str = unicode_type(pd.Timedelta(t)) + timedelta_str = str(pd.Timedelta(t)) try: days_str, time_str = timedelta_str.split(' days ') except ValueError: @@ -166,12 +142,12 @@ def format_item(x, timedelta_format=None, quote_strings=True): return format_timestamp(x) if isinstance(x, (np.timedelta64, timedelta)): return format_timedelta(x, timedelta_format=timedelta_format) - elif isinstance(x, (unicode_type, bytes_type)): + elif isinstance(x, (str, bytes)): return repr(x) if quote_strings else x elif isinstance(x, (float, np.float)): - return u'{0:.4}'.format(x) + return '{0:.4}'.format(x) else: - return unicode_type(x) + return str(x) def format_items(x): @@ -215,20 +191,20 @@ def format_array_flat(array, max_width): cum_len = np.cumsum([len(s) + 1 for s in relevant_items]) - 1 if (array.size > 2) and ((max_possibly_relevant < array.size) or (cum_len > max_width).any()): - padding = u' ... ' + padding = ' ... ' count = min(array.size, max(np.argmax(cum_len + len(padding) - 1 > max_width), 2)) else: count = array.size - padding = u'' if (count <= 1) else u' ' + padding = '' if (count <= 1) else ' ' num_front = (count + 1) // 2 num_back = count - num_front # note that num_back is 0 <--> array.size is 0 or 1 # <--> relevant_back_items is [] - pprint_str = (u' '.join(relevant_front_items[:num_front]) + + pprint_str = (' '.join(relevant_front_items[:num_front]) + padding + - u' '.join(relevant_back_items[-num_back:])) + ' '.join(relevant_back_items[-num_back:])) return pprint_str @@ -236,30 +212,30 @@ def summarize_variable(name, var, col_width, show_values=True, marker=' ', max_width=None): if max_width is None: max_width = OPTIONS['display_width'] - first_col = pretty_print(u' %s %s ' % (marker, name), col_width) + first_col = pretty_print(' %s %s ' % (marker, name), col_width) if var.dims: - dims_str = u'(%s) ' % u', '.join(map(unicode_type, var.dims)) + dims_str = '(%s) ' % ', '.join(map(str, var.dims)) else: - dims_str = u'' - front_str = u'%s%s%s ' % (first_col, dims_str, var.dtype) + dims_str = '' + front_str = '%s%s%s ' % (first_col, dims_str, var.dtype) if show_values: values_str = format_array_flat(var, max_width - len(front_str)) elif isinstance(var._data, dask_array_type): values_str = short_dask_repr(var, show_dtype=False) else: - values_str = u'...' + values_str = '...' return front_str + values_str def _summarize_coord_multiindex(coord, col_width, marker): - first_col = pretty_print(u' %s %s ' % (marker, coord.name), col_width) - return u'%s(%s) MultiIndex' % (first_col, unicode_type(coord.dims[0])) + first_col = pretty_print(' %s %s ' % (marker, coord.name), col_width) + return '%s(%s) MultiIndex' % (first_col, str(coord.dims[0])) -def _summarize_coord_levels(coord, col_width, marker=u'-'): +def _summarize_coord_levels(coord, col_width, marker='-'): relevant_coord = coord[:30] - return u'\n'.join( + return '\n'.join( [summarize_variable(lname, relevant_coord.get_level_variable(lname), col_width, marker=marker) @@ -274,11 +250,11 @@ def summarize_datavar(name, var, col_width): def summarize_coord(name, var, col_width): is_index = name in var.dims show_values = var._in_memory - marker = u'*' if is_index else u' ' + marker = '*' if is_index else ' ' if is_index: coord = var.variable.to_index_variable() if coord.level_names is not None: - return u'\n'.join( + return '\n'.join( [_summarize_coord_multiindex(coord, col_width, marker), _summarize_coord_levels(coord, col_width)]) return summarize_variable( @@ -288,16 +264,16 @@ def summarize_coord(name, var, col_width): def summarize_attr(key, value, col_width=None): """Summary for __repr__ - use ``X.attrs[key]`` for full value.""" # Indent key and add ':', then right-pad if col_width is not None - k_str = u' %s:' % key + k_str = ' %s:' % key if col_width is not None: k_str = pretty_print(k_str, col_width) # Replace tabs and newlines, so we print on one line in known width - v_str = unicode_type(value).replace(u'\t', u'\\t').replace(u'\n', u'\\n') + v_str = str(value).replace('\t', '\\t').replace('\n', '\\n') # Finally, truncate to the desired display width - return maybe_truncate(u'%s %s' % (k_str, v_str), OPTIONS['display_width']) + return maybe_truncate('%s %s' % (k_str, v_str), OPTIONS['display_width']) -EMPTY_REPR = u' *empty*' +EMPTY_REPR = ' *empty*' def _get_col_items(mapping): @@ -318,7 +294,7 @@ def _get_col_items(mapping): def _calculate_col_width(col_items): - max_name_length = (max(len(unicode_type(s)) for s in col_items) + max_name_length = (max(len(str(s)) for s in col_items) if col_items else 0) col_width = max(max_name_length, 7) + 6 return col_width @@ -327,26 +303,26 @@ def _calculate_col_width(col_items): def _mapping_repr(mapping, title, summarizer, col_width=None): if col_width is None: col_width = _calculate_col_width(mapping) - summary = [u'%s:' % title] + summary = ['%s:' % title] if mapping: summary += [summarizer(k, v, col_width) for k, v in mapping.items()] else: summary += [EMPTY_REPR] - return u'\n'.join(summary) + return '\n'.join(summary) -data_vars_repr = functools.partial(_mapping_repr, title=u'Data variables', +data_vars_repr = functools.partial(_mapping_repr, title='Data variables', summarizer=summarize_datavar) -attrs_repr = functools.partial(_mapping_repr, title=u'Attributes', +attrs_repr = functools.partial(_mapping_repr, title='Attributes', summarizer=summarize_attr) def coords_repr(coords, col_width=None): if col_width is None: col_width = _calculate_col_width(_get_col_items(coords)) - return _mapping_repr(coords, title=u'Coordinates', + return _mapping_repr(coords, title='Coordinates', summarizer=summarize_coord, col_width=col_width) @@ -354,19 +330,19 @@ def indexes_repr(indexes): summary = [] for k, v in indexes.items(): summary.append(wrap_indent(repr(v), '%s: ' % k)) - return u'\n'.join(summary) + return '\n'.join(summary) def dim_summary(obj): - elements = [u'%s: %s' % (k, v) for k, v in obj.sizes.items()] - return u', '.join(elements) + elements = ['%s: %s' % (k, v) for k, v in obj.sizes.items()] + return ', '.join(elements) def unindexed_dims_repr(dims, coords): unindexed_dims = [d for d in dims if d not in coords] if unindexed_dims: - dims_str = u', '.join(u'%s' % d for d in unindexed_dims) - return u'Dimensions without coordinates: ' + dims_str + dims_str = ', '.join('%s' % d for d in unindexed_dims) + return 'Dimensions without coordinates: ' + dims_str else: return None @@ -426,9 +402,9 @@ def array_repr(arr): if hasattr(arr, 'name') and arr.name is not None: name_str = '%r ' % arr.name else: - name_str = u'' + name_str = '' - summary = [u'' + summary = ['' % (type(arr).__name__, name_str, dim_summary(arr))] summary.append(short_data_repr(arr)) @@ -444,16 +420,16 @@ def array_repr(arr): if arr.attrs: summary.append(attrs_repr(arr.attrs)) - return u'\n'.join(summary) + return '\n'.join(summary) def dataset_repr(ds): - summary = [u'' % type(ds).__name__] + summary = ['' % type(ds).__name__] col_width = _calculate_col_width(_get_col_items(ds.variables)) - dims_start = pretty_print(u'Dimensions:', col_width) - summary.append(u'%s(%s)' % (dims_start, dim_summary(ds))) + dims_start = pretty_print('Dimensions:', col_width) + summary.append('%s(%s)' % (dims_start, dim_summary(ds))) if ds.coords: summary.append(coords_repr(ds.coords, col_width=col_width)) @@ -467,7 +443,7 @@ def dataset_repr(ds): if ds.attrs: summary.append(attrs_repr(ds.attrs)) - return u'\n'.join(summary) + return '\n'.join(summary) def diff_dim_summary(a, b): diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index aa8ced5adab..e4577c3d593 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import datetime import functools import warnings @@ -12,7 +10,7 @@ from .combine import concat from .common import ALL_DIMS, ImplementsArrayReduce, ImplementsDatasetReduce from .options import _get_keep_attrs -from .pycompat import integer_types, range, zip +from .pycompat import integer_types from .utils import hashable, maybe_wrap_array, peek_at, safe_cast_to_index from .variable import IndexVariable, Variable, as_variable diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py index ffa483fc370..c360a209c46 100644 --- a/xarray/core/indexes.py +++ b/xarray/core/indexes.py @@ -1,14 +1,10 @@ -from __future__ import absolute_import, division, print_function -try: - from collections.abc import Mapping -except ImportError: - from collections import Mapping +from collections.abc import Mapping from collections import OrderedDict from . import formatting -class Indexes(Mapping, formatting.ReprMixin): +class Indexes(Mapping): """Immutable proxy for Dataset or DataArrary indexes.""" def __init__(self, indexes): """Not for public consumption. @@ -32,7 +28,7 @@ def __contains__(self, key): def __getitem__(self, key): return self._indexes[key] - def __unicode__(self): + def __repr__(self): return formatting.indexes_repr(self) diff --git a/xarray/core/indexing.py b/xarray/core/indexing.py index dab23540178..65a123c3319 100644 --- a/xarray/core/indexing.py +++ b/xarray/core/indexing.py @@ -1,23 +1,17 @@ -from __future__ import absolute_import, division, print_function - import functools import operator from collections import defaultdict +from collections.abc import Hashable +from contextlib import suppress from datetime import timedelta import numpy as np import pandas as pd from . import duck_array_ops, nputils, utils -from .pycompat import ( - dask_array_type, integer_types, iteritems, range, suppress) +from .pycompat import dask_array_type, integer_types from .utils import is_dict_like -try: - from collections.abc import Hashable -except ImportError: # Py2 - from collections import Hashable - def expanded_indexer(key, ndim): """Given a key for indexing an ndarray, return an equivalent key which is a @@ -214,7 +208,7 @@ def get_dim_indexers(data_obj, indexers): level_indexers = defaultdict(dict) dim_indexers = {} - for key, label in iteritems(indexers): + for key, label in indexers.items(): dim, = data_obj[key].dims if key != dim: # assume here multi-index level indexer @@ -222,7 +216,7 @@ def get_dim_indexers(data_obj, indexers): else: dim_indexers[key] = label - for dim, level_labels in iteritems(level_indexers): + for dim, level_labels in level_indexers.items(): if dim_indexers.get(dim, False): raise ValueError("cannot combine multi-index level indexers " "with an indexer for dimension %s" % dim) @@ -243,7 +237,7 @@ def remap_label_indexers(data_obj, indexers, method=None, tolerance=None): new_indexes = {} dim_indexers = get_dim_indexers(data_obj, indexers) - for dim, label in iteritems(dim_indexers): + for dim, label in dim_indexers.items(): try: index = data_obj.indexes[dim] except KeyError: diff --git a/xarray/core/merge.py b/xarray/core/merge.py index 637a9cbda7f..7bbd14470f2 100644 --- a/xarray/core/merge.py +++ b/xarray/core/merge.py @@ -1,4 +1,4 @@ -from __future__ import absolute_import, division, print_function +from collections import OrderedDict from typing import ( Any, Dict, List, Mapping, Optional, Set, Tuple, TYPE_CHECKING, Union, @@ -7,7 +7,6 @@ import pandas as pd from .alignment import deep_align -from .pycompat import OrderedDict, basestring from .utils import Frozen from .variable import ( Variable, as_variable, assert_unique_multiindex_level_names) @@ -539,7 +538,7 @@ def dataset_merge_method(dataset, other, overwrite_vars, compat, join): # method due for backwards compatibility # TODO: consider deprecating it? - if isinstance(overwrite_vars, basestring): + if isinstance(overwrite_vars, str): overwrite_vars = set([overwrite_vars]) overwrite_vars = set(overwrite_vars) diff --git a/xarray/core/missing.py b/xarray/core/missing.py index ff0e63801bc..4c9435e0bf4 100644 --- a/xarray/core/missing.py +++ b/xarray/core/missing.py @@ -1,7 +1,5 @@ -from __future__ import absolute_import, division, print_function - import warnings -from collections import Iterable +from collections.abc import Iterable from functools import partial from typing import Any, Dict @@ -12,7 +10,6 @@ from .common import _contains_datetime_like_objects from .computation import apply_ufunc from .duck_array_ops import dask_array_type -from .pycompat import iteritems from .utils import OrderedSet, datetime_to_numeric, is_scalar from .variable import Variable, broadcast_variables @@ -147,7 +144,7 @@ def _apply_over_vars_with_dim(func, self, dim=None, **kwargs): ds = type(self)(coords=self.coords, attrs=self.attrs) - for name, var in iteritems(self.data_vars): + for name, var in self.data_vars.items(): if dim in var.dims: ds[name] = func(var, dim=dim, **kwargs) else: diff --git a/xarray/core/nanops.py b/xarray/core/nanops.py index 4d3f03c899e..babc1dd97e6 100644 --- a/xarray/core/nanops.py +++ b/xarray/core/nanops.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np from . import dtypes, nputils diff --git a/xarray/core/npcompat.py b/xarray/core/npcompat.py index efa68c8bad5..0adda4557dc 100644 --- a/xarray/core/npcompat.py +++ b/xarray/core/npcompat.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - from distutils.version import LooseVersion import numpy as np diff --git a/xarray/core/nputils.py b/xarray/core/nputils.py index a8d596abd86..14fbec72341 100644 --- a/xarray/core/nputils.py +++ b/xarray/core/nputils.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import warnings import numpy as np diff --git a/xarray/core/ops.py b/xarray/core/ops.py index 272a4eaf2f1..97e240c5126 100644 --- a/xarray/core/ops.py +++ b/xarray/core/ops.py @@ -5,15 +5,12 @@ functions. """ -from __future__ import absolute_import, division, print_function - import operator import numpy as np from . import dtypes, duck_array_ops from .nputils import array_eq, array_ne -from .pycompat import PY3 try: import bottleneck as bn @@ -28,8 +25,6 @@ CMP_BINARY_OPS = ['lt', 'le', 'ge', 'gt'] NUM_BINARY_OPS = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod', 'pow', 'and', 'xor', 'or'] -if not PY3: - NUM_BINARY_OPS.append('div') # methods which pass on the numpy return value unchanged # be careful not to list methods that we would want to wrap later diff --git a/xarray/core/options.py b/xarray/core/options.py index db8e696eedf..c9d26c3e577 100644 --- a/xarray/core/options.py +++ b/xarray/core/options.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import warnings DISPLAY_WIDTH = 'display_width' diff --git a/xarray/core/pycompat.py b/xarray/core/pycompat.py index 67921b5d145..bd2075fa300 100644 --- a/xarray/core/pycompat.py +++ b/xarray/core/pycompat.py @@ -1,72 +1,8 @@ # flake8: noqa -from __future__ import absolute_import, division, print_function - -import sys - import numpy as np -PY2 = sys.version_info[0] < 3 -PY3 = sys.version_info[0] >= 3 - -if PY3: # pragma: no cover - basestring = str - unicode_type = str - bytes_type = bytes - native_int_types = (int,) - - def iteritems(d): - return iter(d.items()) - - def itervalues(d): - return iter(d.values()) - - range = range - zip = zip - from itertools import zip_longest - from functools import reduce - import builtins - from urllib.request import urlretrieve - from inspect import getfullargspec as getargspec - - def move_to_end(ordered_dict, key): - ordered_dict.move_to_end(key) -else: # pragma: no cover - # Python 2 - basestring = basestring # noqa - unicode_type = unicode # noqa - bytes_type = str - native_int_types = (int, long) # noqa - - def iteritems(d): - return d.iteritems() - - def itervalues(d): - return d.itervalues() - - range = xrange - from itertools import ( - izip as zip, imap as map, izip_longest as zip_longest, - ) - reduce = reduce - import __builtin__ as builtins - from urllib import urlretrieve - from inspect import getargspec - - def move_to_end(ordered_dict, key): - value = ordered_dict[key] - del ordered_dict[key] - ordered_dict[key] = value - -integer_types = native_int_types + (np.integer,) - -try: - from cyordereddict import OrderedDict -except ImportError: # pragma: no cover - try: - from collections import OrderedDict - except ImportError: - from ordereddict import OrderedDict +integer_types = (int, np.integer, ) try: # solely for isinstance checks @@ -74,177 +10,3 @@ def move_to_end(ordered_dict, key): dask_array_type = (dask.array.Array,) except ImportError: # pragma: no cover dask_array_type = () - -try: - try: - from pathlib import Path - except ImportError as e: - from pathlib2 import Path - path_type = (Path, ) -except ImportError as e: - path_type = () - -try: - from contextlib import suppress -except ImportError: - # Backport from CPython 3.5: - # Used under the terms of Python's license, see licenses/PYTHON_LICENSE. - - class suppress: - """Context manager to suppress specified exceptions - - After the exception is suppressed, execution proceeds with the next - statement following the with statement. - - with suppress(FileNotFoundError): - os.remove(somefile) - # Execution still resumes here if the file was already removed - """ - - def __init__(self, *exceptions): - self._exceptions = exceptions - - def __enter__(self): - pass - - def __exit__(self, exctype, excinst, exctb): - # Unlike isinstance and issubclass, CPython exception handling - # currently only looks at the concrete type hierarchy (ignoring - # the instance and subclass checking hooks). While Guido considers - # that a bug rather than a feature, it's a fairly hard one to fix - # due to various internal implementation details. suppress provides - # the simpler issubclass based semantics, rather than trying to - # exactly reproduce the limitations of the CPython interpreter. - # - # See http://bugs.python.org/issue12029 for more details - return exctype is not None and issubclass( - exctype, self._exceptions) -try: - from contextlib import ExitStack -except ImportError: - # backport from Python 3.5: - from collections import deque - - # Inspired by discussions on http://bugs.python.org/issue13585 - class ExitStack(object): - """Context manager for dynamic management of a stack of exit callbacks - """ - - def __init__(self): - self._exit_callbacks = deque() - - def pop_all(self): - new_stack = type(self)() - new_stack._exit_callbacks = self._exit_callbacks - self._exit_callbacks = deque() - return new_stack - - def _push_cm_exit(self, cm, cm_exit): - """Helper to correctly register callbacks to __exit__ methods""" - def _exit_wrapper(*exc_details): - return cm_exit(cm, *exc_details) - _exit_wrapper.__self__ = cm - self.push(_exit_wrapper) - - def push(self, exit): - """Registers a callback with the standard __exit__ method signature - - Can suppress exceptions the same way __exit__ methods can. - - Also accepts any object with an __exit__ method (registering a call - to the method instead of the object itself) - """ - # We use an unbound method rather than a bound method to follow - # the standard lookup behaviour for special methods - _cb_type = type(exit) - try: - exit_method = _cb_type.__exit__ - except AttributeError: - # Not a context manager, so assume its a callable - self._exit_callbacks.append(exit) - else: - self._push_cm_exit(exit, exit_method) - return exit # Allow use as a decorator - - def callback(self, callback, *args, **kwds): - """Registers an arbitrary callback and arguments. - - Cannot suppress exceptions. - """ - def _exit_wrapper(exc_type, exc, tb): - callback(*args, **kwds) - # We changed the signature, so using @wraps is not appropriate, but - # setting __wrapped__ may still help with introspection - _exit_wrapper.__wrapped__ = callback - self.push(_exit_wrapper) - return callback # Allow use as a decorator - - def enter_context(self, cm): - """Enters the supplied context manager - - If successful, also pushes its __exit__ method as a callback and - returns the result of the __enter__ method. - """ - # We look up the special methods on the type to match the with - # statement - _cm_type = type(cm) - _exit = _cm_type.__exit__ - result = _cm_type.__enter__(cm) - self._push_cm_exit(cm, _exit) - return result - - def close(self): - """Immediately unwind the context stack""" - self.__exit__(None, None, None) - - def __enter__(self): - return self - - def __exit__(self, *exc_details): - received_exc = exc_details[0] is not None - - # We manipulate the exception state so it behaves as though - # we were actually nesting multiple with statements - frame_exc = sys.exc_info()[1] - - def _fix_exception_context(new_exc, old_exc): - # Context may not be correct, so find the end of the chain - while True: - exc_context = new_exc.__context__ - if exc_context is old_exc: - # Context is already set correctly (see issue 20317) - return - if exc_context is None or exc_context is frame_exc: - break - new_exc = exc_context - # Change the end of the chain to point to the exception - # we expect it to reference - new_exc.__context__ = old_exc - - # Callbacks are invoked in LIFO order to match the behaviour of - # nested context managers - suppressed_exc = False - pending_raise = False - while self._exit_callbacks: - cb = self._exit_callbacks.pop() - try: - if cb(*exc_details): - suppressed_exc = True - pending_raise = False - exc_details = (None, None, None) - except BaseException: - new_exc_details = sys.exc_info() - # simulate the stack of exceptions by setting the context - _fix_exception_context(new_exc_details[1], exc_details[1]) - pending_raise = True - exc_details = new_exc_details - if pending_raise: - try: - # bare "raise exc_details[1]" replaces our carefully - # set-up context - fixed_ctx = exc_details[1].__context__ - raise exc_details[1] - except BaseException: - exc_details[1].__context__ = fixed_ctx - raise - return received_exc and suppressed_exc diff --git a/xarray/core/resample.py b/xarray/core/resample.py index 886303db345..3c39d2299e4 100644 --- a/xarray/core/resample.py +++ b/xarray/core/resample.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - from . import ops from .groupby import DEFAULT_DIMS, DataArrayGroupBy, DatasetGroupBy diff --git a/xarray/core/rolling.py b/xarray/core/rolling.py index 57463ef5987..8a974e2da72 100644 --- a/xarray/core/rolling.py +++ b/xarray/core/rolling.py @@ -1,6 +1,5 @@ -from __future__ import absolute_import, division, print_function - import warnings +from collections import OrderedDict from distutils.version import LooseVersion import numpy as np @@ -10,7 +9,7 @@ from .ops import ( bn, has_bottleneck, inject_coarsen_methods, inject_bottleneck_rolling_methods, inject_datasetrolling_methods) -from .pycompat import OrderedDict, dask_array_type, zip +from .pycompat import dask_array_type class Rolling(object): diff --git a/xarray/core/utils.py b/xarray/core/utils.py index 085eaaa5ed1..b8e818693c4 100644 --- a/xarray/core/utils.py +++ b/xarray/core/utils.py @@ -1,20 +1,18 @@ """Internal utilties; not for external use """ -from __future__ import absolute_import, division, print_function - import contextlib import functools import itertools import os.path import re import warnings -from collections import Iterable, Mapping, MutableMapping, MutableSet +from collections import OrderedDict +from collections.abc import Iterable, Mapping, MutableMapping, MutableSet import numpy as np import pandas as pd -from .pycompat import ( - OrderedDict, basestring, bytes_type, dask_array_type, iteritems) +from .pycompat import dask_array_type def _check_inplace(inplace, default=False): @@ -37,7 +35,7 @@ def alias_warning(old_name, new_name, stacklevel=3): def alias(obj, old_name): - assert isinstance(old_name, basestring) + assert isinstance(old_name, str) @functools.wraps(obj) def wrapper(*args, **kwargs): @@ -157,7 +155,7 @@ def update_safety_check(first_dict, second_dict, compat=equivalent): Binary operator to determine if two values are compatible. By default, checks for equivalence. """ - for k, v in iteritems(second_dict): + for k, v in second_dict.items(): if k in first_dict and not compat(v, first_dict[k]): raise ValueError('unsafe to merge dictionaries without ' 'overriding values; conflicting key %r' % k) @@ -212,7 +210,7 @@ def is_scalar(value): """ return ( getattr(value, 'ndim', None) == 0 or - isinstance(value, (basestring, bytes_type)) or not + isinstance(value, (str, bytes)) or not isinstance(value, (Iterable, ) + dask_array_type)) diff --git a/xarray/core/variable.py b/xarray/core/variable.py index a71b148baf3..23ee9f24871 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -1,8 +1,6 @@ -from __future__ import absolute_import, division, print_function - import functools import itertools -from collections import defaultdict +from collections import OrderedDict, defaultdict from datetime import timedelta from typing import Tuple, Type @@ -17,8 +15,7 @@ BasicIndexer, OuterIndexer, PandasIndexAdapter, VectorizedIndexer, as_indexable) from .options import _get_keep_attrs -from .pycompat import ( - OrderedDict, basestring, dask_array_type, integer_types, zip) +from .pycompat import dask_array_type, integer_types from .utils import (OrderedSet, either_dict_or_kwargs, decode_numpy_dict_values, ensure_us_time_resolution) @@ -432,7 +429,7 @@ def dims(self, value): self._dims = self._parse_dimensions(value) def _parse_dimensions(self, dims): - if isinstance(dims, basestring): + if isinstance(dims, str): dims = (dims,) dims = tuple(dims) if len(dims) != self.ndim: @@ -1177,7 +1174,7 @@ def set_dims(self, dims, shape=None): ------- Variable """ - if isinstance(dims, basestring): + if isinstance(dims, str): dims = [dims] if shape is None and utils.is_dict_like(dims): @@ -1413,7 +1410,7 @@ def concat(cls, variables, dim='concat_dim', positions=None, Concatenated Variable formed by stacking all the supplied variables along the given dimension. """ - if not isinstance(dim, basestring): + if not isinstance(dim, str): dim, = dim.dims # can't do this lazily: we need to loop through variables at least @@ -1664,7 +1661,7 @@ def coarsen(self, windows, func, boundary='exact', side='left'): return self.copy() reshaped, axes = self._coarsen_reshape(windows, boundary, side) - if isinstance(func, basestring): + if isinstance(func, str): name = func func = getattr(duck_array_ops, name, None) if func is None: @@ -1845,7 +1842,7 @@ def concat(cls, variables, dim='concat_dim', positions=None, This exists because we want to avoid converting Index objects to NumPy arrays, if possible. """ - if not isinstance(dim, basestring): + if not isinstance(dim, str): dim, = dim.dims variables = list(variables) diff --git a/xarray/plot/__init__.py b/xarray/plot/__init__.py index 4b53b22243c..51712e78bf8 100644 --- a/xarray/plot/__init__.py +++ b/xarray/plot/__init__.py @@ -1,6 +1,3 @@ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function from .plot import (plot, line, step, contourf, contour, hist, imshow, pcolormesh) diff --git a/xarray/plot/facetgrid.py b/xarray/plot/facetgrid.py index f133e7806a3..2a4c67036d6 100644 --- a/xarray/plot/facetgrid.py +++ b/xarray/plot/facetgrid.py @@ -1,13 +1,11 @@ -from __future__ import absolute_import, division, print_function - import functools import itertools import warnings +from inspect import getfullargspec import numpy as np from ..core.formatting import format_item -from ..core.pycompat import getargspec from .utils import ( _determine_cmap_params, _infer_xy_labels, import_matplotlib_pyplot, label_from_attrs) @@ -240,7 +238,7 @@ def map_dataarray(self, func, x, y, **kwargs): 'filled': func.__name__ != 'contour', } - cmap_args = getargspec(_determine_cmap_params).args + cmap_args = getfullargspec(_determine_cmap_params).args cmap_kwargs.update((a, kwargs[a]) for a in cmap_args if a in kwargs) cmap_params = _determine_cmap_params(**cmap_kwargs) diff --git a/xarray/plot/plot.py b/xarray/plot/plot.py index 1f7b8d8587a..13d6ec31104 100644 --- a/xarray/plot/plot.py +++ b/xarray/plot/plot.py @@ -5,8 +5,6 @@ Or use the methods on a DataArray: DataArray.plot._____ """ -from __future__ import absolute_import, division, print_function - import functools import warnings from datetime import datetime @@ -15,7 +13,6 @@ import pandas as pd from xarray.core.common import contains_cftime_datetimes -from xarray.core.pycompat import basestring from .facetgrid import FacetGrid from .utils import ( @@ -834,14 +831,14 @@ def newplotfunc(darray, x=None, y=None, figsize=None, size=None, kwargs['levels'] = cmap_params['levels'] # if colors == a single color, matplotlib draws dashed negative # contours. we lose this feature if we pass cmap and not colors - if isinstance(colors, basestring): + if isinstance(colors, str): cmap_params['cmap'] = None kwargs['colors'] = colors if 'pcolormesh' == plotfunc.__name__: kwargs['infer_intervals'] = infer_intervals - if 'imshow' == plotfunc.__name__ and isinstance(aspect, basestring): + if 'imshow' == plotfunc.__name__ and isinstance(aspect, str): # forbid usage of mpl strings raise ValueError("plt.imshow's `aspect` kwarg is not available " "in xarray") diff --git a/xarray/plot/utils.py b/xarray/plot/utils.py index 41f61554739..a42fbc7aba6 100644 --- a/xarray/plot/utils.py +++ b/xarray/plot/utils.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import itertools import textwrap import warnings @@ -8,7 +6,6 @@ import pandas as pd from ..core.options import OPTIONS -from ..core.pycompat import basestring from ..core.utils import is_scalar ROBUST_PERCENTILE = 2.0 @@ -104,7 +101,7 @@ def _color_palette(cmap, n_colors): # we have a list of colors cmap = ListedColormap(cmap, N=n_colors) pal = cmap(colors_i) - elif isinstance(cmap, basestring): + elif isinstance(cmap, str): # we have some sort of named palette try: # is this a matplotlib cmap? diff --git a/xarray/testing.py b/xarray/testing.py index 418f1a08668..794c0614925 100644 --- a/xarray/testing.py +++ b/xarray/testing.py @@ -1,6 +1,4 @@ """Testing functions exposed to the user API""" -from __future__ import absolute_import, division, print_function - import numpy as np from xarray.core import duck_array_ops diff --git a/xarray/tests/__init__.py b/xarray/tests/__init__.py index 58f76596822..a7eafa92bd7 100644 --- a/xarray/tests/__init__.py +++ b/xarray/tests/__init__.py @@ -1,6 +1,3 @@ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function import warnings from contextlib import contextmanager from distutils import version diff --git a/xarray/tests/test_accessors.py b/xarray/tests/test_accessors.py index 5d088e8cd48..ae95bae3a93 100644 --- a/xarray/tests/test_accessors.py +++ b/xarray/tests/test_accessors.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np import pandas as pd import pytest diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index d3c8599b21b..55e4eb7c8db 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import contextlib import itertools import math @@ -11,6 +9,7 @@ import tempfile from typing import Optional import warnings +from contextlib import ExitStack from io import BytesIO import numpy as np @@ -26,8 +25,7 @@ from xarray.backends.pydap_ import PydapDataStore from xarray.core import indexing from xarray.core.options import set_options -from xarray.core.pycompat import ( - ExitStack, basestring, dask_array_type, iteritems) +from xarray.core.pycompat import dask_array_type from xarray.tests import mock from . import ( @@ -206,7 +204,7 @@ def test_zero_dimensional_variable(self): expected = create_test_data() expected['float_var'] = ([], 1.0e9, {'units': 'units of awesome'}) expected['bytes_var'] = ([], b'foobar') - expected['string_var'] = ([], u'foobar') + expected['string_var'] = ([], 'foobar') with self.roundtrip(expected) as actual: assert_identical(expected, actual) @@ -338,8 +336,8 @@ def test_roundtrip_object_dtype(self): floats_nans = np.array([np.nan, np.nan, 1.0, 2.0, 3.0], dtype=object) bytes_ = np.array([b'ab', b'cdef', b'g'], dtype=object) bytes_nans = np.array([b'ab', b'cdef', np.nan], dtype=object) - strings = np.array([u'ab', u'cdef', u'g'], dtype=object) - strings_nans = np.array([u'ab', u'cdef', np.nan], dtype=object) + strings = np.array(['ab', 'cdef', 'g'], dtype=object) + strings_nans = np.array(['ab', 'cdef', np.nan], dtype=object) all_nans = np.array([np.nan, np.nan], dtype=object) original = Dataset({'floats': ('a', floats), 'floats_nans': ('a', floats_nans), @@ -361,7 +359,7 @@ def test_roundtrip_object_dtype(self): # explicitly set. # https://github.com/pydata/xarray/issues/1647 expected['bytes_nans'][-1] = b'' - expected['strings_nans'][-1] = u'' + expected['strings_nans'][-1] = '' assert_identical(expected, actual) def test_roundtrip_string_data(self): @@ -370,7 +368,7 @@ def test_roundtrip_string_data(self): assert_identical(expected, actual) def test_roundtrip_string_encoded_characters(self): - expected = Dataset({'x': ('t', [u'ab', u'cdef'])}) + expected = Dataset({'x': ('t', ['ab', 'cdef'])}) expected['x'].encoding['dtype'] = 'S1' with self.roundtrip(expected) as actual: assert_identical(expected, actual) @@ -641,7 +639,7 @@ def test_roundtrip_bytes_with_fill_value(self): assert_identical(expected, actual) def test_roundtrip_string_with_fill_value_nchar(self): - values = np.array([u'ab', u'cdef', np.nan], dtype=object) + values = np.array(['ab', 'cdef', np.nan], dtype=object) expected = Dataset({'x': ('t', values)}) encoding = {'dtype': 'S1', '_FillValue': b'X'} @@ -790,7 +788,7 @@ def test_encoding_kwarg_fixed_width_string(self): # regression test for GH2149 for strings in [ [b'foo', b'bar', b'baz'], - [u'foo', u'bar', u'baz'], + ['foo', 'bar', 'baz'], ]: ds = Dataset({'x': strings}) kwargs = dict(encoding={'x': {'dtype': 'S1'}}) @@ -982,29 +980,29 @@ def test_write_groups(self): def test_encoding_kwarg_vlen_string(self): for input_strings in [ [b'foo', b'bar', b'baz'], - [u'foo', u'bar', u'baz'], + ['foo', 'bar', 'baz'], ]: original = Dataset({'x': input_strings}) - expected = Dataset({'x': [u'foo', u'bar', u'baz']}) + expected = Dataset({'x': ['foo', 'bar', 'baz']}) kwargs = dict(encoding={'x': {'dtype': str}}) with self.roundtrip(original, save_kwargs=kwargs) as actual: assert actual['x'].encoding['dtype'] is str assert_identical(actual, expected) def test_roundtrip_string_with_fill_value_vlen(self): - values = np.array([u'ab', u'cdef', np.nan], dtype=object) + values = np.array(['ab', 'cdef', np.nan], dtype=object) expected = Dataset({'x': ('t', values)}) # netCDF4-based backends don't support an explicit fillvalue # for variable length strings yet. # https://github.com/Unidata/netcdf4-python/issues/730 # https://github.com/shoyer/h5netcdf/issues/37 - original = Dataset({'x': ('t', values, {}, {'_FillValue': u'XXX'})}) + original = Dataset({'x': ('t', values, {}, {'_FillValue': 'XXX'})}) with pytest.raises(NotImplementedError): with self.roundtrip(original) as actual: assert_identical(expected, actual) - original = Dataset({'x': ('t', values, {}, {'_FillValue': u''})}) + original = Dataset({'x': ('t', values, {}, {'_FillValue': ''})}) with pytest.raises(NotImplementedError): with self.roundtrip(original) as actual: assert_identical(expected, actual) @@ -1054,7 +1052,7 @@ def test_open_encodings(self): with open_dataset(tmp_file) as actual: assert_equal(actual['time'], expected['time']) actual_encoding = dict((k, v) for k, v in - iteritems(actual['time'].encoding) + actual['time'].encoding.items() if k in expected['time'].encoding) assert actual_encoding == \ expected['time'].encoding @@ -1094,7 +1092,7 @@ def test_compression_encoding(self): 'shuffle': True, 'original_shape': data.var2.shape}) with self.roundtrip(data) as actual: - for k, v in iteritems(data['var2'].encoding): + for k, v in data['var2'].encoding.items(): assert v == actual['var2'].encoding[k] # regression test for #156 @@ -1688,7 +1686,7 @@ def create_store(self): yield store def test_encoding_kwarg_vlen_string(self): - original = Dataset({'x': [u'foo', u'bar', u'baz']}) + original = Dataset({'x': ['foo', 'bar', 'baz']}) kwargs = dict(encoding={'x': {'dtype': str}}) with raises_regex(ValueError, 'encoding dtype=str for vlen'): with self.roundtrip(original, save_kwargs=kwargs): @@ -2860,7 +2858,7 @@ def test_utm(self): with create_tmp_geotiff() as (tmp_file, expected): with xr.open_rasterio(tmp_file) as rioda: assert_allclose(rioda, expected) - assert isinstance(rioda.attrs['crs'], basestring) + assert isinstance(rioda.attrs['crs'], str) assert isinstance(rioda.attrs['res'], tuple) assert isinstance(rioda.attrs['is_tiled'], np.uint8) assert isinstance(rioda.attrs['transform'], tuple) @@ -2903,7 +2901,7 @@ def test_platecarree(self): as (tmp_file, expected): with xr.open_rasterio(tmp_file) as rioda: assert_allclose(rioda, expected) - assert isinstance(rioda.attrs['crs'], basestring) + assert isinstance(rioda.attrs['crs'], str) assert isinstance(rioda.attrs['res'], tuple) assert isinstance(rioda.attrs['is_tiled'], np.uint8) assert isinstance(rioda.attrs['transform'], tuple) @@ -3141,15 +3139,15 @@ def test_ENVI_tags(self): with xr.open_rasterio(tmp_file) as rioda: assert_allclose(rioda, expected) - assert isinstance(rioda.attrs['crs'], basestring) + assert isinstance(rioda.attrs['crs'], str) assert isinstance(rioda.attrs['res'], tuple) assert isinstance(rioda.attrs['is_tiled'], np.uint8) assert isinstance(rioda.attrs['transform'], tuple) assert len(rioda.attrs['transform']) == 6 # from ENVI tags - assert isinstance(rioda.attrs['description'], basestring) - assert isinstance(rioda.attrs['map_info'], basestring) - assert isinstance(rioda.attrs['samples'], basestring) + assert isinstance(rioda.attrs['description'], str) + assert isinstance(rioda.attrs['map_info'], str) + assert isinstance(rioda.attrs['samples'], str) def test_no_mftime(self): # rasterio can accept "filename" urguments that are actually urls, diff --git a/xarray/tests/test_backends_api.py b/xarray/tests/test_backends_api.py index 2b025db8cab..04ad473cd26 100644 --- a/xarray/tests/test_backends_api.py +++ b/xarray/tests/test_backends_api.py @@ -1,4 +1,3 @@ - import pytest from xarray.backends.api import _get_default_engine diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 3fe014bdaba..09c598272e3 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import - from datetime import timedelta import numpy as np @@ -12,8 +10,9 @@ _parsed_string_to_bounds, assert_all_valid_date_type, parse_iso8601) from xarray.tests import assert_array_equal, assert_identical -from . import (has_cftime, has_cftime_1_0_2_1, has_cftime_or_netCDF4, - raises_regex, requires_cftime) +from . import ( + has_cftime, has_cftime_1_0_2_1, has_cftime_or_netCDF4, raises_regex, + requires_cftime) from .test_coding_times import ( _ALL_CALENDARS, _NON_STANDARD_CALENDARS, _all_cftime_date_types) diff --git a/xarray/tests/test_coding.py b/xarray/tests/test_coding.py index 6300a1957f8..95c8ebc0b42 100644 --- a/xarray/tests/test_coding.py +++ b/xarray/tests/test_coding.py @@ -1,9 +1,10 @@ +from contextlib import suppress + import numpy as np import pytest import xarray as xr from xarray.coding import variables -from xarray.core.pycompat import suppress from . import assert_identical, requires_dask diff --git a/xarray/tests/test_coding_strings.py b/xarray/tests/test_coding_strings.py index ca138ca8362..c50376a5841 100644 --- a/xarray/tests/test_coding_strings.py +++ b/xarray/tests/test_coding_strings.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -from __future__ import absolute_import, division, print_function +from contextlib import suppress import numpy as np import pytest @@ -7,7 +7,6 @@ from xarray import Variable from xarray.coding import strings from xarray.core import indexing -from xarray.core.pycompat import bytes_type, suppress, unicode_type from . import ( IndexerMaker, assert_array_equal, assert_identical, raises_regex, @@ -18,17 +17,17 @@ def test_vlen_dtype(): - dtype = strings.create_vlen_dtype(unicode_type) - assert dtype.metadata['element_type'] == unicode_type + dtype = strings.create_vlen_dtype(str) + assert dtype.metadata['element_type'] == str assert strings.is_unicode_dtype(dtype) assert not strings.is_bytes_dtype(dtype) - assert strings.check_vlen_dtype(dtype) is unicode_type + assert strings.check_vlen_dtype(dtype) is str - dtype = strings.create_vlen_dtype(bytes_type) - assert dtype.metadata['element_type'] == bytes_type + dtype = strings.create_vlen_dtype(bytes) + assert dtype.metadata['element_type'] == bytes assert not strings.is_unicode_dtype(dtype) assert strings.is_bytes_dtype(dtype) - assert strings.check_vlen_dtype(dtype) is bytes_type + assert strings.check_vlen_dtype(dtype) is bytes assert strings.check_vlen_dtype(np.dtype(object)) is None @@ -36,12 +35,12 @@ def test_vlen_dtype(): def test_EncodedStringCoder_decode(): coder = strings.EncodedStringCoder() - raw_data = np.array([b'abc', u'ß∂µ∆'.encode('utf-8')]) + raw_data = np.array([b'abc', 'ß∂µ∆'.encode('utf-8')]) raw = Variable(('x',), raw_data, {'_Encoding': 'utf-8'}) actual = coder.decode(raw) expected = Variable( - ('x',), np.array([u'abc', u'ß∂µ∆'], dtype=object)) + ('x',), np.array(['abc', 'ß∂µ∆'], dtype=object)) assert_identical(actual, expected) assert_identical(coder.decode(actual[0]), expected[0]) @@ -51,12 +50,12 @@ def test_EncodedStringCoder_decode(): def test_EncodedStringCoder_decode_dask(): coder = strings.EncodedStringCoder() - raw_data = np.array([b'abc', u'ß∂µ∆'.encode('utf-8')]) + raw_data = np.array([b'abc', 'ß∂µ∆'.encode('utf-8')]) raw = Variable(('x',), raw_data, {'_Encoding': 'utf-8'}).chunk() actual = coder.decode(raw) assert isinstance(actual.data, da.Array) - expected = Variable(('x',), np.array([u'abc', u'ß∂µ∆'], dtype=object)) + expected = Variable(('x',), np.array(['abc', 'ß∂µ∆'], dtype=object)) assert_identical(actual, expected) actual_indexed = coder.decode(actual[0]) @@ -65,8 +64,8 @@ def test_EncodedStringCoder_decode_dask(): def test_EncodedStringCoder_encode(): - dtype = strings.create_vlen_dtype(unicode_type) - raw_data = np.array([u'abc', u'ß∂µ∆'], dtype=dtype) + dtype = strings.create_vlen_dtype(str) + raw_data = np.array(['abc', 'ß∂µ∆'], dtype=dtype) expected_data = np.array([r.encode('utf-8') for r in raw_data], dtype=object) @@ -97,7 +96,7 @@ def test_CharacterArrayCoder_roundtrip(original): @pytest.mark.parametrize('data', [ np.array([b'a', b'bc']), - np.array([b'a', b'bc'], dtype=strings.create_vlen_dtype(bytes_type)), + np.array([b'a', b'bc'], dtype=strings.create_vlen_dtype(bytes)), ]) def test_CharacterArrayCoder_encode(data): coder = strings.CharacterArrayCoder() diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 756d51e7997..24234d3b6b5 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import warnings from itertools import product @@ -33,7 +31,7 @@ # 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'), (12300 + np.arange(5), ' Hour since 1680-01-01 00:00:00 '), (10, 'days since 2000-01-01'), ([10], 'daYs since 2000-01-01'), diff --git a/xarray/tests/test_combine.py b/xarray/tests/test_combine.py index e978350d322..c37abc98f07 100644 --- a/xarray/tests/test_combine.py +++ b/xarray/tests/test_combine.py @@ -1,5 +1,4 @@ -from __future__ import absolute_import, division, print_function - +from collections import OrderedDict from copy import deepcopy from itertools import product @@ -12,7 +11,6 @@ _auto_combine, _auto_combine_1d, _auto_combine_all_along_first_dim, _check_shape_tile_ids, _combine_nd, _infer_concat_order_from_positions, _infer_tile_ids_from_nested_list, _new_tile_id) -from xarray.core.pycompat import OrderedDict, iteritems from . import ( InaccessibleArray, assert_array_equal, assert_combined_tile_ids_equal, @@ -38,7 +36,7 @@ def rectify_dim_order(dataset): # return a new dataset with all variable dimensions transposed into # the order in which they are found in `data` return Dataset(dict((k, v.transpose(*data[k].dims)) - for k, v in iteritems(dataset.data_vars)), + for k, v in dataset.data_vars.items()), dataset.coords, attrs=dataset.attrs) for dim in ['dim1', 'dim2']: @@ -52,7 +50,7 @@ def rectify_dim_order(dataset): data, concat(datasets, data[dim], coords='minimal')) datasets = [g for _, g in data.groupby(dim, squeeze=True)] - concat_over = [k for k, v in iteritems(data.coords) + concat_over = [k for k, v in data.coords.items() if dim in v.dims and k != dim] actual = concat(datasets, data[dim], coords=concat_over) assert_identical(data, rectify_dim_order(actual)) diff --git a/xarray/tests/test_conventions.py b/xarray/tests/test_conventions.py index 5fa518f5112..27f5e7ec079 100644 --- a/xarray/tests/test_conventions.py +++ b/xarray/tests/test_conventions.py @@ -1,6 +1,4 @@ # -*- coding: utf-8 -*- -from __future__ import absolute_import, division, print_function - import contextlib import warnings @@ -126,7 +124,7 @@ def test_multidimensional_coordinates(self): @requires_dask def test_string_object_warning(self): original = Variable( - ('x',), np.array([u'foo', u'bar'], dtype=object)).chunk() + ('x',), np.array(['foo', 'bar'], dtype=object)).chunk() with pytest.warns(SerializationWarning, match='dask array with dtype=object'): encoded = conventions.encode_cf_variable(original) diff --git a/xarray/tests/test_dask.py b/xarray/tests/test_dask.py index c77384c5733..b6a70794c23 100644 --- a/xarray/tests/test_dask.py +++ b/xarray/tests/test_dask.py @@ -1,6 +1,6 @@ -from __future__ import absolute_import, division, print_function - import pickle +from collections import OrderedDict +from contextlib import suppress from distutils.version import LooseVersion from textwrap import dedent @@ -11,7 +11,6 @@ import xarray as xr import xarray.ufuncs as xu from xarray import DataArray, Dataset, Variable -from xarray.core.pycompat import OrderedDict, suppress from xarray.tests import mock from . import ( diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 8995fca2f95..32754788eab 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -1,7 +1,6 @@ -from __future__ import absolute_import, division, print_function - import pickle import warnings +from collections import OrderedDict from copy import deepcopy from textwrap import dedent @@ -16,7 +15,6 @@ from xarray.convert import from_cdms2 from xarray.core import dtypes from xarray.core.common import ALL_DIMS, full_like -from xarray.core.pycompat import OrderedDict, iteritems from xarray.tests import ( LooseVersion, ReturnItem, assert_allclose, assert_array_equal, assert_equal, assert_identical, raises_regex, requires_bottleneck, @@ -74,7 +72,7 @@ def test_properties(self): assert len(self.dv) == len(self.v) assert_equal(self.dv.variable, self.v) assert set(self.dv.coords) == set(self.ds.coords) - for k, v in iteritems(self.dv.coords): + for k, v in self.dv.coords.items(): assert_array_equal(v, self.ds.coords[k]) with pytest.raises(AttributeError): self.dv.dataset diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 376c22104c5..416ae99bedf 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -1,8 +1,7 @@ # -*- coding: utf-8 -*- -from __future__ import absolute_import, division, print_function - import sys import warnings +from collections import OrderedDict from copy import copy, deepcopy from io import StringIO import pickle @@ -18,8 +17,7 @@ backends, broadcast, open_dataset, set_options) from xarray.core import dtypes, indexing, npcompat, utils from xarray.core.common import full_like -from xarray.core.pycompat import ( - OrderedDict, integer_types, iteritems, unicode_type) +from xarray.core.pycompat import integer_types from . import ( InaccessibleArray, UnexpectedDataAccess, assert_allclose, @@ -80,7 +78,7 @@ def lazy_inaccessible(k, v): InaccessibleArray(v.values)) return Variable(v.dims, data, v.attrs) return dict((k, lazy_inaccessible(k, v)) for - k, v in iteritems(self._variables)) + k, v in self._variables.items()) class TestDataset(object): @@ -178,7 +176,7 @@ def test_repr_period_index(self): def test_unicode_data(self): # regression test for GH834 - data = Dataset({u'foø': [u'ba®']}, attrs={u'å': u'∑'}) + data = Dataset({'foø': ['ba®']}, attrs={'å': '∑'}) repr(data) # should not raise byteorder = '<' if sys.byteorder == 'little' else '>' @@ -190,20 +188,20 @@ def test_unicode_data(self): Data variables: *empty* Attributes: - å: ∑""" % (byteorder, u'ba®')) - actual = unicode_type(data) + å: ∑""" % (byteorder, 'ba®')) + actual = str(data) assert expected == actual def test_info(self): ds = create_test_data(seed=123) ds = ds.drop('dim3') # string type prints differently in PY2 vs PY3 - ds.attrs['unicode_attr'] = u'ba®' + ds.attrs['unicode_attr'] = 'ba®' ds.attrs['string_attr'] = 'bar' buf = StringIO() ds.info(buf=buf) - expected = dedent(u'''\ + expected = dedent('''\ xarray.Dataset { dimensions: \tdim1 = 8 ; @@ -273,7 +271,7 @@ class Arbitrary(object): pass d = pd.Timestamp('2000-01-01T12') - args = [True, None, 3.4, np.nan, 'hello', u'uni', b'raw', + args = [True, None, 3.4, np.nan, 'hello', b'raw', np.datetime64('2000-01-01'), d, d.to_pydatetime(), Arbitrary()] for arg in args: @@ -836,7 +834,7 @@ def test_isel(self): assert data[v].dims == ret[v].dims assert data[v].attrs == ret[v].attrs slice_list = [slice(None)] * data[v].values.ndim - for d, s in iteritems(slicers): + for d, s in slicers.items(): if d in data[v].dims: inds = np.nonzero(np.array(data[v].dims) == d)[0] for ind in inds: @@ -1889,7 +1887,7 @@ def test_copy(self): def test_copy_with_data(self): orig = create_test_data() new_data = {k: np.random.randn(*v.shape) - for k, v in iteritems(orig.data_vars)} + for k, v in orig.data_vars.items()} actual = orig.copy(data=new_data) expected = orig.copy() @@ -1913,12 +1911,12 @@ def test_rename(self): renamed = data.rename(newnames) variables = OrderedDict(data.variables) - for k, v in iteritems(newnames): + for k, v in newnames.items(): variables[v] = variables.pop(k) - for k, v in iteritems(variables): + for k, v in variables.items(): dims = list(v.dims) - for name, newname in iteritems(newnames): + for name, newname in newnames.items(): if name in dims: dims[dims.index(name)] = newname @@ -2557,7 +2555,7 @@ def test_squeeze(self): def get_args(v): return [set(args[0]) & set(v.dims)] if args else [] expected = Dataset(dict((k, v.squeeze(*get_args(v))) - for k, v in iteritems(data.variables))) + for k, v in data.variables.items())) expected = expected.set_coords(data.coords) assert_identical(expected, data.squeeze(*args)) # invalid squeeze @@ -3450,7 +3448,7 @@ def test_reduce(self): actual = data.max() expected = Dataset(dict((k, v.max()) - for k, v in iteritems(data.data_vars))) + for k, v in data.data_vars.items())) assert_equal(expected, actual) assert_equal(data.min(dim=['dim1']), @@ -3554,7 +3552,7 @@ def test_reduce_strings(self): actual = ds.min() assert_identical(expected, actual) - expected = Dataset({'x': u'a'}) + expected = Dataset({'x': 'a'}) ds = Dataset({'x': ('y', np.array(['a', 'b'], 'U1'))}) actual = ds.min() assert_identical(expected, actual) @@ -4418,9 +4416,9 @@ def test_dir_non_string(data_set): def test_dir_unicode(data_set): - data_set[u'unicode'] = 'uni' + data_set['unicode'] = 'uni' result = dir(data_set) - assert u'unicode' in result + assert 'unicode' in result @pytest.fixture(params=[1]) diff --git a/xarray/tests/test_distributed.py b/xarray/tests/test_distributed.py index 3a79d40c226..17f655cef8d 100644 --- a/xarray/tests/test_distributed.py +++ b/xarray/tests/test_distributed.py @@ -1,5 +1,4 @@ """ isort:skip_file """ -from __future__ import absolute_import, division, print_function import pickle import pytest diff --git a/xarray/tests/test_dtypes.py b/xarray/tests/test_dtypes.py index 292c60b4d05..260486df275 100644 --- a/xarray/tests/test_dtypes.py +++ b/xarray/tests/test_dtypes.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np import pytest diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index 2a6a957e10f..ba7f6ba5db8 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/xarray/tests/test_duck_array_ops.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import warnings from distutils.version import LooseVersion from textwrap import dedent diff --git a/xarray/tests/test_extensions.py b/xarray/tests/test_extensions.py index 608ec798ca1..1b6e665bdae 100644 --- a/xarray/tests/test_extensions.py +++ b/xarray/tests/test_extensions.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import pickle import pytest diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index 6ca5e6f5363..82b7b86bb76 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -1,6 +1,4 @@ # -*- coding: utf-8 -*- -from __future__ import absolute_import, division, print_function - from textwrap import dedent import numpy as np @@ -8,7 +6,6 @@ import xarray as xr from xarray.core import formatting -from xarray.core.pycompat import PY3 from . import raises_regex @@ -83,8 +80,7 @@ def test_format_item(self): (pd.Timedelta('3 hours'), '0 days 03:00:00'), (pd.Timedelta('NaT'), 'NaT'), ('foo', "'foo'"), - (u'foo', "'foo'" if PY3 else "u'foo'"), - (b'foo', "b'foo'" if PY3 else "'foo'"), + (b'foo', "b'foo'"), (1, '1'), (1.0, '1.0'), ] @@ -165,10 +161,10 @@ def test_format_array_flat(self): def test_pretty_print(self): assert formatting.pretty_print('abcdefghij', 8) == 'abcde...' - assert formatting.pretty_print(u'ß', 1) == u'ß' + assert formatting.pretty_print('ß', 1) == 'ß' def test_maybe_truncate(self): - assert formatting.maybe_truncate(u'ß', 10) == u'ß' + assert formatting.maybe_truncate('ß', 10) == 'ß' def test_format_timestamp_out_of_bounds(self): from datetime import datetime @@ -183,15 +179,15 @@ def test_format_timestamp_out_of_bounds(self): assert result == expected def test_attribute_repr(self): - short = formatting.summarize_attr(u'key', u'Short string') - long = formatting.summarize_attr(u'key', 100 * u'Very long string ') - newlines = formatting.summarize_attr(u'key', u'\n\n\n') - tabs = formatting.summarize_attr(u'key', u'\t\t\t') + short = formatting.summarize_attr('key', 'Short string') + long = formatting.summarize_attr('key', 100 * 'Very long string ') + newlines = formatting.summarize_attr('key', '\n\n\n') + tabs = formatting.summarize_attr('key', '\t\t\t') assert short == ' key: Short string' assert len(long) <= 80 - assert long.endswith(u'...') - assert u'\n' not in newlines - assert u'\t' not in tabs + assert long.endswith('...') + assert '\n' not in newlines + assert '\t' not in tabs def test_diff_array_repr(self): da_a = xr.DataArray( diff --git a/xarray/tests/test_groupby.py b/xarray/tests/test_groupby.py index 205bc931693..b623c9bf05d 100644 --- a/xarray/tests/test_groupby.py +++ b/xarray/tests/test_groupby.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np import pandas as pd import pytest diff --git a/xarray/tests/test_indexing.py b/xarray/tests/test_indexing.py index 701eefcb462..14b79c71ca4 100644 --- a/xarray/tests/test_indexing.py +++ b/xarray/tests/test_indexing.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import itertools import numpy as np @@ -8,7 +6,6 @@ from xarray import DataArray, Dataset, Variable from xarray.core import indexing, nputils -from xarray.core.pycompat import native_int_types from . import IndexerMaker, ReturnItem, assert_array_equal, raises_regex @@ -174,7 +171,7 @@ def test_lazily_indexed_array(self): indexing.LazilyOuterIndexedArray) # make sure actual.key is appropriate type - if all(isinstance(k, native_int_types + (slice, )) + if all(isinstance(k, (int, slice, )) for k in v_lazy._data.key.tuple): assert isinstance(v_lazy._data.key, indexing.BasicIndexer) @@ -340,7 +337,7 @@ def check_integer(indexer_cls): def check_slice(indexer_cls): (value,) = indexer_cls((slice(1, None, np.int64(2)),)).tuple assert value == slice(1, None, 2) - assert isinstance(value.step, native_int_types) + assert isinstance(value.step, int) def check_array1d(indexer_cls): diff --git a/xarray/tests/test_interp.py b/xarray/tests/test_interp.py index 624879cce1f..d01929f163b 100644 --- a/xarray/tests/test_interp.py +++ b/xarray/tests/test_interp.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np import pandas as pd import pytest diff --git a/xarray/tests/test_merge.py b/xarray/tests/test_merge.py index 300c490cff6..4f26d616ce7 100644 --- a/xarray/tests/test_merge.py +++ b/xarray/tests/test_merge.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import numpy as np import pytest diff --git a/xarray/tests/test_missing.py b/xarray/tests/test_missing.py index 47224e55473..a60650e412e 100644 --- a/xarray/tests/test_missing.py +++ b/xarray/tests/test_missing.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import itertools import numpy as np diff --git a/xarray/tests/test_options.py b/xarray/tests/test_options.py index 3374ded39f0..1508503f7eb 100644 --- a/xarray/tests/test_options.py +++ b/xarray/tests/test_options.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import pytest import xarray diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py index a2c3adf191f..529d35db865 100644 --- a/xarray/tests/test_plot.py +++ b/xarray/tests/test_plot.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import inspect from datetime import datetime @@ -987,7 +985,7 @@ def test_non_linked_coords_transpose(self): def test_default_title(self): a = DataArray(easy_array((4, 3, 2)), dims=['a', 'b', 'c']) a.coords['c'] = [0, 1] - a.coords['d'] = u'foo' + a.coords['d'] = 'foo' self.plotfunc(a.isel(c=1)) title = plt.gca().get_title() assert 'c = 1, d = foo' == title or 'd = foo, c = 1' == title diff --git a/xarray/tests/test_testing.py b/xarray/tests/test_testing.py index 8a0fa5f6e48..041b7341ade 100644 --- a/xarray/tests/test_testing.py +++ b/xarray/tests/test_testing.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import xarray as xr diff --git a/xarray/tests/test_tutorial.py b/xarray/tests/test_tutorial.py index 6547311aa2f..2bb2cfb0415 100644 --- a/xarray/tests/test_tutorial.py +++ b/xarray/tests/test_tutorial.py @@ -1,11 +1,9 @@ -from __future__ import absolute_import, division, print_function - import os +from contextlib import suppress import pytest from xarray import DataArray, tutorial -from xarray.core.pycompat import suppress from . import assert_identical, network diff --git a/xarray/tests/test_ufuncs.py b/xarray/tests/test_ufuncs.py index ff24eee3303..fab828588c6 100644 --- a/xarray/tests/test_ufuncs.py +++ b/xarray/tests/test_ufuncs.py @@ -1,5 +1,3 @@ -from __future__ import absolute_import, division, print_function - import pickle import numpy as np diff --git a/xarray/tests/test_utils.py b/xarray/tests/test_utils.py index fc14ae2350a..5a5041b5449 100644 --- a/xarray/tests/test_utils.py +++ b/xarray/tests/test_utils.py @@ -1,5 +1,4 @@ -from __future__ import absolute_import, division, print_function - +from collections import OrderedDict from datetime import datetime import numpy as np @@ -9,7 +8,6 @@ import xarray as xr from xarray.coding.cftimeindex import CFTimeIndex from xarray.core import duck_array_ops, utils -from xarray.core.pycompat import OrderedDict from xarray.core.utils import either_dict_or_kwargs from xarray.testing import assert_identical diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index fdcc184eec4..eec8d268026 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -1,7 +1,5 @@ - -from __future__ import absolute_import, division, print_function - import warnings +from collections import OrderedDict from copy import copy, deepcopy from datetime import datetime, timedelta from distutils.version import LooseVersion @@ -19,7 +17,6 @@ BasicIndexer, CopyOnWriteArray, DaskIndexingAdapter, LazilyOuterIndexedArray, MemoryCachedArray, NumpyIndexingAdapter, OuterIndexer, PandasIndexAdapter, VectorizedIndexer) -from xarray.core.pycompat import PY3, OrderedDict from xarray.core.utils import NDArrayMixin from xarray.core.variable import as_compatible_data, as_variable from xarray.tests import requires_bottleneck @@ -42,7 +39,7 @@ def test_properties(self): assert v.nbytes == 80 assert v.ndim == 1 assert len(v) == 10 - assert v.attrs == {'foo': u'bar'} + assert v.attrs == {'foo': 'bar'} def test_attrs(self): v = self.cls(['time'], 0.5 * np.arange(10)) @@ -164,10 +161,10 @@ def test_index_0d_float(self): self._assertIndexedLikeNDArray(x, value, dtype) def test_index_0d_string(self): - for value, dtype in [('foo', np.dtype('U3' if PY3 else 'S3')), - (u'foo', np.dtype('U3'))]: - x = self.cls(['x'], [value]) - self._assertIndexedLikeNDArray(x, value, dtype) + value = 'foo' + dtype = np.dtype('U3') + x = self.cls(['x'], [value]) + self._assertIndexedLikeNDArray(x, value, dtype) def test_index_0d_datetime(self): d = datetime(2000, 1, 1) @@ -869,13 +866,13 @@ def test_timedelta64_conversion_scalar(self): assert v.values.dtype == np.dtype('timedelta64[ns]') def test_0d_str(self): - v = Variable([], u'foo') + v = Variable([], 'foo') assert v.dtype == np.dtype('U3') assert v.values == 'foo' v = Variable([], np.string_('foo')) assert v.dtype == np.dtype('S3') - assert v.values == bytes('foo', 'ascii') if PY3 else 'foo' + assert v.values == bytes('foo', 'ascii') def test_0d_datetime(self): v = Variable([], pd.Timestamp('2000-01-01')) @@ -1170,13 +1167,13 @@ def test_index_0d_numpy_string(self): v = Variable([], np.string_('asdf')) assert_identical(v[()], v) - v = Variable([], np.unicode_(u'asdf')) + v = Variable([], np.unicode_('asdf')) assert_identical(v[()], v) def test_indexing_0d_unicode(self): # regression test for GH568 - actual = Variable(('x'), [u'tmax'])[0][()] - expected = Variable((), u'tmax') + actual = Variable(('x'), ['tmax'])[0][()] + expected = Variable((), 'tmax') assert_identical(actual, expected) @pytest.mark.parametrize('fill_value', [dtypes.NA, 2, 2.0]) diff --git a/xarray/tutorial.py b/xarray/tutorial.py index 064eed330cc..3f92bd9a400 100644 --- a/xarray/tutorial.py +++ b/xarray/tutorial.py @@ -5,14 +5,12 @@ * building tutorials in the documentation. ''' -from __future__ import absolute_import, division, print_function - import hashlib import os as _os import warnings +from urllib.request import urlretrieve from .backends.api import open_dataset as _open_dataset -from .core.pycompat import urlretrieve as _urlretrieve _default_cache_dir = _os.sep.join(('~', '.xarray_tutorial_data')) @@ -68,9 +66,9 @@ def open_dataset(name, cache=True, cache_dir=_default_cache_dir, _os.mkdir(longdir) url = '/'.join((github_url, 'raw', branch, fullname)) - _urlretrieve(url, localfile) + urlretrieve(url, localfile) url = '/'.join((github_url, 'raw', branch, md5name)) - _urlretrieve(url, md5file) + urlretrieve(url, md5file) localmd5 = file_md5_checksum(localfile) with open(md5file, 'r') as f: diff --git a/xarray/ufuncs.py b/xarray/ufuncs.py index 66602290dab..dcba208436e 100644 --- a/xarray/ufuncs.py +++ b/xarray/ufuncs.py @@ -13,8 +13,6 @@ Once NumPy 1.10 comes out with support for overriding ufuncs, this module will hopefully no longer be necessary. """ -from __future__ import absolute_import, division, print_function - import warnings as _warnings import numpy as _np diff --git a/xarray/util/print_versions.py b/xarray/util/print_versions.py index 5459e67e603..87eb7399e69 100755 --- a/xarray/util/print_versions.py +++ b/xarray/util/print_versions.py @@ -2,7 +2,6 @@ see pandas/pandas/util/_print_versions.py''' -from __future__ import absolute_import import codecs import importlib From cc5015aabe0b08cdf05610ead9e7bfcbeee807c8 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Fri, 25 Jan 2019 11:55:07 -0800 Subject: [PATCH 070/108] BUG: ensure indexes are reset when coords are modified (#2707) This was introduced by the recent indexes refactor, but never made it into a release. --- xarray/core/coordinates.py | 1 + xarray/tests/test_cftimeindex.py | 2 +- xarray/tests/test_dataarray.py | 5 +++++ xarray/tests/test_dataset.py | 5 +++++ 4 files changed, 12 insertions(+), 1 deletion(-) diff --git a/xarray/core/coordinates.py b/xarray/core/coordinates.py index 7c62d5fd7b5..19e2d009e44 100644 --- a/xarray/core/coordinates.py +++ b/xarray/core/coordinates.py @@ -234,6 +234,7 @@ def _update_coords(self, coords): raise ValueError('cannot add coordinates with new dimensions to ' 'a DataArray') self._data._coords = coords + self._data._indexes = None @property def variables(self): diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 09c598272e3..0d6ba6b47c9 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -8,7 +8,7 @@ from xarray.coding.cftimeindex import ( CFTimeIndex, _parse_array_of_cftime_strings, _parse_iso8601_with_reso, _parsed_string_to_bounds, assert_all_valid_date_type, parse_iso8601) -from xarray.tests import assert_array_equal, assert_identical +from xarray.tests import assert_array_equal, assert_allclose, assert_identical from . import ( has_cftime, has_cftime_1_0_2_1, has_cftime_or_netCDF4, raises_regex, diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 32754788eab..23e15aeff24 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -1220,6 +1220,11 @@ def test_coords_alignment(self): dims='x') assert_identical(lhs, expected) + def test_set_coords_update_index(self): + actual = DataArray([1, 2, 3], [('x', [1, 2, 3])]) + actual.coords['x'] = ['a', 'b', 'c'] + assert actual.indexes['x'].equals(pd.Index(['a', 'b', 'c'])) + def test_coords_replacement_alignment(self): # regression test for GH725 arr = DataArray([0, 1, 2], dims=['abc']) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 416ae99bedf..23a77b54356 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -587,6 +587,11 @@ def test_coords_modify(self): expected = data.merge({'c': 11}).set_coords('c') assert_identical(expected, actual) + def test_update_index(self): + actual = Dataset(coords={'x': [1, 2, 3]}) + actual['x'] = ['a', 'b', 'c'] + assert actual.indexes['x'].equals(pd.Index(['a', 'b', 'c'])) + def test_coords_setitem_with_new_dimension(self): actual = Dataset() actual.coords['foo'] = ('x', [1, 2, 3]) From 2e99c7dde32e396dd2c5fc6261a2d06217621e10 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Fri, 25 Jan 2019 13:52:17 -0800 Subject: [PATCH 071/108] Print full environment fron conf.py (#2709) This should make it easier to debug the doc build environment. --- doc/conf.py | 47 ++++++++++++++++++++++++++--------------------- 1 file changed, 26 insertions(+), 21 deletions(-) diff --git a/doc/conf.py b/doc/conf.py index 897c0443054..322741556b6 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -13,9 +13,10 @@ # serve to show the default. from __future__ import absolute_import, division, print_function +from contextlib import suppress import datetime -import importlib import os +import subprocess import sys import xarray @@ -24,29 +25,33 @@ print("python exec:", sys.executable) print("sys.path:", sys.path) -for name in ('numpy scipy pandas matplotlib dask IPython seaborn ' - 'cartopy netCDF4 rasterio zarr iris flake8 ' - 'sphinx_gallery cftime').split(): - try: - module = importlib.import_module(name) - if name == 'matplotlib': - module.use('Agg') - fname = module.__file__.rstrip('__init__.py') - print("%s: %s, %s" % (name, module.__version__, fname)) - except ImportError: - print("no %s" % name) - # neither rasterio nor cartopy should be hard requirements for - # the doc build. - if name == 'rasterio': - allowed_failures.update(['gallery/plot_rasterio_rgb.py', - 'gallery/plot_rasterio.py']) - elif name == 'cartopy': - allowed_failures.update(['gallery/plot_cartopy_facetgrid.py', - 'gallery/plot_rasterio_rgb.py', - 'gallery/plot_rasterio.py']) + +if 'conda' in sys.executable: + print('conda environment:') + subprocess.run(['conda', 'list']) +else: + print('pip environment:') + subprocess.run(['pip', 'list']) print("xarray: %s, %s" % (xarray.__version__, xarray.__file__)) +with suppress(ImportError): + import matplotlib + matplotlib.use('Agg') + +try: + import rasterio +except ImportError: + allowed_failures.update(['gallery/plot_rasterio_rgb.py', + 'gallery/plot_rasterio.py']) + +try: + import cartopy +except ImportError: + allowed_failures.update(['gallery/plot_cartopy_facetgrid.py', + 'gallery/plot_rasterio_rgb.py', + 'gallery/plot_rasterio.py']) + # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. From 8ca8efe16698e08e6ac96c63e720c3a7efd248a7 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sat, 26 Jan 2019 10:14:49 -0800 Subject: [PATCH 072/108] Update environment for doc build (#2708) * Update environment for doc build We were pinning very old versions for most of these packages. This should fix the failures on ReadTheDocs. * Build fixes --- .travis.yml | 4 ++-- ci/requirements-py36.yml | 4 ++-- doc/environment.yml | 29 +++++++++++++----------- doc/examples/multidimensional-coords.rst | 3 +-- doc/pandas.rst | 6 ++--- doc/time-series.rst | 2 -- 6 files changed, 23 insertions(+), 25 deletions(-) diff --git a/.travis.yml b/.travis.yml index a21d4d94413..fbc01b4815d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -60,8 +60,8 @@ script: - python --version - python -OO -c "import xarray" - if [[ "$CONDA_ENV" == "docs" ]]; then - conda install -c conda-forge --override-channels sphinx sphinx_rtd_theme sphinx-gallery numpydoc "gdal>2.2.4"; - sphinx-build -n -j auto -b html -d _build/doctrees doc _build/html; + cd doc; + sphinx-build -n -j auto -b html -d _build/doctrees . _build/html; elif [[ "$CONDA_ENV" == "lint" ]]; then pycodestyle xarray ; elif [[ "$CONDA_ENV" == "py36-hypothesis" ]]; then diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index 0ed6dd78c3a..7523b14608b 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -26,8 +26,8 @@ dependencies: - pseudonetcdf>=3.0.1 - eccodes - cdms2 - # - pynio # xref #2683 - # - iris>=1.10 # xref #2683 +# - pynio # xref #2683 +# - iris>=1.10 # xref #2683 - pydap - lxml - pip: diff --git a/doc/environment.yml b/doc/environment.yml index ca4f622cd38..f4d1f4e9008 100644 --- a/doc/environment.yml +++ b/doc/environment.yml @@ -2,22 +2,25 @@ name: xarray-docs channels: - conda-forge dependencies: - - python=3.6 - - numpy=1.14.5 + - python=3.7 + - numpy=1.16.0 - pandas=0.23.3 - - scipy=1.1.0 - - matplotlib=2.2.2 + - scipy=1.2.0 + - matplotlib=3.0.2 - seaborn=0.9.0 - - dask=0.18.2 - - ipython=6.4.0 - - netCDF4=1.4.0 - - cartopy=0.16.0 - - rasterio=1.0.1 + - dask=1.1.0 + - ipython=7.2.0 + - netCDF4=1.4.2 + - cartopy=0.17.0 + - rasterio=1.0.13 - zarr=2.2.0 - - iris=2.1.0 - - flake8=3.5.0 + - iris=2.2.0 + - flake8=3.6.0 - cftime=1.0.3.4 - - bottleneck=1.2 - - sphinx=1.7.6 + - bottleneck=1.2.1 + - sphinx=1.8.2 - numpydoc=0.8.0 - sphinx-gallery=0.2.0 + - pillow=5.4.1 + - sphinx_rtd_theme=0.4.2 + - mock=2.0.0 diff --git a/doc/examples/multidimensional-coords.rst b/doc/examples/multidimensional-coords.rst index 7c86f897a24..a5084043977 100644 --- a/doc/examples/multidimensional-coords.rst +++ b/doc/examples/multidimensional-coords.rst @@ -78,9 +78,8 @@ grid, we can take advantage of xarray's ability to apply ax = plt.axes(projection=ccrs.PlateCarree()); ds.Tair[0].plot.pcolormesh(ax=ax, transform=ccrs.PlateCarree(), x='xc', y='yc', add_colorbar=False); - ax.coastlines(); @savefig xarray_multidimensional_coords_12_0.png width=100% - plt.tight_layout(); + ax.coastlines(); Multidimensional Groupby ------------------------ diff --git a/doc/pandas.rst b/doc/pandas.rst index fc20d161e05..1538fced648 100644 --- a/doc/pandas.rst +++ b/doc/pandas.rst @@ -14,7 +14,7 @@ __ http://pandas.pydata.org/pandas-docs/stable/visualization.html __ http://stanford.edu/~mwaskom/software/seaborn/ .. ipython:: python - :suppress: + :suppress: import numpy as np import pandas as pd @@ -93,7 +93,6 @@ DataFrames: s = ds['foo'].to_series() s - # or equivalently, with Series.to_xarray() xr.DataArray.from_series(s) @@ -173,11 +172,10 @@ So you can represent a Panel, in two ways: Let's take a look: .. ipython:: python - :okwarning: + :okwarning: panel = pd.Panel(np.random.rand(2, 3, 4), items=list('ab'), major_axis=list('mno'), minor_axis=pd.date_range(start='2000', periods=4, name='date')) - panel As a DataArray: diff --git a/doc/time-series.rst b/doc/time-series.rst index 1ced1ac30f6..32c6b581aa4 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -15,7 +15,6 @@ core functionality. import numpy as np import pandas as pd import xarray as xr - np.random.seed(123456) Creating datetime64 data @@ -241,7 +240,6 @@ coordinate with dates from a no-leap calendar and a from itertools import product from cftime import DatetimeNoLeap - dates = [DatetimeNoLeap(year, month, 1) for year, month in product(range(1, 3), range(1, 13))] da = xr.DataArray(np.arange(24), coords=[dates], dims=['time'], name='foo') From 882deac6a38078a64032f88d4785567fd9be8d56 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sun, 27 Jan 2019 09:11:47 -0800 Subject: [PATCH 073/108] DOC: refresh whats-new for 0.11.3 / 0.12.0 (#2718) --- doc/whats-new.rst | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index c408306ffdb..37ea0ba8601 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -13,9 +13,9 @@ What's New import xarray as xr np.random.seed(123456) -.. _whats-new.0.11.3: +.. _whats-new.0.12.0: -v0.11.3 (unreleased) +v0.12.0 (unreleased) -------------------- Breaking changes @@ -52,9 +52,23 @@ Bug fixes from higher frequencies to lower frequencies. Datapoints outside the bounds of the original time coordinate are now filled with NaN (:issue:`2197`). By `Spencer Clark `_. + +.. _whats-new.0.11.3: + +v0.11.3 (26 January 2019) +------------------------- + +Bug fixes +~~~~~~~~~ + - Saving files with times encoded with reference dates with timezones (e.g. '2000-01-01T00:00:00-05:00') no longer raises an error (:issue:`2649`). By `Spencer Clark `_. +- Fixed performance regression with ``open_mfdataset`` (:issue:`2662`). + By `Tom Nicholas `_. +- Fixed supplying an explicit dimension in the ``concat_dim`` argument to + to ``open_mfdataset`` (:issue:`2647`). + By `Ben Root `_. .. _whats-new.0.11.2: From 620b946b6f9ad922d919c68b0954d7ac13e65282 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sun, 27 Jan 2019 13:02:03 -0800 Subject: [PATCH 074/108] Fix test failures / warnings for pandas 0.24 (#2720) * Fix test failures / warnings for pandas 0.24 Fixes GH2717 * Brief doc note * Comment on name order --- doc/whats-new.rst | 2 ++ xarray/core/coordinates.py | 5 +++-- xarray/core/dataset.py | 15 ++++++++----- xarray/tests/test_coding_times.py | 25 +++++++++++++--------- xarray/tests/test_dataarray.py | 35 +++++++++++-------------------- xarray/tests/test_utils.py | 8 +++++-- 6 files changed, 48 insertions(+), 42 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 37ea0ba8601..184cee05ae2 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -47,6 +47,8 @@ Enhancements Bug fixes ~~~~~~~~~ +- Silenced warnings that appear when using pandas 0.24. + By `Stephan Hoyer `_ - Interpolating via resample now internally specifies ``bounds_error=False`` as an argument to ``scipy.interpolate.interp1d``, allowing for interpolation from higher frequencies to lower frequencies. Datapoints outside the bounds diff --git a/xarray/core/coordinates.py b/xarray/core/coordinates.py index 19e2d009e44..9347ba6b6db 100644 --- a/xarray/core/coordinates.py +++ b/xarray/core/coordinates.py @@ -1,4 +1,5 @@ -from collections import Mapping, OrderedDict +import collections.abc +from collections import OrderedDict from contextlib import contextmanager import pandas as pd @@ -14,7 +15,7 @@ _THIS_ARRAY = ReprObject('') -class AbstractCoordinates(Mapping): +class AbstractCoordinates(collections.abc.Mapping): def __getitem__(self, key): raise NotImplementedError diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 711dfcdce71..0d1b9ebd55b 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -130,7 +130,7 @@ def merge_indexes( if isinstance(var_names, str): var_names = [var_names] - names, labels, levels = [], [], [] # type: (list, list, list) + names, codes, levels = [], [], [] # type: (list, list, list) current_index_variable = variables.get(dim) for n in var_names: @@ -144,13 +144,18 @@ def merge_indexes( if current_index_variable is not None and append: current_index = current_index_variable.to_index() if isinstance(current_index, pd.MultiIndex): + try: + current_codes = current_index.codes + except AttributeError: + # fpr pandas<0.24 + current_codes = current_index.labels names.extend(current_index.names) - labels.extend(current_index.labels) + codes.extend(current_codes) levels.extend(current_index.levels) else: names.append('%s_level_0' % dim) cat = pd.Categorical(current_index.values, ordered=True) - labels.append(cat.codes) + codes.append(cat.codes) levels.append(cat.categories) if not len(names) and len(var_names) == 1: @@ -161,10 +166,10 @@ def merge_indexes( names.append(n) var = variables[n] cat = pd.Categorical(var.values, ordered=True) - labels.append(cat.codes) + codes.append(cat.codes) levels.append(cat.categories) - idx = pd.MultiIndex(labels=labels, levels=levels, names=names) + idx = pd.MultiIndex(levels, codes, names=names) vars_to_replace[dim] = IndexVariable(dim, idx) vars_to_remove.extend(var_names) diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 24234d3b6b5..863c0378835 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -533,17 +533,22 @@ def test_infer_cftime_datetime_units(calendar, date_args, expected): @pytest.mark.parametrize( ['timedeltas', 'units', 'numbers'], - [('1D', 'days', np.int64(1)), - (['1D', '2D', '3D'], 'days', np.array([1, 2, 3], 'int64')), - ('1h', 'hours', np.int64(1)), - ('1ms', 'milliseconds', np.int64(1)), - ('1us', 'microseconds', np.int64(1)), - (['NaT', '0s', '1s'], None, [np.nan, 0, 1]), - (['30m', '60m'], 'hours', [0.5, 1.0]), - (np.timedelta64('NaT', 'ns'), 'days', np.nan), - (['NaT', 'NaT'], 'days', [np.nan, np.nan])]) + [ + ('1D', 'days', np.int64(1)), + (['1D', '2D', '3D'], 'days', np.array([1, 2, 3], 'int64')), + ('1h', 'hours', np.int64(1)), + ('1ms', 'milliseconds', np.int64(1)), + ('1us', 'microseconds', np.int64(1)), + (['NaT', '0s', '1s'], None, [np.nan, 0, 1]), + (['30m', '60m'], 'hours', [0.5, 1.0]), + ('NaT', 'days', np.nan), + (['NaT', 'NaT'], 'days', [np.nan, np.nan]), + ]) def test_cf_timedelta(timedeltas, units, numbers): - timedeltas = pd.to_timedelta(timedeltas, box=False) + if timedeltas == 'NaT': + timedeltas = np.timedelta64('NaT', 'ns') + else: + timedeltas = pd.to_timedelta(timedeltas, box=False) numbers = np.array(numbers) expected = numbers diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 23e15aeff24..59d14d7cdac 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -122,21 +122,14 @@ def test_struct_array_dims(self): """ # GH837, GH861 # checking array subraction when dims are the same - p_data = np.array([('John', 180), ('Stacy', 150), ('Dick', 200)], + # note: names need to be in sorted order to align consistently with + # pandas < 0.24 and >= 0.24. + p_data = np.array([('Abe', 180), ('Stacy', 150), ('Dick', 200)], dtype=[('name', '|S256'), ('height', object)]) - - p_data_1 = np.array([('John', 180), ('Stacy', 150), ('Dick', 200)], - dtype=[('name', '|S256'), ('height', object)]) - - p_data_2 = np.array([('John', 180), ('Dick', 200)], - dtype=[('name', '|S256'), ('height', object)]) - weights_0 = DataArray([80, 56, 120], dims=['participant'], coords={'participant': p_data}) - weights_1 = DataArray([81, 52, 115], dims=['participant'], - coords={'participant': p_data_1}) - + coords={'participant': p_data}) actual = weights_1 - weights_0 expected = DataArray([1, -4, -5], dims=['participant'], @@ -145,31 +138,27 @@ def test_struct_array_dims(self): assert_identical(actual, expected) # checking array subraction when dims are not the same - p_data_1 = np.array([('John', 180), ('Stacy', 151), ('Dick', 200)], - dtype=[('name', '|S256'), ('height', object)]) - + p_data_alt = np.array([('Abe', 180), ('Stacy', 151), ('Dick', 200)], + dtype=[('name', '|S256'), ('height', object)]) weights_1 = DataArray([81, 52, 115], dims=['participant'], - coords={'participant': p_data_1}) - + coords={'participant': p_data_alt}) actual = weights_1 - weights_0 expected = DataArray([1, -5], dims=['participant'], - coords={'participant': p_data_2}) + coords={'participant': p_data[[0, 2]]}) assert_identical(actual, expected) # checking array subraction when dims are not the same and one # is np.nan - p_data_1 = np.array([('John', 180), ('Stacy', np.nan), ('Dick', 200)], - dtype=[('name', '|S256'), ('height', object)]) - + p_data_nan = np.array([('Abe', 180), ('Stacy', np.nan), ('Dick', 200)], + dtype=[('name', '|S256'), ('height', object)]) weights_1 = DataArray([81, 52, 115], dims=['participant'], - coords={'participant': p_data_1}) - + coords={'participant': p_data_nan}) actual = weights_1 - weights_0 expected = DataArray([1, -5], dims=['participant'], - coords={'participant': p_data_2}) + coords={'participant': p_data[[0, 2]]}) assert_identical(actual, expected) diff --git a/xarray/tests/test_utils.py b/xarray/tests/test_utils.py index 5a5041b5449..09152bac284 100644 --- a/xarray/tests/test_utils.py +++ b/xarray/tests/test_utils.py @@ -74,7 +74,9 @@ def test_multiindex_from_product_levels(): result = utils.multiindex_from_product_levels( [pd.Index(['b', 'a']), pd.Index([1, 3, 2])]) np.testing.assert_array_equal( - result.labels, [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]) + # compat for pandas < 0.24 + result.codes if hasattr(result, 'codes') else result.labels, + [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]) np.testing.assert_array_equal(result.levels[0], ['b', 'a']) np.testing.assert_array_equal(result.levels[1], [1, 3, 2]) @@ -86,7 +88,9 @@ def test_multiindex_from_product_levels_non_unique(): result = utils.multiindex_from_product_levels( [pd.Index(['b', 'a']), pd.Index([1, 1, 2])]) np.testing.assert_array_equal( - result.labels, [[0, 0, 0, 1, 1, 1], [0, 0, 1, 0, 0, 1]]) + # compat for pandas < 0.24 + result.codes if hasattr(result, 'codes') else result.labels, + [[0, 0, 0, 1, 1, 1], [0, 0, 1, 0, 0, 1]]) np.testing.assert_array_equal(result.levels[0], ['b', 'a']) np.testing.assert_array_equal(result.levels[1], [1, 2]) From e8bf4bf9a744148f1f6586cabe7f5c5ef6e9bf26 Mon Sep 17 00:00:00 2001 From: Tom Nicholas <35968931+TomNicholas@users.noreply.github.com> Date: Wed, 30 Jan 2019 02:02:22 +0000 Subject: [PATCH 075/108] Bugfix for line plot axes (#2726) * Fixed logic for setting line data * Added tests to check line data matches values of correct coords * Recorded bugfix for line plots * Update doc/whats-new.rst Co-Authored-By: TomNicholas <35968931+TomNicholas@users.noreply.github.com> * Update doc/whats-new.rst Co-Authored-By: TomNicholas <35968931+TomNicholas@users.noreply.github.com> --- doc/whats-new.rst | 2 ++ xarray/plot/plot.py | 14 +++++++++----- xarray/tests/test_plot.py | 15 +++++++++++++++ 3 files changed, 26 insertions(+), 5 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 184cee05ae2..39ba72063ef 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -54,6 +54,8 @@ Bug fixes from higher frequencies to lower frequencies. Datapoints outside the bounds of the original time coordinate are now filled with NaN (:issue:`2197`). By `Spencer Clark `_. +- Line plots with the `x` argument set to a non-dimensional coord now plot the correct data for 1D DataArrays. + (:issue:`27251). By `Tom Nicholas `_. .. _whats-new.0.11.3: diff --git a/xarray/plot/plot.py b/xarray/plot/plot.py index 13d6ec31104..9178dd8f031 100644 --- a/xarray/plot/plot.py +++ b/xarray/plot/plot.py @@ -200,18 +200,22 @@ def _infer_line_data(darray, x, y, hue): 'for line plots.') if ndims == 1: - dim, = darray.dims # get the only dimension name huename = None hueplt = None huelabel = '' - if (x is None and y is None) or x == dim: - xplt = darray[dim] + if x is not None: + xplt = darray[x] yplt = darray - else: - yplt = darray[dim] + elif y is not None: xplt = darray + yplt = darray[y] + + else: # Both x & y are None + dim = darray.dims[0] + xplt = darray[dim] + yplt = darray else: if x is None and y is None and hue is None: diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py index 529d35db865..3b08ce706f5 100644 --- a/xarray/tests/test_plot.py +++ b/xarray/tests/test_plot.py @@ -4,6 +4,7 @@ import numpy as np import pandas as pd import pytest +from numpy.testing import assert_array_equal import xarray as xr import xarray.plot as xplt @@ -140,6 +141,20 @@ def test_1d_x_y_kw(self): with raises_regex(ValueError, 'None'): da.plot(x='z', y='f') + # Test for bug in GH issue #2725 + def test_infer_line_data(self): + current = DataArray(name='I', data=np.array([5, 8]), dims=['t'], + coords={'t': (['t'], np.array([0.1, 0.2])), + 'V': (['t'], np.array([100, 200]))}) + + # Plot current against voltage + line = current.plot.line(x='V')[0] + assert_array_equal(line.get_xdata(), current.coords['V'].values) + + # Plot current against time + line = current.plot.line()[0] + assert_array_equal(line.get_xdata(), current.coords['t'].values) + def test_2d_line(self): with raises_regex(ValueError, 'hue'): self.darray[:, :, 0].plot.line() From fd2552a0f2d837c43085bc0c5d5da428771b8989 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Wed, 30 Jan 2019 11:45:09 -0500 Subject: [PATCH 076/108] Enable subtracting a scalar cftime.datetime object from a CFTimeIndex (#2672) * Enable subtracting a scalar cftime.datetime object from a CFTimeIndex * lint * Test cftime.datetime minus CFTimeIndex as well * Fix cftime minus CFTimeIndex --- doc/whats-new.rst | 4 ++++ xarray/coding/cftimeindex.py | 6 +++++- xarray/tests/test_cftimeindex.py | 20 ++++++++++++++++++++ 3 files changed, 29 insertions(+), 1 deletion(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 39ba72063ef..f6fdcef9306 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -56,6 +56,10 @@ Bug fixes `Spencer Clark `_. - Line plots with the `x` argument set to a non-dimensional coord now plot the correct data for 1D DataArrays. (:issue:`27251). By `Tom Nicholas `_. +- Subtracting a scalar ``cftime.datetime`` object from a + :py:class:`CFTimeIndex` now results in a :py:class:`pandas.TimedeltaIndex` + instead of raising a ``TypeError`` (:issue:`2671`). By `Spencer Clark + `_. .. _whats-new.0.11.3: diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 1861d49a1d4..f1a05d31a0c 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -408,13 +408,17 @@ def __radd__(self, other): return CFTimeIndex(other + np.array(self)) def __sub__(self, other): - if isinstance(other, CFTimeIndex): + import cftime + if isinstance(other, (CFTimeIndex, cftime.datetime)): return pd.TimedeltaIndex(np.array(self) - np.array(other)) elif isinstance(other, pd.TimedeltaIndex): return CFTimeIndex(np.array(self) - other.to_pytimedelta()) else: return CFTimeIndex(np.array(self) - other) + def __rsub__(self, other): + return pd.TimedeltaIndex(other - np.array(self)) + def _add_delta(self, deltas): # To support TimedeltaIndex + CFTimeIndex with older versions of # pandas. No longer used as of pandas 0.23. diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 0d6ba6b47c9..97be993d842 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -700,6 +700,26 @@ def test_cftimeindex_sub_cftimeindex(calendar): assert isinstance(result, pd.TimedeltaIndex) +@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +@pytest.mark.parametrize('calendar', _CFTIME_CALENDARS) +def test_cftimeindex_sub_cftime_datetime(calendar): + a = xr.cftime_range('2000', periods=5, calendar=calendar) + result = a - a[0] + expected = pd.TimedeltaIndex([timedelta(days=i) for i in range(5)]) + assert result.equals(expected) + assert isinstance(result, pd.TimedeltaIndex) + + +@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +@pytest.mark.parametrize('calendar', _CFTIME_CALENDARS) +def test_cftime_datetime_sub_cftimeindex(calendar): + a = xr.cftime_range('2000', periods=5, calendar=calendar) + result = a[0] - a + expected = pd.TimedeltaIndex([timedelta(days=-i) for i in range(5)]) + assert result.equals(expected) + assert isinstance(result, pd.TimedeltaIndex) + + @pytest.mark.skipif(not has_cftime, reason='cftime not installed') @pytest.mark.parametrize('calendar', _CFTIME_CALENDARS) def test_cftimeindex_sub_timedeltaindex(calendar): From 37a947abc97f41aacdd91b6322275c73d757d60c Mon Sep 17 00:00:00 2001 From: Deepak Cherian Date: Wed, 30 Jan 2019 09:20:57 -0800 Subject: [PATCH 077/108] Refactor plot utils (#2670) * Refactor out utility functions. * facetgrid refactor 1. refactor out _easy_facetgrid 2. Combine map_dataarray_line with map_dataarray * flake8 * Refactor out colorbar making to plot.utils._add_colorbar * Refactor out cmap_params, cbar_kwargs processing * Back to map_dataarray_line * lint * small rename * review comment. * Move _infer_line_data back. --- xarray/plot/facetgrid.py | 87 ++++----- xarray/plot/plot.py | 410 ++++++++------------------------------- xarray/plot/utils.py | 232 ++++++++++++++++++++++ 3 files changed, 361 insertions(+), 368 deletions(-) diff --git a/xarray/plot/facetgrid.py b/xarray/plot/facetgrid.py index 2a4c67036d6..4f0232236f8 100644 --- a/xarray/plot/facetgrid.py +++ b/xarray/plot/facetgrid.py @@ -7,8 +7,8 @@ from ..core.formatting import format_item from .utils import ( - _determine_cmap_params, _infer_xy_labels, import_matplotlib_pyplot, - label_from_attrs) + _infer_xy_labels, _process_cmap_cbar_kwargs, + import_matplotlib_pyplot, label_from_attrs) # Overrides axes.labelsize, xtick.major.size, ytick.major.size # from mpl.rcParams @@ -219,32 +219,13 @@ def map_dataarray(self, func, x, y, **kwargs): """ - cmapkw = kwargs.get('cmap') - colorskw = kwargs.get('colors') - cbar_kwargs = kwargs.pop('cbar_kwargs', {}) - cbar_kwargs = {} if cbar_kwargs is None else dict(cbar_kwargs) - if kwargs.get('cbar_ax', None) is not None: raise ValueError('cbar_ax not supported by FacetGrid.') - # colors is mutually exclusive with cmap - if cmapkw and colorskw: - raise ValueError("Can't specify both cmap and colors.") - - # These should be consistent with xarray.plot._plot2d - cmap_kwargs = {'plot_data': self.data.values, - # MPL default - 'levels': 7 if 'contour' in func.__name__ else None, - 'filled': func.__name__ != 'contour', - } - - cmap_args = getfullargspec(_determine_cmap_params).args - cmap_kwargs.update((a, kwargs[a]) for a in cmap_args if a in kwargs) + cmap_params, cbar_kwargs = _process_cmap_cbar_kwargs( + func, kwargs, self.data.values) - cmap_params = _determine_cmap_params(**cmap_kwargs) - - if colorskw is not None: - cmap_params['cmap'] = None + self._cmap_extend = cmap_params.get('extend') # Order is important func_kwargs = kwargs.copy() @@ -260,7 +241,7 @@ def map_dataarray(self, func, x, y, **kwargs): # None is the sentinel value if d is not None: subset = self.data.loc[d] - mappable = func(subset, x, y, ax=ax, **func_kwargs) + mappable = func(subset, x=x, y=y, ax=ax, **func_kwargs) self._mappables.append(mappable) self._cmap_extend = cmap_params.get('extend') @@ -271,36 +252,24 @@ def map_dataarray(self, func, x, y, **kwargs): return self - def map_dataarray_line(self, x=None, y=None, hue=None, **kwargs): - """ - Apply a line plot to a 2d facet subset of the data. - - Parameters - ---------- - x, y, hue: string - dimension names for the axes and hues of each facet - - Returns - ------- - self : FacetGrid object - - """ - from .plot import line, _infer_line_data + def map_dataarray_line(self, func, x, y, **kwargs): + from .plot import _infer_line_data add_legend = kwargs.pop('add_legend', True) kwargs['add_legend'] = False + func_kwargs = kwargs.copy() + func_kwargs['_labels'] = False for d, ax in zip(self.name_dicts.flat, self.axes.flat): # None is the sentinel value if d is not None: subset = self.data.loc[d] - mappable = line(subset, x=x, y=y, hue=hue, - ax=ax, _labels=False, - **kwargs) + mappable = func(subset, x=x, y=y, ax=ax, **func_kwargs) self._mappables.append(mappable) + _, _, hueplt, xlabel, ylabel, huelabel = _infer_line_data( darray=self.data.loc[self.name_dicts.flat[0]], - x=x, y=y, hue=hue) + x=x, y=y, hue=func_kwargs['hue']) self._hue_var = hueplt self._hue_label = huelabel @@ -520,3 +489,33 @@ def map(self, func, *args, **kwargs): self._finalize_grid(*args[:2]) return self + + +def _easy_facetgrid(data, plotfunc, kind, x=None, y=None, row=None, + col=None, col_wrap=None, sharex=True, sharey=True, + aspect=None, size=None, subplot_kws=None, **kwargs): + """ + Convenience method to call xarray.plot.FacetGrid from 2d plotting methods + + kwargs are the arguments to 2d plotting method + """ + ax = kwargs.pop('ax', None) + figsize = kwargs.pop('figsize', None) + if ax is not None: + raise ValueError("Can't use axes when making faceted plots.") + if aspect is None: + aspect = 1 + if size is None: + size = 3 + elif figsize is not None: + raise ValueError('cannot provide both `figsize` and `size` arguments') + + g = FacetGrid(data=data, col=col, row=row, col_wrap=col_wrap, + sharex=sharex, sharey=sharey, figsize=figsize, + aspect=aspect, size=size, subplot_kws=subplot_kws) + + if kind == 'line': + return g.map_dataarray_line(plotfunc, x, y, **kwargs) + + if kind == 'dataarray': + return g.map_dataarray(plotfunc, x, y, **kwargs) diff --git a/xarray/plot/plot.py b/xarray/plot/plot.py index 9178dd8f031..5b60f8d73a1 100644 --- a/xarray/plot/plot.py +++ b/xarray/plot/plot.py @@ -6,97 +6,96 @@ DataArray.plot._____ """ import functools -import warnings -from datetime import datetime import numpy as np import pandas as pd from xarray.core.common import contains_cftime_datetimes -from .facetgrid import FacetGrid +from .facetgrid import _easy_facetgrid from .utils import ( - ROBUST_PERCENTILE, _determine_cmap_params, _infer_xy_labels, + _add_colorbar, _ensure_plottable, _infer_interval_breaks, _infer_xy_labels, _interval_to_double_bound_points, _interval_to_mid_points, - _resolve_intervals_2dplot, _valid_other_type, get_axis, - import_matplotlib_pyplot, label_from_attrs) + _process_cmap_cbar_kwargs, _rescale_imshow_rgb, _resolve_intervals_2dplot, + _update_axes, _valid_other_type, get_axis, import_matplotlib_pyplot, + label_from_attrs) -def _valid_numpy_subdtype(x, numpy_types): - """ - Is any dtype from numpy_types superior to the dtype of x? - """ - # If any of the types given in numpy_types is understood as numpy.generic, - # all possible x will be considered valid. This is probably unwanted. - for t in numpy_types: - assert not np.issubdtype(np.generic, t) +def _infer_line_data(darray, x, y, hue): + error_msg = ('must be either None or one of ({0:s})' + .format(', '.join([repr(dd) for dd in darray.dims]))) + ndims = len(darray.dims) - return any(np.issubdtype(x.dtype, t) for t in numpy_types) + if x is not None and x not in darray.dims and x not in darray.coords: + raise ValueError('x ' + error_msg) + if y is not None and y not in darray.dims and y not in darray.coords: + raise ValueError('y ' + error_msg) -def _ensure_plottable(*args): - """ - Raise exception if there is anything in args that can't be plotted on an - axis by matplotlib. - """ - numpy_types = [np.floating, np.integer, np.timedelta64, np.datetime64] - other_types = [datetime] + if x is not None and y is not None: + raise ValueError('You cannot specify both x and y kwargs' + 'for line plots.') - for x in args: - if not (_valid_numpy_subdtype(np.array(x), numpy_types) - or _valid_other_type(np.array(x), other_types)): - raise TypeError('Plotting requires coordinates to be numeric ' - 'or dates of type np.datetime64 or ' - 'datetime.datetime or pd.Interval.') + if ndims == 1: + huename = None + hueplt = None + huelabel = '' + if x is not None: + xplt = darray[x] + yplt = darray -def _easy_facetgrid(darray, plotfunc, x, y, row=None, col=None, - col_wrap=None, sharex=True, sharey=True, aspect=None, - size=None, subplot_kws=None, **kwargs): - """ - Convenience method to call xarray.plot.FacetGrid from 2d plotting methods + elif y is not None: + xplt = darray + yplt = darray[y] - kwargs are the arguments to 2d plotting method - """ - ax = kwargs.pop('ax', None) - figsize = kwargs.pop('figsize', None) - if ax is not None: - raise ValueError("Can't use axes when making faceted plots.") - if aspect is None: - aspect = 1 - if size is None: - size = 3 - elif figsize is not None: - raise ValueError('cannot provide both `figsize` and `size` arguments') - - g = FacetGrid(data=darray, col=col, row=row, col_wrap=col_wrap, - sharex=sharex, sharey=sharey, figsize=figsize, - aspect=aspect, size=size, subplot_kws=subplot_kws) - return g.map_dataarray(plotfunc, x, y, **kwargs) - - -def _line_facetgrid(darray, row=None, col=None, hue=None, - col_wrap=None, sharex=True, sharey=True, aspect=None, - size=None, subplot_kws=None, **kwargs): - """ - Convenience method to call xarray.plot.FacetGrid for line plots - kwargs are the arguments to pyplot.plot() - """ - ax = kwargs.pop('ax', None) - figsize = kwargs.pop('figsize', None) - if ax is not None: - raise ValueError("Can't use axes when making faceted plots.") - if aspect is None: - aspect = 1 - if size is None: - size = 3 - elif figsize is not None: - raise ValueError('cannot provide both `figsize` and `size` arguments') + else: # Both x & y are None + dim = darray.dims[0] + xplt = darray[dim] + yplt = darray + + else: + if x is None and y is None and hue is None: + raise ValueError('For 2D inputs, please' + 'specify either hue, x or y.') + + if y is None: + xname, huename = _infer_xy_labels(darray=darray, x=x, y=hue) + xplt = darray[xname] + if xplt.ndim > 1: + if huename in darray.dims: + otherindex = 1 if darray.dims.index(huename) == 0 else 0 + otherdim = darray.dims[otherindex] + yplt = darray.transpose(otherdim, huename) + xplt = xplt.transpose(otherdim, huename) + else: + raise ValueError('For 2D inputs, hue must be a dimension' + + ' i.e. one of ' + repr(darray.dims)) + + else: + yplt = darray.transpose(xname, huename) + + else: + yname, huename = _infer_xy_labels(darray=darray, x=y, y=hue) + yplt = darray[yname] + if yplt.ndim > 1: + if huename in darray.dims: + otherindex = 1 if darray.dims.index(huename) == 0 else 0 + xplt = darray.transpose(otherdim, huename) + else: + raise ValueError('For 2D inputs, hue must be a dimension' + + ' i.e. one of ' + repr(darray.dims)) - g = FacetGrid(data=darray, col=col, row=row, col_wrap=col_wrap, - sharex=sharex, sharey=sharey, figsize=figsize, - aspect=aspect, size=size, subplot_kws=subplot_kws) - return g.map_dataarray_line(hue=hue, **kwargs) + else: + xplt = darray.transpose(yname, huename) + + huelabel = label_from_attrs(darray[huename]) + hueplt = darray[huename] + + xlabel = label_from_attrs(xplt) + ylabel = label_from_attrs(yplt) + + return xplt, yplt, hueplt, xlabel, ylabel, huelabel def plot(darray, row=None, col=None, col_wrap=None, ax=None, hue=None, @@ -184,83 +183,6 @@ def plot(darray, row=None, col=None, col_wrap=None, ax=None, hue=None, return plotfunc(darray, **kwargs) -def _infer_line_data(darray, x, y, hue): - error_msg = ('must be either None or one of ({0:s})' - .format(', '.join([repr(dd) for dd in darray.dims]))) - ndims = len(darray.dims) - - if x is not None and x not in darray.dims and x not in darray.coords: - raise ValueError('x ' + error_msg) - - if y is not None and y not in darray.dims and y not in darray.coords: - raise ValueError('y ' + error_msg) - - if x is not None and y is not None: - raise ValueError('You cannot specify both x and y kwargs' - 'for line plots.') - - if ndims == 1: - huename = None - hueplt = None - huelabel = '' - - if x is not None: - xplt = darray[x] - yplt = darray - - elif y is not None: - xplt = darray - yplt = darray[y] - - else: # Both x & y are None - dim = darray.dims[0] - xplt = darray[dim] - yplt = darray - - else: - if x is None and y is None and hue is None: - raise ValueError('For 2D inputs, please' - 'specify either hue, x or y.') - - if y is None: - xname, huename = _infer_xy_labels(darray=darray, x=x, y=hue) - xplt = darray[xname] - if xplt.ndim > 1: - if huename in darray.dims: - otherindex = 1 if darray.dims.index(huename) == 0 else 0 - otherdim = darray.dims[otherindex] - yplt = darray.transpose(otherdim, huename) - xplt = xplt.transpose(otherdim, huename) - else: - raise ValueError('For 2D inputs, hue must be a dimension' - + ' i.e. one of ' + repr(darray.dims)) - - else: - yplt = darray.transpose(xname, huename) - - else: - yname, huename = _infer_xy_labels(darray=darray, x=y, y=hue) - yplt = darray[yname] - if yplt.ndim > 1: - if huename in darray.dims: - otherindex = 1 if darray.dims.index(huename) == 0 else 0 - xplt = darray.transpose(otherdim, huename) - else: - raise ValueError('For 2D inputs, hue must be a dimension' - + ' i.e. one of ' + repr(darray.dims)) - - else: - xplt = darray.transpose(yname, huename) - - huelabel = label_from_attrs(darray[huename]) - hueplt = darray[huename] - - xlabel = label_from_attrs(xplt) - ylabel = label_from_attrs(yplt) - - return xplt, yplt, hueplt, xlabel, ylabel, huelabel - - # This function signature should not change so that it can use # matplotlib format strings def line(darray, *args, **kwargs): @@ -316,7 +238,8 @@ def line(darray, *args, **kwargs): if row or col: allargs = locals().copy() allargs.update(allargs.pop('kwargs')) - return _line_facetgrid(**allargs) + allargs.pop('darray') + return _easy_facetgrid(darray, line, kind='line', **allargs) ndims = len(darray.dims) if ndims > 2: @@ -496,48 +419,6 @@ def hist(darray, figsize=None, size=None, aspect=None, ax=None, **kwargs): return primitive -def _update_axes(ax, xincrease, yincrease, - xscale=None, yscale=None, - xticks=None, yticks=None, - xlim=None, ylim=None): - """ - Update axes with provided parameters - """ - if xincrease is None: - pass - elif xincrease and ax.xaxis_inverted(): - ax.invert_xaxis() - elif not xincrease and not ax.xaxis_inverted(): - ax.invert_xaxis() - - if yincrease is None: - pass - elif yincrease and ax.yaxis_inverted(): - ax.invert_yaxis() - elif not yincrease and not ax.yaxis_inverted(): - ax.invert_yaxis() - - # The default xscale, yscale needs to be None. - # If we set a scale it resets the axes formatters, - # This means that set_xscale('linear') on a datetime axis - # will remove the date labels. So only set the scale when explicitly - # asked to. https://github.com/matplotlib/matplotlib/issues/8740 - if xscale is not None: - ax.set_xscale(xscale) - if yscale is not None: - ax.set_yscale(yscale) - - if xticks is not None: - ax.set_xticks(xticks) - if yticks is not None: - ax.set_yticks(yticks) - - if xlim is not None: - ax.set_xlim(xlim) - if ylim is not None: - ax.set_ylim(ylim) - - # MUST run before any 2d plotting functions are defined since # _plot2d decorator adds them as methods here. class _PlotMethods(object): @@ -565,44 +446,6 @@ def step(self, *args, **kwargs): return step(self._da, *args, **kwargs) -def _rescale_imshow_rgb(darray, vmin, vmax, robust): - assert robust or vmin is not None or vmax is not None - # TODO: remove when min numpy version is bumped to 1.13 - # There's a cyclic dependency via DataArray, so we can't import from - # xarray.ufuncs in global scope. - from xarray.ufuncs import maximum, minimum - - # Calculate vmin and vmax automatically for `robust=True` - if robust: - if vmax is None: - vmax = np.nanpercentile(darray, 100 - ROBUST_PERCENTILE) - if vmin is None: - vmin = np.nanpercentile(darray, ROBUST_PERCENTILE) - # If not robust and one bound is None, calculate the default other bound - # and check that an interval between them exists. - elif vmax is None: - vmax = 255 if np.issubdtype(darray.dtype, np.integer) else 1 - if vmax < vmin: - raise ValueError( - 'vmin=%r is less than the default vmax (%r) - you must supply ' - 'a vmax > vmin in this case.' % (vmin, vmax)) - elif vmin is None: - vmin = 0 - if vmin > vmax: - raise ValueError( - 'vmax=%r is less than the default vmin (0) - you must supply ' - 'a vmin < vmax in this case.' % vmax) - # Scale interval [vmin .. vmax] to [0 .. 1], with darray as 64-bit float - # to avoid precision loss, integer over/underflow, etc with extreme inputs. - # After scaling, downcast to 32-bit float. This substantially reduces - # memory usage after we hand `darray` off to matplotlib. - darray = ((darray.astype('f8') - vmin) / (vmax - vmin)).astype('f4') - with warnings.catch_warnings(): - warnings.filterwarnings('ignore', 'xarray.ufuncs', - PendingDeprecationWarning) - return minimum(maximum(darray, 0), 1) - - def _plot2d(plotfunc): """ Decorator for common 2d plotting logic @@ -745,38 +588,23 @@ def newplotfunc(darray, x=None, y=None, figsize=None, size=None, allargs = locals().copy() allargs.pop('imshow_rgb') allargs.update(allargs.pop('kwargs')) - + allargs.pop('darray') # Need the decorated plotting function allargs['plotfunc'] = globals()[plotfunc.__name__] - - return _easy_facetgrid(**allargs) + return _easy_facetgrid(darray, kind='dataarray', **allargs) plt = import_matplotlib_pyplot() - # colors is mutually exclusive with cmap - if cmap and colors: - raise ValueError("Can't specify both cmap and colors.") - # colors is only valid when levels is supplied or the plot is of type - # contour or contourf - if colors and (('contour' not in plotfunc.__name__) and (not levels)): - raise ValueError("Can only specify colors with contour or levels") - # we should not be getting a list of colors in cmap anymore - # is there a better way to do this test? - if isinstance(cmap, (list, tuple)): - warnings.warn("Specifying a list of colors in cmap is deprecated. " - "Use colors keyword instead.", - DeprecationWarning, stacklevel=3) - rgb = kwargs.pop('rgb', None) - xlab, ylab = _infer_xy_labels( - darray=darray, x=x, y=y, imshow=imshow_rgb, rgb=rgb) - if rgb is not None and plotfunc.__name__ != 'imshow': raise ValueError('The "rgb" keyword is only valid for imshow()') elif rgb is not None and not imshow_rgb: raise ValueError('The "rgb" keyword is only valid for imshow()' 'with a three-dimensional array (per facet)') + xlab, ylab = _infer_xy_labels( + darray=darray, x=x, y=y, imshow=imshow_rgb, rgb=rgb) + # better to pass the ndarrays directly to plotting functions xval = darray[xlab].values yval = darray[ylab].values @@ -810,22 +638,8 @@ def newplotfunc(darray, x=None, y=None, figsize=None, size=None, _ensure_plottable(xplt, yplt) - if 'contour' in plotfunc.__name__ and levels is None: - levels = 7 # this is the matplotlib default - - cmap_kwargs = {'plot_data': zval.data, - 'vmin': vmin, - 'vmax': vmax, - 'cmap': colors if colors else cmap, - 'center': center, - 'robust': robust, - 'extend': extend, - 'levels': levels, - 'filled': plotfunc.__name__ != 'contour', - 'norm': norm, - } - - cmap_params = _determine_cmap_params(**cmap_kwargs) + cmap_params, cbar_kwargs = _process_cmap_cbar_kwargs( + plotfunc, locals(), zval.data) if 'contour' in plotfunc.__name__: # extend is a keyword argument only for contour and contourf, but @@ -861,16 +675,12 @@ def newplotfunc(darray, x=None, y=None, figsize=None, size=None, ax.set_title(darray._title_for_slice()) if add_colorbar: - cbar_kwargs = {} if cbar_kwargs is None else dict(cbar_kwargs) - cbar_kwargs.setdefault('extend', cmap_params['extend']) - if cbar_ax is None: - cbar_kwargs.setdefault('ax', ax) - else: - cbar_kwargs.setdefault('cax', cbar_ax) - cbar = plt.colorbar(primitive, **cbar_kwargs) if add_labels and 'label' not in cbar_kwargs: - cbar.set_label(label_from_attrs(darray)) - elif cbar_ax is not None or cbar_kwargs is not None: + cbar_kwargs['label'] = label_from_attrs(darray) + cbar = _add_colorbar(primitive, ax, cbar_ax, cbar_kwargs, + cmap_params) + + elif (cbar_ax is not None or cbar_kwargs): # inform the user about keywords which aren't used raise ValueError("cbar_ax and cbar_kwargs can't be used with " "add_colorbar=False.") @@ -1020,54 +830,6 @@ def contourf(x, y, z, ax, **kwargs): return primitive -def _is_monotonic(coord, axis=0): - """ - >>> _is_monotonic(np.array([0, 1, 2])) - True - >>> _is_monotonic(np.array([2, 1, 0])) - True - >>> _is_monotonic(np.array([0, 2, 1])) - False - """ - if coord.shape[axis] < 3: - return True - else: - n = coord.shape[axis] - delta_pos = (coord.take(np.arange(1, n), axis=axis) >= - coord.take(np.arange(0, n - 1), axis=axis)) - delta_neg = (coord.take(np.arange(1, n), axis=axis) <= - coord.take(np.arange(0, n - 1), axis=axis)) - return np.all(delta_pos) or np.all(delta_neg) - - -def _infer_interval_breaks(coord, axis=0, check_monotonic=False): - """ - >>> _infer_interval_breaks(np.arange(5)) - array([-0.5, 0.5, 1.5, 2.5, 3.5, 4.5]) - >>> _infer_interval_breaks([[0, 1], [3, 4]], axis=1) - array([[-0.5, 0.5, 1.5], - [ 2.5, 3.5, 4.5]]) - """ - coord = np.asarray(coord) - - if check_monotonic and not _is_monotonic(coord, axis=axis): - raise ValueError("The input coordinate is not sorted in increasing " - "order along axis %d. This can lead to unexpected " - "results. Consider calling the `sortby` method on " - "the input DataArray. To plot data with categorical " - "axes, consider using the `heatmap` function from " - "the `seaborn` statistical plotting library." % axis) - - deltas = 0.5 * np.diff(coord, axis=axis) - if deltas.size == 0: - deltas = np.array(0.0) - first = np.take(coord, [0], axis=axis) - np.take(deltas, [0], axis=axis) - last = np.take(coord, [-1], axis=axis) + np.take(deltas, [-1], axis=axis) - trim_last = tuple(slice(None, -1) if n == axis else slice(None) - for n in range(coord.ndim)) - return np.concatenate([first, coord[trim_last] + deltas, last], axis=axis) - - @_plot2d def pcolormesh(x, y, z, ax, infer_intervals=None, **kwargs): """ diff --git a/xarray/plot/utils.py b/xarray/plot/utils.py index a42fbc7aba6..6d812fbc2bc 100644 --- a/xarray/plot/utils.py +++ b/xarray/plot/utils.py @@ -1,10 +1,13 @@ import itertools import textwrap import warnings +from datetime import datetime import numpy as np import pandas as pd +from inspect import getfullargspec + from ..core.options import OPTIONS from ..core.utils import is_scalar @@ -447,3 +450,232 @@ def _valid_other_type(x, types): Do all elements of x have a type from types? """ return all(any(isinstance(el, t) for t in types) for el in np.ravel(x)) + + +def _valid_numpy_subdtype(x, numpy_types): + """ + Is any dtype from numpy_types superior to the dtype of x? + """ + # If any of the types given in numpy_types is understood as numpy.generic, + # all possible x will be considered valid. This is probably unwanted. + for t in numpy_types: + assert not np.issubdtype(np.generic, t) + + return any(np.issubdtype(x.dtype, t) for t in numpy_types) + + +def _ensure_plottable(*args): + """ + Raise exception if there is anything in args that can't be plotted on an + axis by matplotlib. + """ + numpy_types = [np.floating, np.integer, np.timedelta64, np.datetime64] + other_types = [datetime] + + for x in args: + if not (_valid_numpy_subdtype(np.array(x), numpy_types) + or _valid_other_type(np.array(x), other_types)): + raise TypeError('Plotting requires coordinates to be numeric ' + 'or dates of type np.datetime64 or ' + 'datetime.datetime or pd.Interval.') + + +def _ensure_numeric(arr): + numpy_types = [np.floating, np.integer] + return _valid_numpy_subdtype(arr, numpy_types) + + +def _add_colorbar(primitive, ax, cbar_ax, cbar_kwargs, cmap_params): + plt = import_matplotlib_pyplot() + cbar_kwargs.setdefault('extend', cmap_params['extend']) + if cbar_ax is None: + cbar_kwargs.setdefault('ax', ax) + else: + cbar_kwargs.setdefault('cax', cbar_ax) + + cbar = plt.colorbar(primitive, **cbar_kwargs) + + return cbar + + +def _rescale_imshow_rgb(darray, vmin, vmax, robust): + assert robust or vmin is not None or vmax is not None + # TODO: remove when min numpy version is bumped to 1.13 + # There's a cyclic dependency via DataArray, so we can't import from + # xarray.ufuncs in global scope. + from xarray.ufuncs import maximum, minimum + + # Calculate vmin and vmax automatically for `robust=True` + if robust: + if vmax is None: + vmax = np.nanpercentile(darray, 100 - ROBUST_PERCENTILE) + if vmin is None: + vmin = np.nanpercentile(darray, ROBUST_PERCENTILE) + # If not robust and one bound is None, calculate the default other bound + # and check that an interval between them exists. + elif vmax is None: + vmax = 255 if np.issubdtype(darray.dtype, np.integer) else 1 + if vmax < vmin: + raise ValueError( + 'vmin=%r is less than the default vmax (%r) - you must supply ' + 'a vmax > vmin in this case.' % (vmin, vmax)) + elif vmin is None: + vmin = 0 + if vmin > vmax: + raise ValueError( + 'vmax=%r is less than the default vmin (0) - you must supply ' + 'a vmin < vmax in this case.' % vmax) + # Scale interval [vmin .. vmax] to [0 .. 1], with darray as 64-bit float + # to avoid precision loss, integer over/underflow, etc with extreme inputs. + # After scaling, downcast to 32-bit float. This substantially reduces + # memory usage after we hand `darray` off to matplotlib. + darray = ((darray.astype('f8') - vmin) / (vmax - vmin)).astype('f4') + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'xarray.ufuncs', + PendingDeprecationWarning) + return minimum(maximum(darray, 0), 1) + + +def _update_axes(ax, xincrease, yincrease, + xscale=None, yscale=None, + xticks=None, yticks=None, + xlim=None, ylim=None): + """ + Update axes with provided parameters + """ + if xincrease is None: + pass + elif xincrease and ax.xaxis_inverted(): + ax.invert_xaxis() + elif not xincrease and not ax.xaxis_inverted(): + ax.invert_xaxis() + + if yincrease is None: + pass + elif yincrease and ax.yaxis_inverted(): + ax.invert_yaxis() + elif not yincrease and not ax.yaxis_inverted(): + ax.invert_yaxis() + + # The default xscale, yscale needs to be None. + # If we set a scale it resets the axes formatters, + # This means that set_xscale('linear') on a datetime axis + # will remove the date labels. So only set the scale when explicitly + # asked to. https://github.com/matplotlib/matplotlib/issues/8740 + if xscale is not None: + ax.set_xscale(xscale) + if yscale is not None: + ax.set_yscale(yscale) + + if xticks is not None: + ax.set_xticks(xticks) + if yticks is not None: + ax.set_yticks(yticks) + + if xlim is not None: + ax.set_xlim(xlim) + if ylim is not None: + ax.set_ylim(ylim) + + +def _is_monotonic(coord, axis=0): + """ + >>> _is_monotonic(np.array([0, 1, 2])) + True + >>> _is_monotonic(np.array([2, 1, 0])) + True + >>> _is_monotonic(np.array([0, 2, 1])) + False + """ + if coord.shape[axis] < 3: + return True + else: + n = coord.shape[axis] + delta_pos = (coord.take(np.arange(1, n), axis=axis) >= + coord.take(np.arange(0, n - 1), axis=axis)) + delta_neg = (coord.take(np.arange(1, n), axis=axis) <= + coord.take(np.arange(0, n - 1), axis=axis)) + return np.all(delta_pos) or np.all(delta_neg) + + +def _infer_interval_breaks(coord, axis=0, check_monotonic=False): + """ + >>> _infer_interval_breaks(np.arange(5)) + array([-0.5, 0.5, 1.5, 2.5, 3.5, 4.5]) + >>> _infer_interval_breaks([[0, 1], [3, 4]], axis=1) + array([[-0.5, 0.5, 1.5], + [ 2.5, 3.5, 4.5]]) + """ + coord = np.asarray(coord) + + if check_monotonic and not _is_monotonic(coord, axis=axis): + raise ValueError("The input coordinate is not sorted in increasing " + "order along axis %d. This can lead to unexpected " + "results. Consider calling the `sortby` method on " + "the input DataArray. To plot data with categorical " + "axes, consider using the `heatmap` function from " + "the `seaborn` statistical plotting library." % axis) + + deltas = 0.5 * np.diff(coord, axis=axis) + if deltas.size == 0: + deltas = np.array(0.0) + first = np.take(coord, [0], axis=axis) - np.take(deltas, [0], axis=axis) + last = np.take(coord, [-1], axis=axis) + np.take(deltas, [-1], axis=axis) + trim_last = tuple(slice(None, -1) if n == axis else slice(None) + for n in range(coord.ndim)) + return np.concatenate([first, coord[trim_last] + deltas, last], axis=axis) + + +def _process_cmap_cbar_kwargs(func, kwargs, data): + """ + Parameters + ========== + func : plotting function + kwargs : dict, + Dictionary with arguments that need to be parsed + data : ndarray, + Data values + + Returns + ======= + cmap_params + + cbar_kwargs + """ + + cmap = kwargs.pop('cmap', None) + colors = kwargs.pop('colors', None) + + cbar_kwargs = kwargs.pop('cbar_kwargs', {}) + cbar_kwargs = {} if cbar_kwargs is None else dict(cbar_kwargs) + + levels = kwargs.pop('levels', None) + if 'contour' in func.__name__ and levels is None: + levels = 7 # this is the matplotlib default + + # colors is mutually exclusive with cmap + if cmap and colors: + raise ValueError("Can't specify both cmap and colors.") + + # colors is only valid when levels is supplied or the plot is of type + # contour or contourf + if colors and (('contour' not in func.__name__) and (not levels)): + raise ValueError("Can only specify colors with contour or levels") + + # we should not be getting a list of colors in cmap anymore + # is there a better way to do this test? + if isinstance(cmap, (list, tuple)): + warnings.warn("Specifying a list of colors in cmap is deprecated. " + "Use colors keyword instead.", + DeprecationWarning, stacklevel=3) + + cmap_kwargs = {'plot_data': data, + 'levels': levels, + 'cmap': colors if colors else cmap, + 'filled': func.__name__ != 'contour'} + + cmap_args = getfullargspec(_determine_cmap_params).args + cmap_kwargs.update((a, kwargs[a]) for a in cmap_args if a in kwargs) + cmap_params = _determine_cmap_params(**cmap_kwargs) + + return cmap_params, cbar_kwargs From 5527f693fc0a39cd04db7aa6b4fd95edbe722921 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Wed, 30 Jan 2019 14:06:33 -0500 Subject: [PATCH 078/108] silence a couple of warnings (#2727) --- xarray/tests/test_ufuncs.py | 1 + 1 file changed, 1 insertion(+) diff --git a/xarray/tests/test_ufuncs.py b/xarray/tests/test_ufuncs.py index fab828588c6..2f6ca37bd2a 100644 --- a/xarray/tests/test_ufuncs.py +++ b/xarray/tests/test_ufuncs.py @@ -206,6 +206,7 @@ def test_numpy_ufuncs(name, request): assert isinstance(y, xr.DataArray) +@pytest.mark.filterwarnings("ignore:xarray.ufuncs") def test_xarray_ufuncs_pickle(): a = 1.0 cos_pickled = pickle.loads(pickle.dumps(xu.cos)) From ce3ef3a56a7ff5e527b2aad7a3b3635d75d9c514 Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Thu, 31 Jan 2019 09:26:53 -0800 Subject: [PATCH 079/108] improve error message for invalid encoding (#2730) --- xarray/backends/netCDF4_.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/xarray/backends/netCDF4_.py b/xarray/backends/netCDF4_.py index 92e990f76d5..b26d5575d23 100644 --- a/xarray/backends/netCDF4_.py +++ b/xarray/backends/netCDF4_.py @@ -217,8 +217,9 @@ def _extract_nc4_variable_encoding(variable, raise_on_invalid=False, if raise_on_invalid: invalid = [k for k in encoding if k not in valid_encodings] if invalid: - raise ValueError('unexpected encoding parameters for %r backend: ' - ' %r' % (backend, invalid)) + raise ValueError( + 'unexpected encoding parameters for %r backend: %r. Valid ' + 'encodings are: %r' % (backend, invalid, valid_encodings)) else: for k in list(encoding): if k not in valid_encodings: From 3cc0d2214d699accb5cd904f775b442083b7bfd8 Mon Sep 17 00:00:00 2001 From: observingClouds <43613877+observingClouds@users.noreply.github.com> Date: Thu, 31 Jan 2019 18:28:09 +0100 Subject: [PATCH 080/108] ENH: resample methods with tolerance (#2716) * ENH: resample methods with tolerance * ENH: resample methods bfill, pad, nearest accept tolerance keyword * DOC: documentation is updated with examples Fixes: GH2695 * TST: Upsampling with tolerance keyword Include tests for GH2695 * pep8 * Make resample().nearest(tolerance) test meaningful * DOC: Mention units of tolerance --- doc/time-series.rst | 15 +++++++++--- doc/whats-new.rst | 3 +++ xarray/core/common.py | 7 ++++++ xarray/core/resample.py | 42 +++++++++++++++++++++++++++++----- xarray/tests/test_dataarray.py | 24 +++++++++++++++++++ 5 files changed, 82 insertions(+), 9 deletions(-) diff --git a/doc/time-series.rst b/doc/time-series.rst index 32c6b581aa4..47742360f62 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -196,11 +196,20 @@ resampling group: ds.resample(time='6H').reduce(np.mean) -For upsampling, xarray provides four methods: ``asfreq``, ``ffill``, ``bfill``, -and ``interpolate``. ``interpolate`` extends ``scipy.interpolate.interp1d`` and -supports all of its schemes. All of these resampling operations work on both +For upsampling, xarray provides six methods: ``asfreq``, ``ffill``, ``bfill``, ``pad``, +``nearest`` and ``interpolate``. ``interpolate`` extends ``scipy.interpolate.interp1d`` +and supports all of its schemes. All of these resampling operations work on both Dataset and DataArray objects with an arbitrary number of dimensions. +In order to limit the scope of the methods ``ffill``, ``bfill``, ``pad`` and +``nearest`` the ``tolerance`` argument can be set in coordinate units. +Data that has indices outside of the given ``tolerance`` are set to ``NaN``. + +.. ipython:: python + + ds.resample(time='1H').nearest(tolerance='1H') + + For more examples of using grouped operations on a time dimension, see :ref:`toy weather data`. diff --git a/doc/whats-new.rst b/doc/whats-new.rst index f6fdcef9306..c35a419f2fa 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -43,6 +43,9 @@ Enhancements report showing what exactly differs between the two objects (dimensions / coordinates / variables / attributes) (:issue:`1507`). By `Benoit Bovy `_. +- Add ``tolerance`` option to ``resample()`` methods ``bfill``, ``pad``, + ``nearest``. (:issue:`2695`) + By `Hauke Schulz `_. Bug fixes ~~~~~~~~~ diff --git a/xarray/core/common.py b/xarray/core/common.py index f50b5bfedf4..ff0c7034d70 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -713,6 +713,13 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, array([ 0. , 0.032258, 0.064516, ..., 10.935484, 10.967742, 11. ]) Coordinates: * time (time) datetime64[ns] 1999-12-15 1999-12-16 1999-12-17 ... + + Limit scope of upsampling method + >>> da.resample(time='1D').nearest(tolerance='1D') + + array([ 0., 0., nan, ..., nan, 11., 11.]) + Coordinates: + * time (time) datetime64[ns] 1999-12-15 1999-12-16 ... 2000-11-15 References ---------- diff --git a/xarray/core/resample.py b/xarray/core/resample.py index 3c39d2299e4..40298f14d08 100644 --- a/xarray/core/resample.py +++ b/xarray/core/resample.py @@ -71,23 +71,53 @@ def asfreq(self): """ return self._upsample('asfreq') - def pad(self): + def pad(self, tolerance=None): """Forward fill new values at up-sampled frequency. + + Parameters + ---------- + tolerance : optional + Maximum distance between original and new labels to limit + the up-sampling method. + Up-sampled data with indices that satisfy the equation + ``abs(index[indexer] - target) <= tolerance`` are filled by + new values. Data with indices that are outside the given + tolerance are filled with ``NaN`` s """ - return self._upsample('pad') + return self._upsample('pad', tolerance=tolerance) ffill = pad - def backfill(self): + def backfill(self, tolerance=None): """Backward fill new values at up-sampled frequency. + + Parameters + ---------- + tolerance : optional + Maximum distance between original and new labels to limit + the up-sampling method. + Up-sampled data with indices that satisfy the equation + ``abs(index[indexer] - target) <= tolerance`` are filled by + new values. Data with indices that are outside the given + tolerance are filled with ``NaN`` s """ - return self._upsample('backfill') + return self._upsample('backfill', tolerance=tolerance) bfill = backfill - def nearest(self): + def nearest(self, tolerance=None): """Take new values from nearest original coordinate to up-sampled frequency coordinates. + + Parameters + ---------- + tolerance : optional + Maximum distance between original and new labels to limit + the up-sampling method. + Up-sampled data with indices that satisfy the equation + ``abs(index[indexer] - target) <= tolerance`` are filled by + new values. Data with indices that are outside the given + tolerance are filled with ``NaN`` s """ - return self._upsample('nearest') + return self._upsample('nearest', tolerance=tolerance) def interpolate(self, kind='linear'): """Interpolate up-sampled data using the original data diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 59d14d7cdac..f596ac71a6e 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2485,6 +2485,30 @@ def test_upsample_nd(self): ('x', 'y', 'time')) assert_identical(expected, actual) + def test_upsample_tolerance(self): + # Test tolerance keyword for upsample methods bfill, pad, nearest + times = pd.date_range('2000-01-01', freq='1D', periods=2) + times_upsampled = pd.date_range('2000-01-01', freq='6H', periods=5) + array = DataArray(np.arange(2), [('time', times)]) + + # Forward fill + actual = array.resample(time='6H').ffill(tolerance='12H') + expected = DataArray([0., 0., 0., np.nan, 1.], + [('time', times_upsampled)]) + assert_identical(expected, actual) + + # Backward fill + actual = array.resample(time='6H').bfill(tolerance='12H') + expected = DataArray([0., np.nan, 1., 1., 1.], + [('time', times_upsampled)]) + assert_identical(expected, actual) + + # Nearest + actual = array.resample(time='6H').nearest(tolerance='6H') + expected = DataArray([0, 0, np.nan, 1, 1], + [('time', times_upsampled)]) + assert_identical(expected, actual) + @requires_scipy def test_upsample_interpolate(self): from scipy.interpolate import interp1d From 492303924f4573173029aa9cf5a785413ee9d2ed Mon Sep 17 00:00:00 2001 From: Keisuke Fujii Date: Fri, 1 Feb 2019 02:30:30 +0900 Subject: [PATCH 081/108] Implement integrate (#2653) * added integrate. * Docs * Update via comment * Update via comments * integrate can accept multiple dimensions. * using set instead of list * dim -> coord --- doc/api.rst | 2 + doc/computation.rst | 14 ++++++- doc/whats-new.rst | 8 ++++ xarray/core/dataarray.py | 47 +++++++++++++++++++++ xarray/core/dataset.py | 72 +++++++++++++++++++++++++++++++ xarray/core/duck_array_ops.py | 12 ++++++ xarray/tests/test_dataset.py | 79 +++++++++++++++++++++++++++++++++++ 7 files changed, 232 insertions(+), 2 deletions(-) diff --git a/doc/api.rst b/doc/api.rst index e1f70cfbdea..552582a553f 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -152,6 +152,7 @@ Computation Dataset.diff Dataset.quantile Dataset.differentiate + Dataset.integrate **Aggregation**: :py:attr:`~Dataset.all` @@ -321,6 +322,7 @@ Computation DataArray.dot DataArray.quantile DataArray.differentiate + DataArray.integrate **Aggregation**: :py:attr:`~DataArray.all` diff --git a/doc/computation.rst b/doc/computation.rst index 412f24eee6a..2d41479f67f 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -240,6 +240,8 @@ function or method name to ``coord_func`` option, da.coarsen(time=7, x=2, coord_func={'time': 'min'}).mean() +.. _compute.using_coordinates: + Computation using Coordinates ============================= @@ -261,9 +263,17 @@ This method can be used also for multidimensional arrays, coords={'x': [0.1, 0.11, 0.2, 0.3]}) a.differentiate('x') +:py:meth:`~xarray.DataArray.integrate` computes integration based on +trapezoidal rule using their coordinates, + +.. ipython:: python + + a.integrate('x') + .. note:: - This method is limited to simple cartesian geometry. Differentiation along - multidimensional coordinate is not supported. + These methods are limited to simple cartesian geometry. Differentiation + and integration along multidimensional coordinate are not supported. + .. _compute.broadcasting: diff --git a/doc/whats-new.rst b/doc/whats-new.rst index c35a419f2fa..b7ca384ff09 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -47,6 +47,13 @@ Enhancements ``nearest``. (:issue:`2695`) By `Hauke Schulz `_. +- :py:meth:`~xarray.DataArray.integrate` and + :py:meth:`~xarray.Dataset.integrate` are newly added. + See :ref:`_compute.using_coordinates` for the detail. + (:issue:`1332`) + By `Keisuke Fujii `_. + + Bug fixes ~~~~~~~~~ @@ -115,6 +122,7 @@ Breaking changes (:issue:`2565`). The previous behavior was to decode them only if they had specific time attributes, now these attributes are copied automatically from the corresponding time coordinate. This might + break downstream code that was relying on these variables to be brake downstream code that was relying on these variables to be not decoded. By `Fabien Maussion `_. diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 3c8344f4514..cf5227b0a1f 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -2425,6 +2425,53 @@ def differentiate(self, coord, edge_order=1, datetime_unit=None): coord, edge_order, datetime_unit) return self._from_temp_dataset(ds) + def integrate(self, dim, datetime_unit=None): + """ integrate the array with the trapezoidal rule. + + .. note:: + This feature is limited to simple cartesian geometry, i.e. coord + must be one dimensional. + + Parameters + ---------- + dim: str, or a sequence of str + Coordinate(s) used for the integration. + datetime_unit + Can be specify the unit if datetime coordinate is used. One of + {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', + 'as'} + + Returns + ------- + integrated: DataArray + + See also + -------- + numpy.trapz: corresponding numpy function + + Examples + -------- + + >>> da = xr.DataArray(np.arange(12).reshape(4, 3), dims=['x', 'y'], + ... coords={'x': [0, 0.1, 1.1, 1.2]}) + >>> da + + array([[ 0, 1, 2], + [ 3, 4, 5], + [ 6, 7, 8], + [ 9, 10, 11]]) + Coordinates: + * x (x) float64 0.0 0.1 1.1 1.2 + Dimensions without coordinates: y + >>> + >>> da.integrate('x') + + array([5.4, 6.6, 7.8]) + Dimensions without coordinates: y + """ + ds = self._to_temp_dataset().integrate(dim, datetime_unit) + return self._from_temp_dataset(ds) + # priority most be higher than Variable to properly work with binary ufuncs ops.inject_all_ops_and_reduce_methods(DataArray, priority=60) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 0d1b9ebd55b..3c30dff1507 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -3869,6 +3869,78 @@ def differentiate(self, coord, edge_order=1, datetime_unit=None): variables[k] = v return self._replace_vars_and_dims(variables) + def integrate(self, coord, datetime_unit=None): + """ integrate the array with the trapezoidal rule. + + .. note:: + This feature is limited to simple cartesian geometry, i.e. coord + must be one dimensional. + + Parameters + ---------- + dim: str, or a sequence of str + Coordinate(s) used for the integration. + datetime_unit + Can be specify the unit if datetime coordinate is used. One of + {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', + 'as'} + + Returns + ------- + integrated: Dataset + + See also + -------- + DataArray.integrate + numpy.trapz: corresponding numpy function + """ + if not isinstance(coord, (list, tuple)): + coord = (coord, ) + result = self + for c in coord: + result = result._integrate_one(c, datetime_unit=datetime_unit) + return result + + def _integrate_one(self, coord, datetime_unit=None): + from .variable import Variable + + if coord not in self.variables and coord not in self.dims: + raise ValueError('Coordinate {} does not exist.'.format(dim)) + + coord_var = self[coord].variable + if coord_var.ndim != 1: + raise ValueError('Coordinate {} must be 1 dimensional but is {}' + ' dimensional'.format(coord, coord_var.ndim)) + + dim = coord_var.dims[0] + if _contains_datetime_like_objects(coord_var): + if coord_var.dtype.kind in 'mM' and datetime_unit is None: + datetime_unit, _ = np.datetime_data(coord_var.dtype) + elif datetime_unit is None: + datetime_unit = 's' # Default to seconds for cftime objects + coord_var = datetime_to_numeric( + coord_var, datetime_unit=datetime_unit) + + variables = OrderedDict() + coord_names = set() + for k, v in self.variables.items(): + if k in self.coords: + if dim not in v.dims: + variables[k] = v + coord_names.add(k) + else: + if k in self.data_vars and dim in v.dims: + if _contains_datetime_like_objects(v): + v = datetime_to_numeric(v, datetime_unit=datetime_unit) + integ = duck_array_ops.trapz( + v.data, coord_var.data, axis=v.get_axis_num(dim)) + v_dims = list(v.dims) + v_dims.remove(dim) + variables[k] = Variable(v_dims, integ) + else: + variables[k] = v + return self._replace_vars_and_dims(variables, coord_names=coord_names) + @property def real(self): return self._unary_op(lambda x: x.real, diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index eb1e928b58e..330bdc19cfc 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -99,6 +99,18 @@ def gradient(x, coord, axis, edge_order): return npcompat.gradient(x, coord, axis=axis, edge_order=edge_order) +def trapz(y, x, axis): + if axis < 0: + axis = y.ndim + axis + x_sl1 = (slice(1, None), ) + (None, ) * (y.ndim - axis - 1) + x_sl2 = (slice(None, -1), ) + (None, ) * (y.ndim - axis - 1) + slice1 = (slice(None),) * axis + (slice(1, None), ) + slice2 = (slice(None),) * axis + (slice(None, -1), ) + dx = (x[x_sl1] - x[x_sl2]) + integrand = dx * 0.5 * (y[tuple(slice1)] + y[tuple(slice2)]) + return sum(integrand, axis=axis, skipna=False) + + masked_invalid = _dask_or_eager_func( 'masked_invalid', eager_module=np.ma, dask_module=getattr(dask_array, 'ma', None)) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 23a77b54356..f4b709272d0 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -4716,3 +4716,82 @@ def test_differentiate_cftime(dask): # Test the differentiation of datetimes themselves actual = da['time'].differentiate('time', edge_order=1, datetime_unit='D') assert_allclose(actual, xr.ones_like(da['time']).astype(float)) + + +@pytest.mark.parametrize('dask', [True, False]) +def test_integrate(dask): + rs = np.random.RandomState(42) + coord = [0.2, 0.35, 0.4, 0.6, 0.7, 0.75, 0.76, 0.8] + + da = xr.DataArray(rs.randn(8, 6), dims=['x', 'y'], + coords={'x': coord, 'x2': (('x', ), rs.randn(8)), + 'z': 3, 'x2d': (('x', 'y'), rs.randn(8, 6))}) + if dask and has_dask: + da = da.chunk({'x': 4}) + + ds = xr.Dataset({'var': da}) + + # along x + actual = da.integrate('x') + # coordinate that contains x should be dropped. + expected_x = xr.DataArray( + np.trapz(da, da['x'], axis=0), dims=['y'], + coords={k: v for k, v in da.coords.items() if 'x' not in v.dims}) + assert_allclose(expected_x, actual.compute()) + assert_equal(ds['var'].integrate('x'), ds.integrate('x')['var']) + + # make sure result is also a dask array (if the source is dask array) + assert isinstance(actual.data, type(da.data)) + + # along y + actual = da.integrate('y') + expected_y = xr.DataArray( + np.trapz(da, da['y'], axis=1), dims=['x'], + coords={k: v for k, v in da.coords.items() if 'y' not in v.dims}) + assert_allclose(expected_y, actual.compute()) + assert_equal(actual, ds.integrate('y')['var']) + assert_equal(ds['var'].integrate('y'), ds.integrate('y')['var']) + + # along x and y + actual = da.integrate(('y', 'x')) + assert actual.ndim == 0 + + with pytest.raises(ValueError): + da.integrate('x2d') + + +@pytest.mark.parametrize('dask', [True, False]) +@pytest.mark.parametrize('which_datetime', ['np', 'cftime']) +def test_trapz_datetime(dask, which_datetime): + rs = np.random.RandomState(42) + if which_datetime == 'np': + coord = np.array( + ['2004-07-13', '2006-01-13', '2010-08-13', '2010-09-13', + '2010-10-11', '2010-12-13', '2011-02-13', '2012-08-13'], + dtype='datetime64') + else: + if not has_cftime: + pytest.skip('Test requires cftime.') + coord = xr.cftime_range('2000', periods=8, freq='2D') + + da = xr.DataArray( + rs.randn(8, 6), + coords={'time': coord, 'z': 3, 't2d': (('time', 'y'), rs.randn(8, 6))}, + dims=['time', 'y']) + + if dask and has_dask: + da = da.chunk({'time': 4}) + + actual = da.integrate('time', datetime_unit='D') + expected_data = np.trapz( + da, utils.datetime_to_numeric(da['time'], datetime_unit='D'), axis=0) + expected = xr.DataArray( + expected_data, dims=['y'], + coords={k: v for k, v in da.coords.items() if 'time' not in v.dims}) + assert_allclose(expected, actual.compute()) + + # make sure result is also a dask array (if the source is dask array) + assert isinstance(actual.data, type(da.data)) + + actual2 = da.integrate('time', datetime_unit='h') + assert_allclose(actual, actual2 / 24.0) From d634f64c818d84dfc6fcc0f7fef81e4bb2094540 Mon Sep 17 00:00:00 2001 From: Maximilian Roos <5635139+max-sixty@users.noreply.github.com> Date: Thu, 31 Jan 2019 22:16:09 -0500 Subject: [PATCH 082/108] deprecate compat & encoding (#2703) * deprecate compat & encoding * stacklevel * whatsnew * imports * merge conflicts * remove deprecations * removal date --- .github/stale.yml | 3 ++- doc/whats-new.rst | 4 ++++ xarray/core/alignment.py | 2 +- xarray/core/dataarray.py | 25 +++++++++++++------------ xarray/core/dataset.py | 33 +++++++++++++++++---------------- xarray/tests/test_dataarray.py | 4 ++-- xarray/tests/test_dataset.py | 6 +----- 7 files changed, 40 insertions(+), 37 deletions(-) diff --git a/.github/stale.yml b/.github/stale.yml index 5a8f6596d69..f4835b5eeec 100644 --- a/.github/stale.yml +++ b/.github/stale.yml @@ -28,7 +28,8 @@ staleLabel: stale # Comment to post when marking as stale. Set to `false` to disable markComment: | In order to maintain a list of currently relevant issues, we mark issues as stale after a period of inactivity - If this issue remains relevant, please comment here; otherwise it will be marked as closed automatically + + If this issue remains relevant, please comment here or remove the `stale` label; otherwise it will be marked as closed automatically # Comment to post when removing the stale label. # unmarkComment: > diff --git a/doc/whats-new.rst b/doc/whats-new.rst index b7ca384ff09..0149d119595 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -24,6 +24,10 @@ Breaking changes - Remove support for Python 2. This is the first version of xarray that is Python 3 only. (:issue:`1876`). By `Joe Hamman `_. +- The `compat` argument to `Dataset` and the `encoding` argument to + `DataArray` are deprecated and will be removed in a future release. + (:issue:`1188`) + By `Maximilian Roos `_. Enhancements ~~~~~~~~~~~~ diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index 278548cca8c..c44a0c4201d 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -495,7 +495,7 @@ def _broadcast_array(array): coords = OrderedDict(array.coords) coords.update(common_coords) return DataArray(data, coords, data.dims, name=array.name, - attrs=array.attrs, encoding=array.encoding) + attrs=array.attrs) def _broadcast_dataset(ds): data_vars = OrderedDict( diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index cf5227b0a1f..96b42f19555 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -12,15 +12,13 @@ from .alignment import align, reindex_like_indexers from .common import AbstractArray, DataWithCoords from .coordinates import ( - DataArrayCoordinates, LevelCoordinatesSource, - assert_coordinate_consistent, remap_label_indexers) + DataArrayCoordinates, LevelCoordinatesSource, assert_coordinate_consistent, + remap_label_indexers) from .dataset import Dataset, merge_indexes, split_indexes from .formatting import format_item -from .indexes import default_indexes, Indexes +from .indexes import Indexes, default_indexes from .options import OPTIONS -from .utils import ( - _check_inplace, decode_numpy_dict_values, either_dict_or_kwargs, - ensure_us_time_resolution) +from .utils import _check_inplace, either_dict_or_kwargs from .variable import ( IndexVariable, Variable, as_compatible_data, as_variable, assert_unique_multiindex_level_names) @@ -192,13 +190,16 @@ def __init__(self, data, coords=None, dims=None, name=None, attrs : dict_like or None, optional Attributes to assign to the new instance. By default, an empty attribute dictionary is initialized. - encoding : dict_like or None, optional - Dictionary specifying how to encode this array's data into a - serialized format like netCDF4. Currently used keys (for netCDF) - include '_FillValue', 'scale_factor', 'add_offset', 'dtype', - 'units' and 'calendar' (the later two only for datetime arrays). - Unrecognized keys are ignored. + encoding : deprecated """ + + if encoding is not None: + warnings.warn( + 'The `encoding` argument to `DataArray` is deprecated, and . ' + 'will be removed in 0.13. ' + 'Instead, specify the encoding when writing to disk or ' + 'set the `encoding` attribute directly.', + FutureWarning, stacklevel=2) if fastpath: variable = data assert dims is None diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 3c30dff1507..8863dedb7db 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -13,16 +13,16 @@ import xarray as xr from . import ( - alignment, dtypes, duck_array_ops, formatting, groupby, - indexing, ops, pdcompat, resample, rolling, utils) + alignment, dtypes, duck_array_ops, formatting, groupby, indexing, ops, + pdcompat, resample, rolling, utils) from ..coding.cftimeindex import _parse_array_of_cftime_strings from .alignment import align from .common import ( ALL_DIMS, DataWithCoords, ImplementsDatasetReduce, _contains_datetime_like_objects) from .coordinates import ( - DatasetCoordinates, LevelCoordinatesSource, - assert_coordinate_consistent, remap_label_indexers) + DatasetCoordinates, LevelCoordinatesSource, assert_coordinate_consistent, + remap_label_indexers) from .indexes import Indexes, default_indexes from .merge import ( dataset_merge_method, dataset_update_method, merge_data_and_coords, @@ -31,8 +31,8 @@ from .pycompat import dask_array_type from .utils import ( Frozen, SortedKeysDict, _check_inplace, datetime_to_numeric, - decode_numpy_dict_values, either_dict_or_kwargs, ensure_us_time_resolution, - hashable, maybe_wrap_array) + decode_numpy_dict_values, either_dict_or_kwargs, hashable, + maybe_wrap_array) from .variable import IndexVariable, Variable, as_variable, broadcast_variables # list of attributes of pd.DatetimeIndex that are ndarrays of time info @@ -324,7 +324,7 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): _resample_cls = resample.DatasetResample def __init__(self, data_vars=None, coords=None, attrs=None, - compat='broadcast_equals'): + compat=None): """To load data from a file or file-like object, use the `open_dataset` function. @@ -348,16 +348,17 @@ def __init__(self, data_vars=None, coords=None, attrs=None, name. attrs : dict-like, optional Global attributes to save on this dataset. - compat : {'broadcast_equals', 'equals', 'identical'}, optional - String indicating how to compare variables of the same name for - potential conflicts when initializing this dataset: - - - 'broadcast_equals': all values must be equal when variables are - broadcast against each other to ensure common dimensions. - - 'equals': all values and dimensions must be the same. - - 'identical': all values, dimensions and attributes must be the - same. + compat : deprecated """ + + if compat is not None: + warnings.warn( + 'The `compat` argument to Dataset is deprecated and will be ' + 'removed in 0.13.' + 'Instead, use `merge` to control how variables are combined', + FutureWarning, stacklevel=2) + else: + compat = 'broadcast_equals' self._variables = OrderedDict() self._coord_names = set() self._dims = {} diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index f596ac71a6e..6c87511562a 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -258,7 +258,7 @@ def test_constructor(self): expected = Dataset({None: (['x', 'y'], data, {'bar': 2})})[None] assert_identical(expected, actual) - actual = DataArray(data, dims=['x', 'y'], encoding={'bar': 2}) + actual = DataArray(data, dims=['x', 'y']) expected = Dataset({None: (['x', 'y'], data, {}, {'bar': 2})})[None] assert_identical(expected, actual) @@ -296,7 +296,7 @@ def test_constructor_from_self_described(self): expected = DataArray(data, coords={'x': ['a', 'b'], 'y': [-1, -2]}, dims=['x', 'y'], name='foobar', - attrs={'bar': 2}, encoding={'foo': 3}) + attrs={'bar': 2}) actual = DataArray(expected) assert_identical(expected, actual) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index f4b709272d0..01838e0ba88 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -1,10 +1,10 @@ # -*- coding: utf-8 -*- +import pickle import sys import warnings from collections import OrderedDict from copy import copy, deepcopy from io import StringIO -import pickle from textwrap import dedent import numpy as np @@ -354,13 +354,9 @@ def test_constructor_pandas_single(self): def test_constructor_compat(self): data = OrderedDict([('x', DataArray(0, coords={'y': 1})), ('y', ('z', [1, 1, 1]))]) - with pytest.raises(MergeError): - Dataset(data, compat='equals') expected = Dataset({'x': 0}, {'y': ('z', [1, 1, 1])}) actual = Dataset(data) assert_identical(expected, actual) - actual = Dataset(data, compat='broadcast_equals') - assert_identical(expected, actual) data = OrderedDict([('y', ('z', [1, 1, 1])), ('x', DataArray(0, coords={'y': 1}))]) From a1ff90be63667ac4384ec74e82406dbcd1e05165 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Sat, 2 Feb 2019 01:56:12 -0500 Subject: [PATCH 083/108] dropna() for a Series indexed by a CFTimeIndex (#2734) * Support dropna() for a Series indexed by a CFTimeIndex * Add a what's new entry * Use == instead of is --- doc/whats-new.rst | 5 +++-- xarray/coding/cftimeindex.py | 8 +++++--- xarray/tests/test_cftimeindex.py | 8 ++++++++ 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 0149d119595..169950813fd 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -50,13 +50,14 @@ Enhancements - Add ``tolerance`` option to ``resample()`` methods ``bfill``, ``pad``, ``nearest``. (:issue:`2695`) By `Hauke Schulz `_. - - :py:meth:`~xarray.DataArray.integrate` and :py:meth:`~xarray.Dataset.integrate` are newly added. See :ref:`_compute.using_coordinates` for the detail. (:issue:`1332`) By `Keisuke Fujii `_. - +- :py:meth:`pandas.Series.dropna` is now supported for a + :py:class:`pandas.Series` indexed by a :py:class:`~xarray.CFTimeIndex` + (:issue:`2688`). By `Spencer Clark `_. Bug fixes ~~~~~~~~~ diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index f1a05d31a0c..1456f8ce3b3 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -335,11 +335,13 @@ def _maybe_cast_slice_bound(self, label, side, kind): # e.g. series[1:5]. def get_value(self, series, key): """Adapted from pandas.tseries.index.DatetimeIndex.get_value""" - if not isinstance(key, slice): - return series.iloc[self.get_loc(key)] - else: + if np.asarray(key).dtype == np.dtype(bool): + return series.iloc[key] + elif isinstance(key, slice): return series.iloc[self.slice_indexer( key.start, key.stop, key.step)] + else: + return series.iloc[self.get_loc(key)] def __contains__(self, key): """Adapted from diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 97be993d842..358c9df0497 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -585,6 +585,14 @@ def test_indexing_in_series_iloc(series, index): assert series.iloc[:2].equals(expected) +@pytest.mark.skipif(not has_cftime, reason='cftime not installed') +def test_series_dropna(index): + series = pd.Series([0., 1., np.nan, np.nan], index=index) + expected = series.iloc[:2] + result = series.dropna() + assert result.equals(expected) + + @pytest.mark.skipif(not has_cftime, reason='cftime not installed') def test_indexing_in_dataframe_loc(df, index, scalar_args, range_args): expected = pd.Series([1], name=index[0]) From 0da9d627d567ea1cb5e733f892930863bd6b630d Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Fri, 1 Feb 2019 23:47:57 -0800 Subject: [PATCH 084/108] add tests for handling of empty pandas objects in constructors (#2735) * add tests for GH#697 - handling of empty pandas objects in constructors * make pep8 happy --- xarray/tests/test_dataarray.py | 9 +++++++++ xarray/tests/test_dataset.py | 9 +++++++++ 2 files changed, 18 insertions(+) diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 6c87511562a..9465ce2f84a 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2872,6 +2872,15 @@ def test_to_and_from_series(self): expected_da, DataArray.from_series(actual).drop(['x', 'y'])) + def test_to_and_from_empty_series(self): + # GH697 + expected = pd.Series([]) + da = DataArray.from_series(expected) + assert len(da) == 0 + actual = da.to_series() + assert len(actual) == 0 + assert expected.equals(actual) + def test_series_categorical_index(self): # regression test for GH700 if not hasattr(pd, 'CategoricalIndex'): diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 01838e0ba88..05884bda4ba 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -2980,6 +2980,15 @@ def test_to_and_from_dataframe(self): expected = pd.DataFrame([[]], index=idx) assert expected.equals(actual), (expected, actual) + def test_to_and_from_empty_dataframe(self): + # GH697 + expected = pd.DataFrame({'foo': []}) + ds = Dataset.from_dataframe(expected) + assert len(ds['foo']) == 0 + actual = ds.to_dataframe() + assert len(actual) == 0 + assert expected.equals(actual) + def test_from_dataframe_non_unique_columns(self): # regression test for GH449 df = pd.DataFrame(np.zeros((2, 2))) From d8ff0790b743a814cc3d6c29e24b7257c7480153 Mon Sep 17 00:00:00 2001 From: jwenfai Date: Sat, 2 Feb 2019 22:21:13 -0500 Subject: [PATCH 085/108] CFTimeIndex Resampling (#2593) * First implementation of resampling for CFTimeIndex. * First implementation of resampling for CFTimeIndex, cleaned. * First implementation of resampling for CFTimeIndex, cleaned. * First implementation of resampling for CFTimeIndex, cleaned. * First implementation of resampling for CFTimeIndex. * First implementation of resampling for CFTimeIndex, more bugs fixed, cleaned. * First implementation of resampling for CFTimeIndex, test file written. * First implementation of resampling for CFTimeIndex, test file written, cleaned. * First implementation of resampling for CFTimeIndex, test file written, cleaned. * First implementation of resampling for CFTimeIndex, test file written, cleaned. * First implementation of resampling for CFTimeIndex, test file written, cleaned. * Docstrings for resample_cftime.py written. Upsample still not fixed. * Fixed PEP8 and test parametrization. * PEP8 * Test file fixes and other optimizations (2018-12-16 @spencerclark and 2018-12-05 @max-sixty GitHub reviews for resample-v2-clean pull request). Not cleaned. * Test file fixes and other optimizations (2018-12-16 @spencerclark and 2018-12-05 @max-sixty GitHub reviews for resample-v2-clean pull request). Cleaned. * _get_range_edges logic changed to emulate latest version of pandas. * Simplified resampling logic (errors persist). Pre-cleaning. * Simplified resampling logic (error persists). Cleaned. * Simplified resampling logic (error persists). Fixed first_items.dropna() in groupby.py. Pandas cannot drop indices made up of CFTime objects, so integer indices were swapped in for dropping then swapped back out once NAs are dropped. * Simplified resampling logic (error persists). Logic slightly altered after more tests. 5578 out of 5920 tests passed. Pre-cleaning. * Simplified resampling logic (error persists). Logic slightly altered after more tests. 5578 out of 5920 tests passed. Cleaned. * Precise cftime arithmetic. Reduced overall test time. Added test for _get_range_edges. * Added default values for closed and label args of resample function in common.py. Cleaned up print statements. Modified tests that were written under the assumption that CFTimeIndex cannot be resampled so that the tests now pass. * Added back replace['dayofwk'] = -1 to cftime_offsets.py and cftimeindex.py. Removed unused code from resample_cftime.py. Removed tests that raise error when resampling CFTimeIndex. Removed temp files. * Optimizations as per https://github.com/pydata/xarray/pull/2593/#pullrequestreview-194390990 * Simple test for non-standard calendars added and documentation updated. * Simple test for non-standard calendars added and documentation updated. * Added loffset support to CFTimeIndex resampling. Better adherence to PEP8 and other coding style conventions. * Added loffset support to CFTimeIndex resampling. Better adherence to PEP8 and other coding style conventions. * Support datetime.timedelta objects for loffset. Improved test coverage. * Removed support for Python 2 compatibility. * Updated pandas minversion to 0.24 as 0.24 is officially out. * Removed Python 2 support from test_cftimeindex_resample.py. * Moved full_index and first_items generation logic to a helper function so that the complexity of GroupBy.__init__ is reduced. * In groupby.py, moved s to _get_index_and_items helper function. * Removed redundant code from test_formatting.py due to bad merge. * Removed redundant test and simplify code now that dropna is implemented. * delete unnecessary test * eliminate some repetition --- doc/time-series.rst | 20 +- doc/whats-new.rst | 4 + xarray/coding/cftime_offsets.py | 25 +- xarray/core/common.py | 23 +- xarray/core/groupby.py | 21 +- xarray/core/resample_cftime.py | 363 ++++++++++++++++++++++ xarray/tests/test_cftimeindex.py | 6 - xarray/tests/test_cftimeindex_resample.py | 87 ++++++ xarray/tests/test_dataarray.py | 10 - 9 files changed, 509 insertions(+), 50 deletions(-) create mode 100644 xarray/core/resample_cftime.py create mode 100644 xarray/tests/test_cftimeindex_resample.py diff --git a/doc/time-series.rst b/doc/time-series.rst index 47742360f62..b716d6cbc24 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -309,13 +309,19 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: da.differentiate('time') -- And serialization: +- Serialization: .. ipython:: python da.to_netcdf('example-no-leap.nc') xr.open_dataset('example-no-leap.nc') +- And resampling along the time dimension for data indexed by a :py:class:`~xarray.CFTimeIndex`: + +.. ipython:: python + + da.resample(time='81T', closed='right', label='right', base=3).mean() + .. note:: While much of the time series functionality that is possible for standard @@ -323,17 +329,14 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: still some remaining important features that have yet to be implemented, for example: - - Resampling along the time dimension for data indexed by a - :py:class:`~xarray.CFTimeIndex` (:issue:`2191`, :issue:`2458`) - Built-in plotting of data with :py:class:`cftime.datetime` coordinate axes (:issue:`2164`). For some use-cases it may still be useful to convert from a :py:class:`~xarray.CFTimeIndex` to a :py:class:`pandas.DatetimeIndex`, - despite the difference in calendar types (e.g. to allow the use of some - forms of resample with non-standard calendars). The recommended way of - doing this is to use the built-in - :py:meth:`~xarray.CFTimeIndex.to_datetimeindex` method: + despite the difference in calendar types. The recommended way of doing this + is to use the built-in :py:meth:`~xarray.CFTimeIndex.to_datetimeindex` + method: .. ipython:: python :okwarning: @@ -343,8 +346,7 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: da datetimeindex = da.indexes['time'].to_datetimeindex() da['time'] = datetimeindex - da.resample(time='Y').mean('time') - + However in this case one should use caution to only perform operations which do not depend on differences between dates (e.g. differentiation, interpolation, or upsampling with resample), as these could introduce subtle diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 169950813fd..142ef3a2e51 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -47,6 +47,10 @@ Enhancements report showing what exactly differs between the two objects (dimensions / coordinates / variables / attributes) (:issue:`1507`). By `Benoit Bovy `_. +- Resampling of standard and non-standard calendars indexed by + :py:class:`~xarray.CFTimeIndex` is now possible. (:issue:`2191`). + By `Jwen Fai Low `_ and + `Spencer Clark `_. - Add ``tolerance`` option to ``resample()`` methods ``bfill``, ``pad``, ``nearest``. (:issue:`2695`) By `Hauke Schulz `_. diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index a373aeff747..d21139995dd 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -358,29 +358,41 @@ def rollback(self, date): class Day(BaseCFTimeOffset): _freq = 'D' + def as_timedelta(self): + return timedelta(days=self.n) + def __apply__(self, other): - return other + timedelta(days=self.n) + return other + self.as_timedelta() class Hour(BaseCFTimeOffset): _freq = 'H' + def as_timedelta(self): + return timedelta(hours=self.n) + def __apply__(self, other): - return other + timedelta(hours=self.n) + return other + self.as_timedelta() class Minute(BaseCFTimeOffset): _freq = 'T' + def as_timedelta(self): + return timedelta(minutes=self.n) + def __apply__(self, other): - return other + timedelta(minutes=self.n) + return other + self.as_timedelta() class Second(BaseCFTimeOffset): _freq = 'S' + def as_timedelta(self): + return timedelta(seconds=self.n) + def __apply__(self, other): - return other + timedelta(seconds=self.n) + return other + self.as_timedelta() _FREQUENCIES = { @@ -427,6 +439,11 @@ def __apply__(self, other): _FREQUENCY_CONDITION) +# pandas defines these offsets as "Tick" objects, which for instance have +# distinct behavior from monthly or longer frequencies in resample. +CFTIME_TICKS = (Day, Hour, Minute, Second) + + def to_offset(freq): """Convert a frequency string to the appropriate subclass of BaseCFTimeOffset.""" diff --git a/xarray/core/common.py b/xarray/core/common.py index ff0c7034d70..30ea56f3496 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -756,23 +756,16 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, dim_coord = self[dim] if isinstance(self.indexes[dim_name], CFTimeIndex): - raise NotImplementedError( - 'Resample is currently not supported along a dimension ' - 'indexed by a CFTimeIndex. For certain kinds of downsampling ' - 'it may be possible to work around this by converting your ' - 'time index to a DatetimeIndex using ' - 'CFTimeIndex.to_datetimeindex. Use caution when doing this ' - 'however, because switching to a DatetimeIndex from a ' - 'CFTimeIndex with a non-standard calendar entails a change ' - 'in the calendar type, which could lead to subtle and silent ' - 'errors.' - ) - + from .resample_cftime import CFTimeGrouper + grouper = CFTimeGrouper(freq, closed, label, base, loffset) + else: + # TODO: to_offset() call required for pandas==0.19.2 + grouper = pd.Grouper(freq=freq, closed=closed, label=label, + base=base, + loffset=pd.tseries.frequencies.to_offset( + loffset)) group = DataArray(dim_coord, coords=dim_coord.coords, dims=dim_coord.dims, name=RESAMPLE_DIM) - # TODO: to_offset() call required for pandas==0.19.2 - grouper = pd.Grouper(freq=freq, closed=closed, label=label, base=base, - loffset=pd.tseries.frequencies.to_offset(loffset)) resampler = self._resample_cls(self, group=group, dim=dim_name, grouper=grouper, resample_dim=RESAMPLE_DIM) diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py index e4577c3d593..1fa1c159fbc 100644 --- a/xarray/core/groupby.py +++ b/xarray/core/groupby.py @@ -258,12 +258,8 @@ def __init__(self, obj, group, squeeze=False, grouper=None, bins=None, if not index.is_monotonic: # TODO: sort instead of raising an error raise ValueError('index must be monotonic for resampling') - s = pd.Series(np.arange(index.size), index) - first_items = s.groupby(grouper).first() - _apply_loffset(grouper, first_items) - full_index = first_items.index - if first_items.isnull().any(): - first_items = first_items.dropna() + full_index, first_items = self._get_index_and_items( + index, grouper) sbins = first_items.values.astype(np.int64) group_indices = ([slice(i, j) for i, j in zip(sbins[:-1], sbins[1:])] + @@ -310,6 +306,19 @@ def __len__(self): def __iter__(self): return zip(self._unique_coord.values, self._iter_grouped()) + def _get_index_and_items(self, index, grouper): + from .resample_cftime import CFTimeGrouper + s = pd.Series(np.arange(index.size), index) + if isinstance(grouper, CFTimeGrouper): + first_items = grouper.first_items(index) + else: + first_items = s.groupby(grouper).first() + _apply_loffset(grouper, first_items) + full_index = first_items.index + if first_items.isnull().any(): + first_items = first_items.dropna() + return full_index, first_items + def _iter_grouped(self): """Iterate over each element in this group""" for indices in self._group_indices: diff --git a/xarray/core/resample_cftime.py b/xarray/core/resample_cftime.py new file mode 100644 index 00000000000..6b6d214768e --- /dev/null +++ b/xarray/core/resample_cftime.py @@ -0,0 +1,363 @@ +"""Resampling for CFTimeIndex. Does not support non-integer freq.""" +# The mechanisms for resampling CFTimeIndex was copied and adapted from +# the source code defined in pandas.core.resample +# +# For reference, here is a copy of the pandas copyright notice: +# +# BSD 3-Clause License +# +# Copyright (c) 2008-2012, AQR Capital Management, LLC, Lambda Foundry, Inc. +# and PyData Development Team +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +from ..coding.cftimeindex import CFTimeIndex +from ..coding.cftime_offsets import (cftime_range, normalize_date, + Day, MonthEnd, YearEnd, + CFTIME_TICKS, to_offset) +import datetime +import numpy as np +import pandas as pd + + +class CFTimeGrouper(object): + """This is a simple container for the grouping parameters that implements a + single method, the only one required for resampling in xarray. It cannot + be used in a call to groupby like a pandas.Grouper object can.""" + + def __init__(self, freq, closed, label, base, loffset): + self.freq = to_offset(freq) + self.closed = closed + self.label = label + self.base = base + self.loffset = loffset + + if isinstance(self.freq, (MonthEnd, YearEnd)): + if self.closed is None: + self.closed = 'right' + if self.label is None: + self.label = 'right' + else: + if self.closed is None: + self.closed = 'left' + if self.label is None: + self.label = 'left' + + def first_items(self, index): + """Meant to reproduce the results of the following + + grouper = pandas.Grouper(...) + first_items = pd.Series(np.arange(len(index)), + index).groupby(grouper).first() + + with index being a CFTimeIndex instead of a DatetimeIndex. + """ + + datetime_bins, labels = _get_time_bins(index, self.freq, self.closed, + self.label, self.base) + if self.loffset is not None: + if isinstance(self.loffset, datetime.timedelta): + labels = labels + self.loffset + else: + labels = labels + to_offset(self.loffset) + + # check binner fits data + if index[0] < datetime_bins[0]: + raise ValueError("Value falls before first bin") + if index[-1] > datetime_bins[-1]: + raise ValueError("Value falls after last bin") + + integer_bins = np.searchsorted( + index, datetime_bins, side=self.closed)[:-1] + first_items = pd.Series(integer_bins, labels) + + # Mask duplicate values with NaNs, preserving the last values + non_duplicate = ~first_items.duplicated('last') + return first_items.where(non_duplicate) + + +def _get_time_bins(index, freq, closed, label, base): + """Obtain the bins and their respective labels for resampling operations. + + Parameters + ---------- + index : CFTimeIndex + Index object to be resampled (e.g., CFTimeIndex named 'time'). + freq : xarray.coding.cftime_offsets.BaseCFTimeOffset + The offset object representing target conversion a.k.a. resampling + frequency (e.g., 'MS', '2D', 'H', or '3T' with + coding.cftime_offsets.to_offset() applied to it). + closed : 'left' or 'right', optional + Which side of bin interval is closed. + The default is 'left' for all frequency offsets except for 'M' and 'A', + which have a default of 'right'. + label : 'left' or 'right', optional + Which bin edge label to label bucket with. + The default is 'left' for all frequency offsets except for 'M' and 'A', + which have a default of 'right'. + base : int, optional + For frequencies that evenly subdivide 1 day, the "origin" of the + aggregated intervals. For example, for '5min' frequency, base could + range from 0 through 4. Defaults to 0. + + Returns + ------- + datetime_bins : CFTimeIndex + Defines the edge of resampling bins by which original index values will + be grouped into. + labels : CFTimeIndex + Define what the user actually sees the bins labeled as. + """ + + if not isinstance(index, CFTimeIndex): + raise TypeError('index must be a CFTimeIndex, but got ' + 'an instance of %r' % type(index).__name__) + if len(index) == 0: + datetime_bins = labels = CFTimeIndex(data=[], name=index.name) + return datetime_bins, labels + + first, last = _get_range_edges(index.min(), index.max(), freq, + closed=closed, + base=base) + datetime_bins = labels = cftime_range(freq=freq, + start=first, + end=last, + name=index.name) + + datetime_bins, labels = _adjust_bin_edges(datetime_bins, freq, closed, + index, labels) + + if label == 'right': + labels = labels[1:] + else: + labels = labels[:-1] + + # TODO: when CFTimeIndex supports missing values, if the reference index + # contains missing values, insert the appropriate NaN value at the + # beginning of the datetime_bins and labels indexes. + + return datetime_bins, labels + + +def _adjust_bin_edges(datetime_bins, offset, closed, index, labels): + """This is required for determining the bin edges resampling with + daily frequencies greater than one day, month end, and year end + frequencies. + + Consider the following example. Let's say you want to downsample the + time series with the following coordinates to month end frequency: + + CFTimeIndex([2000-01-01 12:00:00, 2000-01-31 12:00:00, + 2000-02-01 12:00:00], dtype='object') + + Without this adjustment, _get_time_bins with month-end frequency will + return the following index for the bin edges (default closed='right' and + label='right' in this case): + + CFTimeIndex([1999-12-31 00:00:00, 2000-01-31 00:00:00, + 2000-02-29 00:00:00], dtype='object') + + If 2000-01-31 is used as a bound for a bin, the value on + 2000-01-31T12:00:00 (at noon on January 31st), will not be included in the + month of January. To account for this, pandas adds a day minus one worth + of microseconds to the bin edges generated by cftime range, so that we do + bin the value at noon on January 31st in the January bin. This results in + an index with bin edges like the following: + + CFTimeIndex([1999-12-31 23:59:59, 2000-01-31 23:59:59, + 2000-02-29 23:59:59], dtype='object') + + The labels are still: + + CFTimeIndex([2000-01-31 00:00:00, 2000-02-29 00:00:00], dtype='object') + + This is also required for daily frequencies longer than one day and + year-end frequencies. + """ + is_super_daily = (isinstance(offset, (MonthEnd, YearEnd)) or + (isinstance(offset, Day) and offset.n > 1)) + if is_super_daily: + if closed == 'right': + datetime_bins = datetime_bins + datetime.timedelta(days=1, + microseconds=-1) + if datetime_bins[-2] > index.max(): + datetime_bins = datetime_bins[:-1] + labels = labels[:-1] + + return datetime_bins, labels + + +def _get_range_edges(first, last, offset, closed='left', base=0): + """ Get the correct starting and ending datetimes for the resampled + CFTimeIndex range. + + Parameters + ---------- + first : cftime.datetime + Uncorrected starting datetime object for resampled CFTimeIndex range. + Usually the min of the original CFTimeIndex. + last : cftime.datetime + Uncorrected ending datetime object for resampled CFTimeIndex range. + Usually the max of the original CFTimeIndex. + offset : xarray.coding.cftime_offsets.BaseCFTimeOffset + The offset object representing target conversion a.k.a. resampling + frequency. Contains information on offset type (e.g. Day or 'D') and + offset magnitude (e.g., n = 3). + closed : 'left' or 'right', optional + Which side of bin interval is closed. Defaults to 'left'. + base : int, optional + For frequencies that evenly subdivide 1 day, the "origin" of the + aggregated intervals. For example, for '5min' frequency, base could + range from 0 through 4. Defaults to 0. + + Returns + ------- + first : cftime.datetime + Corrected starting datetime object for resampled CFTimeIndex range. + last : cftime.datetime + Corrected ending datetime object for resampled CFTimeIndex range. + """ + if isinstance(offset, CFTIME_TICKS): + first, last = _adjust_dates_anchored(first, last, offset, + closed=closed, base=base) + return first, last + else: + first = normalize_date(first) + last = normalize_date(last) + + if closed == 'left': + first = offset.rollback(first) + else: + first = first - offset + + last = last + offset + return first, last + + +def _adjust_dates_anchored(first, last, offset, closed='right', base=0): + """ First and last offsets should be calculated from the start day to fix + an error cause by resampling across multiple days when a one day period is + not a multiple of the frequency. + See https://github.com/pandas-dev/pandas/issues/8683 + + Parameters + ---------- + first : cftime.datetime + A datetime object representing the start of a CFTimeIndex range. + last : cftime.datetime + A datetime object representing the end of a CFTimeIndex range. + offset : xarray.coding.cftime_offsets.BaseCFTimeOffset + The offset object representing target conversion a.k.a. resampling + frequency. Contains information on offset type (e.g. Day or 'D') and + offset magnitude (e.g., n = 3). + closed : 'left' or 'right', optional + Which side of bin interval is closed. Defaults to 'right'. + base : int, optional + For frequencies that evenly subdivide 1 day, the "origin" of the + aggregated intervals. For example, for '5min' frequency, base could + range from 0 through 4. Defaults to 0. + + Returns + ------- + fresult : cftime.datetime + A datetime object representing the start of a date range that has been + adjusted to fix resampling errors. + lresult : cftime.datetime + A datetime object representing the end of a date range that has been + adjusted to fix resampling errors. + """ + + base = base % offset.n + start_day = normalize_date(first) + base_td = type(offset)(n=base).as_timedelta() + start_day += base_td + foffset = exact_cftime_datetime_difference( + start_day, first) % offset.as_timedelta() + loffset = exact_cftime_datetime_difference( + start_day, last) % offset.as_timedelta() + if closed == 'right': + if foffset.total_seconds() > 0: + fresult = first - foffset + else: + fresult = first - offset.as_timedelta() + + if loffset.total_seconds() > 0: + lresult = last + (offset.as_timedelta() - loffset) + else: + lresult = last + else: + if foffset.total_seconds() > 0: + fresult = first - foffset + else: + fresult = first + + if loffset.total_seconds() > 0: + lresult = last + (offset.as_timedelta() - loffset) + else: + lresult = last + offset.as_timedelta() + return fresult, lresult + + +def exact_cftime_datetime_difference(a, b): + """Exact computation of b - a + + Assumes: + + a = a_0 + a_m + b = b_0 + b_m + + Here a_0, and b_0 represent the input dates rounded + down to the nearest second, and a_m, and b_m represent + the remaining microseconds associated with date a and + date b. + + We can then express the value of b - a as: + + b - a = (b_0 + b_m) - (a_0 + a_m) = b_0 - a_0 + b_m - a_m + + By construction, we know that b_0 - a_0 must be a round number + of seconds. Therefore we can take the result of b_0 - a_0 using + ordinary cftime.datetime arithmetic and round to the nearest + second. b_m - a_m is the remainder, in microseconds, and we + can simply add this to the rounded timedelta. + + Parameters + ---------- + a : cftime.datetime + Input datetime + b : cftime.datetime + Input datetime + + Returns + ------- + datetime.timedelta + """ + seconds = b.replace(microsecond=0) - a.replace(microsecond=0) + seconds = int(round(seconds.total_seconds())) + microseconds = b.microsecond - a.microsecond + return datetime.timedelta(seconds=seconds, microseconds=microseconds) diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 358c9df0497..c5cdf0a3fee 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -375,12 +375,6 @@ def test_groupby(da): assert_identical(result, expected) -@pytest.mark.skipif(not has_cftime, reason='cftime not installed') -def test_resample_error(da): - with pytest.raises(NotImplementedError, match='to_datetimeindex'): - da.resample(time='Y') - - SEL_STRING_OR_LIST_TESTS = { 'string': '0001', 'string-slice': slice('0001-01-01', '0001-12-30'), # type: ignore diff --git a/xarray/tests/test_cftimeindex_resample.py b/xarray/tests/test_cftimeindex_resample.py new file mode 100644 index 00000000000..0b56f1d1fc6 --- /dev/null +++ b/xarray/tests/test_cftimeindex_resample.py @@ -0,0 +1,87 @@ +import pytest + +import datetime +import numpy as np +import pandas as pd +import xarray as xr + +pytest.importorskip('cftime') +pytest.importorskip('pandas', minversion='0.24') + + +@pytest.fixture( + params=[ + dict(start='2004-01-01T12:07:01', periods=91, freq='3D'), + dict(start='1892-01-03T12:07:01', periods=15, freq='41987T'), + dict(start='2004-01-01T12:07:01', periods=31, freq='2MS'), + dict(start='1892-01-03T12:07:01', periods=10, freq='3AS-JUN') + ], + ids=['3D', '41987T', '2MS', '3AS_JUN'] +) +def time_range_kwargs(request): + return request.param + + +@pytest.fixture() +def datetime_index(time_range_kwargs): + return pd.date_range(**time_range_kwargs) + + +@pytest.fixture() +def cftime_index(time_range_kwargs): + return xr.cftime_range(**time_range_kwargs) + + +def da(index): + return xr.DataArray(np.arange(100., 100. + index.size), + coords=[index], dims=['time']) + + +@pytest.mark.parametrize('freq', [ + '700T', '8001T', + '12H', '8001H', + '3D', '8D', '8001D', + '2MS', '2M', '3MS', '3M', '4MS', '4M', + '3AS', '3A', '4AS', '4A']) +@pytest.mark.parametrize('closed', [None, 'left', 'right']) +@pytest.mark.parametrize('label', [None, 'left', 'right']) +@pytest.mark.parametrize('base', [17, 24]) +def test_resampler(freq, closed, label, base, + datetime_index, cftime_index): + # Fairly extensive testing for standard/proleptic Gregorian calendar + loffset = '12H' + try: + da_datetime = da(datetime_index).resample( + time=freq, closed=closed, label=label, base=base, + loffset=loffset).mean() + except ValueError: + with pytest.raises(ValueError): + da(cftime_index).resample( + time=freq, closed=closed, label=label, base=base, + loffset=loffset).mean() + else: + da_cftime = da(cftime_index).resample(time=freq, closed=closed, + label=label, base=base, + loffset=loffset).mean() + da_cftime['time'] = da_cftime.indexes['time'].to_datetimeindex() + xr.testing.assert_identical(da_cftime, da_datetime) + + +@pytest.mark.parametrize('calendar', ['gregorian', 'noleap', 'all_leap', + '360_day', 'julian']) +def test_calendars(calendar): + # Limited testing for non-standard calendars + freq, closed, label, base = '81T', None, None, 17 + loffset = datetime.timedelta(hours=12) + xr_index = xr.cftime_range(start='2004-01-01T12:07:01', periods=7, + freq='3D', calendar=calendar) + pd_index = pd.date_range(start='2004-01-01T12:07:01', periods=7, + freq='3D') + da_cftime = da(xr_index).resample( + time=freq, closed=closed, label=label, base=base, loffset=loffset + ).mean() + da_datetime = da(pd_index).resample( + time=freq, closed=closed, label=label, base=base, loffset=loffset + ).mean() + da_cftime['time'] = da_cftime.indexes['time'].to_datetimeindex() + xr.testing.assert_identical(da_cftime, da_datetime) diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 9465ce2f84a..906ebb278cc 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2299,16 +2299,6 @@ def func(arg1, arg2, arg3=0.): actual = da.resample(time='D').apply(func, args=(1.,), arg3=1.) assert_identical(actual, expected) - @requires_cftime - def test_resample_cftimeindex(self): - cftime = _import_cftime() - times = cftime.num2date(np.arange(12), units='hours since 0001-01-01', - calendar='noleap') - array = DataArray(np.arange(12), [('time', times)]) - - with raises_regex(NotImplementedError, 'to_datetimeindex'): - array.resample(time='6H').mean() - def test_resample_first(self): times = pd.date_range('2000-01-01', freq='6H', periods=10) array = DataArray(np.arange(10), [('time', times)]) From 2ef3f0b84ee044107e6534326de45702bcdbbf61 Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Sat, 2 Feb 2019 19:32:20 -0800 Subject: [PATCH 086/108] remove bottleneck dev build from travis, this test env was failing to build (#2736) --- .travis.yml | 2 -- ci/requirements-py36-bottleneck-dev.yml | 24 ------------------------ 2 files changed, 26 deletions(-) delete mode 100644 ci/requirements-py36-bottleneck-dev.yml diff --git a/.travis.yml b/.travis.yml index fbc01b4815d..ea9ee7adcf4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,7 +19,6 @@ matrix: - EXTRA_FLAGS="--run-flaky --run-network-tests" - env: CONDA_ENV=py36-dask-dev - env: CONDA_ENV=py36-pandas-dev - - env: CONDA_ENV=py36-bottleneck-dev - env: CONDA_ENV=py36-rasterio - env: CONDA_ENV=py36-zarr-dev - env: CONDA_ENV=docs @@ -31,7 +30,6 @@ matrix: - CONDA_ENV=py36 - EXTRA_FLAGS="--run-flaky --run-network-tests" - env: CONDA_ENV=py36-pandas-dev - - env: CONDA_ENV=py36-bottleneck-dev - env: CONDA_ENV=py36-zarr-dev before_install: diff --git a/ci/requirements-py36-bottleneck-dev.yml b/ci/requirements-py36-bottleneck-dev.yml deleted file mode 100644 index 3f08648be32..00000000000 --- a/ci/requirements-py36-bottleneck-dev.yml +++ /dev/null @@ -1,24 +0,0 @@ -name: test_env -channels: - - conda-forge -dependencies: - - python=3.6 - - cftime - - dask - - distributed - - h5py - - h5netcdf - - matplotlib - - netcdf4 - - pytest - - pytest-cov - - pytest-env - - coveralls - - flake8 - - numpy - - pandas - - scipy - - seaborn - - toolz - - pip: - - git+https://github.com/kwgoodman/bottleneck.git From 053aed1f76b7ccbac86078475b61c23182ace982 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Sun, 3 Feb 2019 20:42:16 -0800 Subject: [PATCH 087/108] Reenable cross engine read write netCDF test (#2739) Fixes https://github.com/pydata/xarray/issues/2050 I'm not quite sure what was going on, but it passes now. --- xarray/tests/test_backends.py | 1 - 1 file changed, 1 deletion(-) diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 55e4eb7c8db..d99a7b32d3d 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -1732,7 +1732,6 @@ def test_engine(self): with raises_regex(ValueError, 'can only read'): open_dataset(BytesIO(netcdf_bytes), engine='foobar') - @pytest.mark.xfail(reason='https://github.com/pydata/xarray/issues/2050') def test_cross_engine_read_write_netcdf3(self): data = create_test_data() valid_engines = set() From 27cf53f24c6c3b6ec05a435d3606ebba977b6343 Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Mon, 4 Feb 2019 06:50:15 -0800 Subject: [PATCH 088/108] remove xfail from test_cross_engine_read_write_netcdf4 (#2741) --- xarray/tests/test_backends.py | 1 - 1 file changed, 1 deletion(-) diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index d99a7b32d3d..e9d7a9f65d6 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -1800,7 +1800,6 @@ def test_complex(self): with self.roundtrip(expected) as actual: assert_equal(expected, actual) - @pytest.mark.xfail(reason='https://github.com/pydata/xarray/issues/535') def test_cross_engine_read_write_netcdf4(self): # Drop dim3, because its labels include strings. These appear to be # not properly read with python-netCDF4, which converts them into From e677b7a0aa344faee3eb407e63422038c2029399 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Wed, 6 Feb 2019 08:07:38 -0800 Subject: [PATCH 089/108] Refactor (part of) dataset.py to use explicit indexes (#2696) * Refactor (part of) dataset.py to use explicit indexes * Use copy.copy() * Ensure coordinate order is deterministic --- xarray/core/alignment.py | 30 ++- xarray/core/dataset.py | 419 ++++++++++++++++++++++----------- xarray/core/duck_array_ops.py | 2 +- xarray/core/indexes.py | 47 +++- xarray/core/merge.py | 38 +-- xarray/core/variable.py | 4 +- xarray/tests/test_dataarray.py | 4 +- xarray/tests/test_dataset.py | 2 +- 8 files changed, 372 insertions(+), 174 deletions(-) diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index c44a0c4201d..7aaeff00b5e 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -3,13 +3,15 @@ import warnings from collections import OrderedDict, defaultdict from contextlib import suppress +from typing import Any, Mapping, Optional import numpy as np +import pandas as pd from . import utils from .indexing import get_indexer_nd from .utils import is_dict_like, is_full_slice -from .variable import IndexVariable +from .variable import IndexVariable, Variable def _get_joiner(join): @@ -260,8 +262,15 @@ def reindex_like_indexers(target, other): return indexers -def reindex_variables(variables, sizes, indexes, indexers, method=None, - tolerance=None, copy=True): +def reindex_variables( + variables: Mapping[Any, Variable], + sizes: Mapping[Any, int], + indexes: Mapping[Any, pd.Index], + indexers: Mapping, + method: Optional[str] = None, + tolerance: Any = None, + copy: bool = True, +) -> 'Tuple[OrderedDict[Any, Variable], OrderedDict[Any, pd.Index]]': """Conform a dictionary of aligned variables onto a new set of variables, filling in missing values with NaN. @@ -274,7 +283,7 @@ def reindex_variables(variables, sizes, indexes, indexers, method=None, sizes : dict-like Dictionary from dimension names to integer sizes. indexes : dict-like - Dictionary of xarray.IndexVariable objects associated with variables. + Dictionary of indexes associated with variables. indexers : dict Dictionary with keys given by dimension names and values given by arrays of coordinates tick labels. Any mis-matched coordinate values @@ -300,13 +309,15 @@ def reindex_variables(variables, sizes, indexes, indexers, method=None, Returns ------- reindexed : OrderedDict - Another dict, with the items in variables but replaced indexes. + Dict of reindexed variables. + new_indexes : OrderedDict + Dict of indexes associated with the reindexed variables. """ from .dataarray import DataArray # build up indexers for assignment along each dimension int_indexers = {} - targets = {} + targets = OrderedDict() masked_dims = set() unchanged_dims = set() @@ -359,7 +370,7 @@ def reindex_variables(variables, sizes, indexes, indexers, method=None, if dim in variables: var = variables[dim] - args = (var.attrs, var.encoding) + args = (var.attrs, var.encoding) # type: tuple else: args = () reindexed[dim] = IndexVariable((dim,), indexers[dim], *args) @@ -384,7 +395,10 @@ def reindex_variables(variables, sizes, indexes, indexers, method=None, reindexed[name] = new_var - return reindexed + new_indexes = OrderedDict(indexes) + new_indexes.update(targets) + + return reindexed, new_indexes def broadcast(*args, **kwargs): diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 8863dedb7db..d1323c171eb 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -1,3 +1,4 @@ +import copy import functools import sys import warnings @@ -5,7 +6,10 @@ from collections.abc import Mapping from distutils.version import LooseVersion from numbers import Number -from typing import Any, Dict, List, Set, Tuple, Union +from typing import ( + Any, Callable, Dict, List, Optional, Set, Tuple, TypeVar, TYPE_CHECKING, + Union, +) import numpy as np import pandas as pd @@ -22,8 +26,9 @@ _contains_datetime_like_objects) from .coordinates import ( DatasetCoordinates, LevelCoordinatesSource, assert_coordinate_consistent, - remap_label_indexers) -from .indexes import Indexes, default_indexes + remap_label_indexers, +) +from .indexes import Indexes, default_indexes, isel_variable_and_index from .merge import ( dataset_merge_method, dataset_update_method, merge_data_and_coords, merge_variables) @@ -34,6 +39,9 @@ decode_numpy_dict_values, either_dict_or_kwargs, hashable, maybe_wrap_array) from .variable import IndexVariable, Variable, as_variable, broadcast_variables +if TYPE_CHECKING: + from .dataarray import DataArray + # list of attributes of pd.DatetimeIndex that are ndarrays of time info _DATETIMEINDEX_COMPONENTS = ['year', 'month', 'day', 'hour', 'minute', @@ -305,6 +313,9 @@ def __getitem__(self, key): return self.dataset.sel(**key) +T = TypeVar('T', bound='Dataset') + + class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): """A multi-dimensional, in memory, array database. @@ -350,7 +361,6 @@ def __init__(self, data_vars=None, coords=None, attrs=None, Global attributes to save on this dataset. compat : deprecated """ - if compat is not None: warnings.warn( 'The `compat` argument to Dataset is deprecated and will be ' @@ -359,10 +369,11 @@ def __init__(self, data_vars=None, coords=None, attrs=None, FutureWarning, stacklevel=2) else: compat = 'broadcast_equals' - self._variables = OrderedDict() + + self._variables = OrderedDict() # type: OrderedDict[Any, Variable] self._coord_names = set() - self._dims = {} - self._attrs = None + self._dims = {} # type: Dict[Any, int] + self._attrs = None # type: Optional[OrderedDict] self._file_obj = None if data_vars is None: data_vars = {} @@ -410,7 +421,7 @@ def load_store(cls, store, decoder=None): return obj @property - def variables(self): + def variables(self) -> 'Mapping[Any, Variable]': """Low level interface to Dataset contents as dict of Variable objects. This ordered dictionary is frozen to prevent mutation that could @@ -420,11 +431,8 @@ def variables(self): """ return Frozen(self._variables) - def _attrs_copy(self): - return None if self._attrs is None else OrderedDict(self._attrs) - @property - def attrs(self): + def attrs(self) -> Mapping: """Dictionary of global attributes on this dataset """ if self._attrs is None: @@ -436,7 +444,7 @@ def attrs(self, value): self._attrs = OrderedDict(value) @property - def encoding(self): + def encoding(self) -> Dict: """Dictionary of global encoding attributes on this dataset """ if self._encoding is None: @@ -448,7 +456,7 @@ def encoding(self, value): self._encoding = dict(value) @property - def dims(self): + def dims(self) -> 'Mapping[Any, int]': """Mapping from dimension names to lengths. Cannot be modified directly, but is updated when adding new variables. @@ -460,7 +468,7 @@ def dims(self): return Frozen(SortedKeysDict(self._dims)) @property - def sizes(self): + def sizes(self) -> 'Mapping[Any, int]': """Mapping from dimension names to lengths. Cannot be modified directly, but is updated when adding new variables. @@ -474,7 +482,7 @@ def sizes(self): """ return self.dims - def load(self, **kwargs): + def load(self: T, **kwargs) -> T: """Manually trigger loading of this dataset's data from disk or a remote source into memory and return this dataset. @@ -549,18 +557,32 @@ def __dask_postcompute__(self): info = [(True, k, v.__dask_postcompute__()) if dask.is_dask_collection(v) else (False, k, v) for k, v in self._variables.items()] - return self._dask_postcompute, (info, self._coord_names, self._dims, - self._attrs, self._file_obj, - self._encoding) + args = ( + info, + self._coord_names, + self._dims, + self._attrs, + self._indexes, + self._encoding, + self._file_obj, + ) + return self._dask_postcompute, args def __dask_postpersist__(self): import dask info = [(True, k, v.__dask_postpersist__()) if dask.is_dask_collection(v) else (False, k, v) for k, v in self._variables.items()] - return self._dask_postpersist, (info, self._coord_names, self._dims, - self._attrs, self._file_obj, - self._encoding) + args = ( + info, + self._coord_names, + self._dims, + self._attrs, + self._indexes, + self._encoding, + self._file_obj, + ) + return self._dask_postpersist, args @staticmethod def _dask_postcompute(results, info, *args): @@ -591,7 +613,7 @@ def _dask_postpersist(dsk, info, *args): return Dataset._construct_direct(variables, *args) - def compute(self, **kwargs): + def compute(self: T, **kwargs) -> T: """Manually trigger loading of this dataset's data from disk or a remote source into memory and return a new dataset. The original is left unaltered. @@ -629,7 +651,7 @@ def _persist_inplace(self, **kwargs): return self - def persist(self, **kwargs): + def persist(self: T, **kwargs) -> T: """ Trigger computation, keeping data as dask arrays This operation can be used to trigger computation on underlying dask @@ -651,8 +673,8 @@ def persist(self, **kwargs): return new._persist_inplace(**kwargs) @classmethod - def _construct_direct(cls, variables, coord_names, dims=None, attrs=None, - indexes=None, file_obj=None, encoding=None): + def _construct_direct(cls, variables, coord_names, dims, attrs=None, + indexes=None, encoding=None, file_obj=None): """Shortcut around __init__ for internal use when we want to skip costly validation """ @@ -667,62 +689,103 @@ def _construct_direct(cls, variables, coord_names, dims=None, attrs=None, obj._initialized = True return obj - __default_attrs = object() + __default = object() @classmethod def _from_vars_and_coord_names(cls, variables, coord_names, attrs=None): dims = dict(calculate_dimensions(variables)) return cls._construct_direct(variables, coord_names, dims, attrs) - def _replace_vars_and_dims(self, variables, coord_names=None, dims=None, - attrs=__default_attrs, indexes=None, - inplace=False): + def _replace( + self: T, + variables: 'OrderedDict[Any, Variable]' = None, + coord_names: set = None, + dims: 'OrderedDict[Any, int]' = None, + attrs: 'Optional[OrderedDict]' = __default, + indexes: 'Optional[OrderedDict[Any, pd.Index]]' = __default, + encoding: Optional[dict] = __default, + inplace: bool = False, + ) -> T: """Fastpath constructor for internal use. - Preserves coord names and attributes. If not provided explicitly, - dimensions are recalculated from the supplied variables. - - The arguments are *not* copied when placed on the new dataset. It is up - to the caller to ensure that they have the right type and are not used - elsewhere. - - Parameters - ---------- - variables : OrderedDict - coord_names : set or None, optional - attrs : OrderedDict or None, optional + Returns an object with optionally with replaced attributes. - Returns - ------- - new : Dataset + Explicitly passed arguments are *not* copied when placed on the new + dataset. It is up to the caller to ensure that they have the right type + and are not used elsewhere. """ - if dims is None: - dims = calculate_dimensions(variables) if inplace: - self._dims = dims - self._variables = variables + if variables is not None: + self._variables = variables if coord_names is not None: self._coord_names = coord_names - if attrs is not self.__default_attrs: + if dims is not None: + self._dims = dims + if attrs is not self.__default: self._attrs = attrs - self._indexes = indexes + if indexes is not self.__default: + self._indexes = indexes + if encoding is not self.__default: + self._encoding = encoding obj = self else: + if variables is None: + variables = self._variables.copy() if coord_names is None: coord_names = self._coord_names.copy() - if attrs is self.__default_attrs: - attrs = self._attrs_copy() + if dims is None: + dims = self._dims.copy() + if attrs is self.__default: + attrs = copy.copy(self._attrs) + if indexes is self.__default: + indexes = copy.copy(self._indexes) + if encoding is self.__default: + encoding = copy.copy(self._encoding) obj = self._construct_direct( - variables, coord_names, dims, attrs, indexes) + variables, coord_names, dims, attrs, indexes, encoding) return obj - def _replace_indexes(self, indexes): - if not len(indexes): + def _replace_with_new_dims( + self: T, + variables: 'OrderedDict[Any, Variable]' = None, + coord_names: set = None, + attrs: 'Optional[OrderedDict]' = __default, + indexes: 'Optional[OrderedDict[Any, pd.Index]]' = __default, + inplace: bool = False, + ) -> T: + """Replace variables with recalculated dimensions.""" + dims = dict(calculate_dimensions(variables)) + return self._replace( + variables, coord_names, dims, attrs, indexes, inplace=inplace) + + def _replace_vars_and_dims( + self: T, + variables: 'OrderedDict[Any, Variable]' = None, + coord_names: set = None, + dims: 'OrderedDict[Any, int]' = None, + attrs: 'Optional[OrderedDict]' = __default, + inplace: bool = False, + ) -> T: + """Deprecated version of _replace_with_new_dims(). + + Unlike _replace_with_new_dims(), this method always recalculates + indexes from variables. + """ + if dims is None: + dims = calculate_dimensions(variables) + return self._replace( + variables, coord_names, dims, attrs, indexes=None, inplace=inplace) + + def _overwrite_indexes(self, indexes): + if not indexes: return self + variables = self._variables.copy() + new_indexes = OrderedDict(self.indexes) for name, idx in indexes.items(): variables[name] = IndexVariable(name, idx) - obj = self._replace_vars_and_dims(variables) + new_indexes[name] = idx + obj = self._replace(variables, indexes=new_indexes) # switch from dimension to level names, if necessary dim_names = {} @@ -733,7 +796,7 @@ def _replace_indexes(self, indexes): obj = obj.rename(dim_names) return obj - def copy(self, deep=False, data=None): + def copy(self: T, deep: bool = False, data: Mapping = None) -> T: """Returns a copy of this dataset. If `deep=True`, a deep copy is made of each of the component variables. @@ -849,22 +912,7 @@ def copy(self, deep=False, data=None): variables = OrderedDict((k, v.copy(deep=deep, data=data.get(k))) for k, v in self._variables.items()) - # skip __init__ to avoid costly validation - return self._construct_direct(variables, self._coord_names.copy(), - self._dims.copy(), self._attrs_copy(), - encoding=self.encoding) - - def _subset_with_all_valid_coords(self, variables, coord_names, attrs): - needed_dims = set() - for v in variables.values(): - needed_dims.update(v.dims) - for k in self._coord_names: - if set(self.variables[k].dims) <= needed_dims: - variables[k] = self._variables[k] - coord_names.add(k) - dims = dict((k, self._dims[k]) for k in needed_dims) - - return self._construct_direct(variables, coord_names, dims, attrs) + return self._replace(variables) @property def _level_coords(self): @@ -872,16 +920,14 @@ def _level_coords(self): coordinate name. """ level_coords = OrderedDict() - for cname in self._coord_names: - var = self.variables[cname] - if var.ndim == 1 and isinstance(var, IndexVariable): - level_names = var.level_names - if level_names is not None: - dim, = var.dims - level_coords.update({lname: dim for lname in level_names}) + for name, index in self.indexes.items(): + if isinstance(index, pd.MultiIndex): + level_names = index.names + (dim,) = self.variables[name].dims + level_coords.update({lname: dim for lname in level_names}) return level_coords - def _copy_listed(self, names): + def _copy_listed(self: T, names) -> T: """Create a new Dataset with the listed variables from this dataset and the all relevant coordinates. Skips all validation. """ @@ -898,10 +944,26 @@ def _copy_listed(self, names): if ref_name in self._coord_names or ref_name in self.dims: coord_names.add(var_name) - return self._subset_with_all_valid_coords(variables, coord_names, - attrs=self.attrs.copy()) + needed_dims = set() # type: set + for v in variables.values(): + needed_dims.update(v.dims) + + dims = dict((k, self.dims[k]) for k in needed_dims) - def _construct_dataarray(self, name): + for k in self._coord_names: + if set(self.variables[k].dims) <= needed_dims: + variables[k] = self._variables[k] + coord_names.add(k) + + if self._indexes is None: + indexes = None + else: + indexes = OrderedDict((k, v) for k, v in self._indexes.items() + if k in coord_names) + + return self._replace(variables, coord_names, dims, indexes=indexes) + + def _construct_dataarray(self, name) -> 'DataArray': """Construct a DataArray by indexing this dataset """ from .dataarray import DataArray @@ -912,13 +974,21 @@ def _construct_dataarray(self, name): _, name, variable = _get_virtual_variable( self._variables, name, self._level_coords, self.dims) - coords = OrderedDict() needed_dims = set(variable.dims) + + coords = OrderedDict() for k in self.coords: if set(self.variables[k].dims) <= needed_dims: coords[k] = self.variables[k] - return DataArray(variable, coords, name=name, fastpath=True) + if self._indexes is None: + indexes = None + else: + indexes = OrderedDict((k, v) for k, v in self._indexes.items() + if k in coords) + + return DataArray(variable, coords, name=name, indexes=indexes, + fastpath=True) def __copy__(self): return self.copy(deep=False) @@ -1078,7 +1148,7 @@ def identical(self, other): return False @property - def indexes(self): + def indexes(self) -> 'Mapping[Any, pd.Index]': """Mapping of pandas.Index objects used for label based indexing """ if self._indexes is None: @@ -1410,9 +1480,11 @@ def maybe_chunk(name, var, chunks): variables = OrderedDict([(k, maybe_chunk(k, v, chunks)) for k, v in self.variables.items()]) - return self._replace_vars_and_dims(variables) + return self._replace(variables) - def _validate_indexers(self, indexers): + def _validate_indexers( + self, indexers: Mapping, + ) -> List[Tuple[Any, Union[slice, Variable]]]: """ Here we make sure + indexer has a valid keys + indexer is in a valid data type @@ -1457,7 +1529,7 @@ def _validate_indexers(self, indexers): indexers_list.append((k, v)) return indexers_list - def _get_indexers_coordinates(self, indexers): + def _get_indexers_coords_and_indexes(self, indexers): """ Extract coordinates from indexers. Returns an OrderedDict mapping from coordinate name to the coordinate variable. @@ -1468,6 +1540,7 @@ def _get_indexers_coordinates(self, indexers): from .dataarray import DataArray coord_list = [] + indexes = OrderedDict() for k, v in indexers.items(): if isinstance(v, DataArray): v_coords = v.coords @@ -1482,17 +1555,22 @@ def _get_indexers_coordinates(self, indexers): v_coords = v[v.values.nonzero()[0]].coords coord_list.append({d: v_coords[d].variable for d in v.coords}) + indexes.update(v.indexes) - # we don't need to call align() explicitly, because merge_variables - # already checks for exact alignment between dimension coordinates + # we don't need to call align() explicitly or check indexes for + # alignment, because merge_variables already checks for exact alignment + # between dimension coordinates coords = merge_variables(coord_list) assert_coordinate_consistent(self, coords) - attached_coords = OrderedDict() - for k, v in coords.items(): # silently drop the conflicted variables. - if k not in self._variables: - attached_coords[k] = v - return attached_coords + # silently drop the conflicted variables. + attached_coords = OrderedDict( + (k, v) for k, v in coords.items() if k not in self._variables + ) + attached_indexes = OrderedDict( + (k, v) for k, v in indexes.items() if k not in self._variables + ) + return attached_coords, attached_indexes def isel(self, indexers=None, drop=False, **indexers_kwargs): """Returns a new dataset with each array indexed along the specified @@ -1540,23 +1618,36 @@ def isel(self, indexers=None, drop=False, **indexers_kwargs): indexers_list = self._validate_indexers(indexers) variables = OrderedDict() - for name, var in self._variables.items(): + indexes = OrderedDict() + for name, var in self.variables.items(): var_indexers = {k: v for k, v in indexers_list if k in var.dims} - new_var = var.isel(indexers=var_indexers) - if not (drop and name in var_indexers): - variables[name] = new_var + if drop and name in var_indexers: + continue # drop this variable + + if name in self.indexes: + new_var, new_index = isel_variable_and_index( + var, self.indexes[name], var_indexers) + if new_index is not None: + indexes[name] = new_index + else: + new_var = var.isel(indexers=var_indexers) + + variables[name] = new_var coord_names = set(variables).intersection(self._coord_names) - selected = self._replace_vars_and_dims(variables, - coord_names=coord_names) + selected = self._replace_with_new_dims( + variables, coord_names, indexes) # Extract coordinates from indexers - coord_vars = selected._get_indexers_coordinates(indexers) + coord_vars, new_indexes = ( + selected._get_indexers_coords_and_indexes(indexers)) variables.update(coord_vars) + indexes.update(new_indexes) coord_names = (set(variables) .intersection(self._coord_names) .union(coord_vars)) - return self._replace_vars_and_dims(variables, coord_names=coord_names) + return self._replace_with_new_dims( + variables, coord_names, indexes=indexes) def sel(self, indexers=None, method=None, tolerance=None, drop=False, **indexers_kwargs): @@ -1626,7 +1717,7 @@ def sel(self, indexers=None, method=None, tolerance=None, drop=False, pos_indexers, new_indexes = remap_label_indexers( self, indexers=indexers, method=method, tolerance=tolerance) result = self.isel(indexers=pos_indexers, drop=drop) - return result._replace_indexes(new_indexes) + return result._overwrite_indexes(new_indexes) def isel_points(self, dim='points', **indexers): # type: (...) -> Dataset @@ -1926,12 +2017,13 @@ def reindex(self, indexers=None, method=None, tolerance=None, copy=True, if bad_dims: raise ValueError('invalid reindex dimensions: %s' % bad_dims) - variables = alignment.reindex_variables( + variables, indexes = alignment.reindex_variables( self.variables, self.sizes, self.indexes, indexers, method, tolerance, copy=copy) coord_names = set(self._coord_names) coord_names.update(indexers) - return self._replace_vars_and_dims(variables, coord_names) + return self._replace_with_new_dims( + variables, coord_names, indexes=indexes) def interp(self, coords=None, method='linear', assume_sorted=False, kwargs={}, **coords_kwargs): @@ -2005,9 +2097,11 @@ def _validate_interp_indexer(x, new_x): for name, var in obj._variables.items(): if name not in indexers: if var.dtype.kind in 'uifc': - var_indexers = {k: _validate_interp_indexer( - maybe_variable(obj, k), v) for k, v - in indexers.items() if k in var.dims} + var_indexers = { + k: _validate_interp_indexer(maybe_variable(obj, k), v) + for k, v in indexers.items() + if k in var.dims + } variables[name] = missing.interp( var, var_indexers, method, **kwargs) elif all(d not in indexers for d in var.dims): @@ -2015,17 +2109,23 @@ def _validate_interp_indexer(x, new_x): variables[name] = var coord_names = set(variables).intersection(obj._coord_names) - selected = obj._replace_vars_and_dims(variables, - coord_names=coord_names) + indexes = OrderedDict( + (k, v) for k, v in obj.indexes.items() if k not in indexers) + selected = self._replace_with_new_dims( + variables, coord_names, indexes=indexes) + # attach indexer as coordinate variables.update(indexers) # Extract coordinates from indexers - coord_vars = selected._get_indexers_coordinates(coords) + coord_vars, new_indexes = ( + selected._get_indexers_coords_and_indexes(coords)) variables.update(coord_vars) + indexes.update(new_indexes) coord_names = (set(variables) .intersection(obj._coord_names) .union(coord_vars)) - return obj._replace_vars_and_dims(variables, coord_names=coord_names) + return self._replace_with_new_dims( + variables, coord_names, indexes=indexes) def interp_like(self, other, method='linear', assume_sorted=False, kwargs={}): @@ -2084,6 +2184,46 @@ def interp_like(self, other, method='linear', assume_sorted=False, ds = self.reindex(object_coords) return ds.interp(numeric_coords, method, assume_sorted, kwargs) + # Helper methods for rename() + def _rename_vars(self, name_dict, dims_dict): + variables = OrderedDict() + coord_names = set() + for k, v in self.variables.items(): + name = name_dict.get(k, k) + dims = tuple(dims_dict.get(dim, dim) for dim in v.dims) + var = v.copy(deep=False) + var.dims = dims + if name in variables: + raise ValueError('the new name %r conflicts' % (name,)) + variables[name] = var + if k in self._coord_names: + coord_names.add(name) + return variables, coord_names + + def _rename_dims(self, dims_dict): + return {dims_dict.get(k, k): v for k, v in self.dims.items()} + + def _rename_indexes(self, name_dict): + if self._indexes is None: + return None + indexes = OrderedDict() + for k, v in self.indexes.items(): + new_name = name_dict.get(k, k) + if isinstance(v, pd.MultiIndex): + new_names = [name_dict.get(k, k) for k in v.names] + index = pd.MultiIndex(v.levels, v.labels, v.sortorder, + names=new_names, verify_integrity=False) + else: + index = pd.Index(v, name=new_name) + indexes[new_name] = index + return indexes + + def _rename_all(self, name_dict, dim_dict): + variables, coord_names = self._rename_vars(name_dict, dim_dict) + dims = self._rename_dims(dim_dict) + indexes = self._rename_indexes(name_dict) + return variables, coord_names, dims, indexes + def rename(self, name_dict=None, inplace=None, **names): """Returns a new object with renamed variables and dimensions. @@ -2109,6 +2249,7 @@ def rename(self, name_dict=None, inplace=None, **names): Dataset.swap_dims DataArray.rename """ + # TODO: add separate rename_vars and rename_dims methods. inplace = _check_inplace(inplace) name_dict = either_dict_or_kwargs(name_dict, names, 'rename') for k, v in name_dict.items(): @@ -2116,24 +2257,10 @@ def rename(self, name_dict=None, inplace=None, **names): raise ValueError("cannot rename %r because it is not a " "variable or dimension in this dataset" % k) - variables = OrderedDict() - coord_names = set() - for k, v in self._variables.items(): - name = name_dict.get(k, k) - dims = tuple(name_dict.get(dim, dim) for dim in v.dims) - var = v.copy(deep=False) - var.dims = dims - if name in variables: - raise ValueError('the new name %r conflicts' % (name,)) - variables[name] = var - if k in self._coord_names: - coord_names.add(name) - - dims = OrderedDict((name_dict.get(k, k), v) - for k, v in self.dims.items()) - - return self._replace_vars_and_dims(variables, coord_names, dims=dims, - inplace=inplace) + variables, coord_names, dims, indexes = self._rename_all( + name_dict=name_dict, dim_dict=name_dict) + return self._replace(variables, coord_names, dims=dims, + indexes=indexes, inplace=inplace) def swap_dims(self, dims_dict, inplace=None): """Returns a new object with swapped dimensions. @@ -2159,6 +2286,8 @@ def swap_dims(self, dims_dict, inplace=None): Dataset.rename DataArray.swap_dims """ + # TODO: deprecate this method in favor of a (less confusing) + # rename_dims() method that only renames dimensions. inplace = _check_inplace(inplace) for k, v in dims_dict.items(): if k not in self.dims: @@ -2171,11 +2300,10 @@ def swap_dims(self, dims_dict, inplace=None): result_dims = set(dims_dict.get(dim, dim) for dim in self.dims) - variables = OrderedDict() - coord_names = self._coord_names.copy() coord_names.update(dims_dict.values()) + variables = OrderedDict() for k, v in self.variables.items(): dims = tuple(dims_dict.get(dim, dim) for dim in v.dims) if k in result_dims: @@ -2185,8 +2313,17 @@ def swap_dims(self, dims_dict, inplace=None): var.dims = dims variables[k] = var - return self._replace_vars_and_dims(variables, coord_names, - inplace=inplace) + indexes = OrderedDict() + for k, v in self.indexes.items(): + if k in dims_dict: + new_name = dims_dict[k] + new_index = variables[k].to_index() + indexes[new_name] = new_index + else: + indexes[k] = v + + return self._replace_with_new_dims(variables, coord_names, + indexes=indexes, inplace=inplace) def expand_dims(self, dim, axis=None): """Return a new object with an additional axis (or axes) inserted at @@ -2270,7 +2407,11 @@ def expand_dims(self, dim, axis=None): # it will be promoted to a 1D coordinate with a single value. variables[k] = v.set_dims(k) - return self._replace_vars_and_dims(variables, self._coord_names) + new_dims = self._dims.copy() + for d in dim: + new_dims[d] = 1 + + return self._replace(variables, dims=new_dims) def set_index(self, indexes=None, append=False, inplace=None, **indexes_kwargs): diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index 330bdc19cfc..36c4090297d 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -302,7 +302,7 @@ def mean(array, axis=None, skipna=None, **kwargs): return _mean(array, axis=axis, skipna=skipna, **kwargs) -mean.numeric_only = True +mean.numeric_only = True # type: ignore def _nd_cum_func(cum_func, array, axis, **kwargs): diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py index c360a209c46..6d8b553036a 100644 --- a/xarray/core/indexes.py +++ b/xarray/core/indexes.py @@ -1,10 +1,14 @@ -from collections.abc import Mapping +import collections.abc from collections import OrderedDict +from typing import Any, Iterable, Mapping, Optional, Tuple, Union + +import pandas as pd from . import formatting +from .variable import Variable -class Indexes(Mapping): +class Indexes(collections.abc.Mapping): """Immutable proxy for Dataset or DataArrary indexes.""" def __init__(self, indexes): """Not for public consumption. @@ -32,7 +36,10 @@ def __repr__(self): return formatting.indexes_repr(self) -def default_indexes(coords, dims): +def default_indexes( + coords: Mapping[Any, Variable], + dims: Iterable, +) -> 'OrderedDict[Any, pd.Index]': """Default indexes for a Dataset/DataArray. Parameters @@ -44,8 +51,38 @@ def default_indexes(coords, dims): Returns ------- - Mapping[Any, pandas.Index] mapping indexing keys (levels/dimension names) - to indexes used for indexing along that dimension. + Mapping from indexing keys (levels/dimension names) to indexes used for + indexing along that dimension. """ return OrderedDict((key, coords[key].to_index()) for key in dims if key in coords) + + +def isel_variable_and_index( + variable: Variable, + index: pd.Index, + indexers: Mapping[Any, Union[slice, Variable]], +) -> Tuple[Variable, Optional[pd.Index]]: + """Index a Variable and pandas.Index together.""" + if not indexers: + # nothing to index + return variable.copy(deep=False), index + + if len(variable.dims) > 1: + raise NotImplementedError( + 'indexing multi-dimensional variable with indexes is not ' + 'supported yet') + + new_variable = variable.isel(indexers) + + if new_variable.ndim != 1: + # can't preserve a index if result is not 0D + return new_variable, None + + # we need to compute the new index + (dim,) = variable.dims + indexer = indexers[dim] + if isinstance(indexer, Variable): + indexer = indexer.data + new_index = index[indexer] + return new_variable, new_index diff --git a/xarray/core/merge.py b/xarray/core/merge.py index 7bbd14470f2..daf400765d5 100644 --- a/xarray/core/merge.py +++ b/xarray/core/merge.py @@ -175,8 +175,9 @@ def merge_variables( return merged -def expand_variable_dicts(list_of_variable_dicts): - # type: (List[Union[Dataset, Dict]]) -> List[Dict[Any, Variable]] +def expand_variable_dicts( + list_of_variable_dicts: 'List[Union[Dataset, OrderedDict]]', +) -> 'List[OrderedDict[Any, Variable]]': """Given a list of dicts with xarray object values, expand the values. Parameters @@ -201,22 +202,23 @@ def expand_variable_dicts(list_of_variable_dicts): for variables in list_of_variable_dicts: if isinstance(variables, Dataset): - sanitized_vars = variables.variables - else: - # append coords to var_dicts before appending sanitized_vars, - # because we want coords to appear first - sanitized_vars = OrderedDict() + var_dicts.append(variables.variables) + continue - for name, var in variables.items(): - if isinstance(var, DataArray): - # use private API for speed - coords = var._coords.copy() - # explicitly overwritten variables should take precedence - coords.pop(name, None) - var_dicts.append(coords) + # append coords to var_dicts before appending sanitized_vars, + # because we want coords to appear first + sanitized_vars = OrderedDict() # type: OrderedDict[Any, Variable] + + for name, var in variables.items(): + if isinstance(var, DataArray): + # use private API for speed + coords = var._coords.copy() + # explicitly overwritten variables should take precedence + coords.pop(name, None) + var_dicts.append(coords) - var = as_variable(var, name=name) - sanitized_vars[name] = var + var = as_variable(var, name=name) + sanitized_vars[name] = var var_dicts.append(sanitized_vars) @@ -526,7 +528,9 @@ def merge(objects, compat='no_conflicts', join='outer'): for obj in objects] variables, coord_names, dims = merge_core(dict_like_objects, compat, join) - merged = Dataset._construct_direct(variables, coord_names, dims) + # TODO: don't always recompute indexes + merged = Dataset._construct_direct( + variables, coord_names, dims, indexes=None) return merged diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 23ee9f24871..a35f8cf02f0 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -2,7 +2,7 @@ import itertools from collections import OrderedDict, defaultdict from datetime import timedelta -from typing import Tuple, Type +from typing import Tuple, Type, Union import numpy as np import pandas as pd @@ -38,7 +38,7 @@ class MissingDimensionsError(ValueError): # TODO: move this to an xarray.exceptions module? -def as_variable(obj, name=None): +def as_variable(obj, name=None) -> 'Union[Variable, IndexVariable]': """Convert an object into a Variable. Parameters diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 906ebb278cc..20872aa4088 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -683,7 +683,9 @@ def test_isel_fancy(self): da.isel(time=(('points',), [1, 2]), x=(('points',), [2, 2]), y=(('points',), [3, 4])) np.testing.assert_allclose( - da.isel_points(time=[1], x=[2], y=[4]).values.squeeze(), + da.isel(time=(('p',), [1]), + x=(('p',), [2]), + y=(('p',), [4])).values.squeeze(), np_array[1, 4, 2].squeeze()) da.isel(time=(('points', ), [1, 2])) y = [-1, 0] diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 05884bda4ba..463c6756268 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -1416,7 +1416,7 @@ def test_sel_fancy(self): assert_identical(actual['b'].drop('y'), idx_y['b']) with pytest.raises(KeyError): - data.sel_points(x=[2.5], y=[2.0], method='pad', tolerance=1e-3) + data.sel(x=[2.5], y=[2.0], method='pad', tolerance=1e-3) def test_sel_method(self): data = create_test_data() From 0c73a380745c4792ab440eb020f78f203897abe5 Mon Sep 17 00:00:00 2001 From: David Hoese Date: Wed, 6 Feb 2019 10:56:06 -0600 Subject: [PATCH 090/108] Fix CRS being WKT instead of PROJ.4 (#2715) * Fix CRS being WKT instead of PROJ.4 See https://github.com/mapbox/rasterio/blob/master/CHANGES.txt#L7 * Fix rasterio usage for older rasterio without to_proj4 Co-Authored-By: djhoese * Fix indentation on rasterio AttributeError check * Add CRS WKT fix to whats-new --- doc/whats-new.rst | 3 +++ xarray/backends/rasterio_.py | 5 ++++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 142ef3a2e51..fb738f04c6d 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -79,6 +79,9 @@ Bug fixes :py:class:`CFTimeIndex` now results in a :py:class:`pandas.TimedeltaIndex` instead of raising a ``TypeError`` (:issue:`2671`). By `Spencer Clark `_. +- Fix ``open_rasterio`` creating a WKT CRS instead of PROJ.4 with + ``rasterio`` 1.0.14+ (:issue:`2715`). + By `David Hoese Date: Wed, 6 Feb 2019 16:08:16 -0800 Subject: [PATCH 091/108] reintroduce pynio/rasterio/iris to py36 test env (#2738) * add h5netcdf+dask tests * pep8 * reactivate pynio/rasterio/iris in py36 test builds * revert changes to test_backends.py -- unrelated to this PR --- ci/requirements-py36.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index 7523b14608b..311e4a275a8 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -20,14 +20,14 @@ dependencies: - scipy - seaborn - toolz - # - rasterio # xref #2683 + - rasterio - bottleneck - zarr - pseudonetcdf>=3.0.1 - eccodes - cdms2 -# - pynio # xref #2683 -# - iris>=1.10 # xref #2683 + - pynio + - iris>=1.10 - pydap - lxml - pip: From 0dfc0e63650deb3da1fb1cba48cda88a704c2d60 Mon Sep 17 00:00:00 2001 From: jonmjoyce <45802786+jonmjoyce@users.noreply.github.com> Date: Wed, 6 Feb 2019 19:56:20 -0700 Subject: [PATCH 092/108] BUG: Pass kwargs to the FileManager for pynio engine (#2380) (#2732) * BUG: Pass kwargs to the FileManager for pynio engine (#2380) * TST: Added test for pynio kwargs passing (#2380) * Fixed formatting (#2380) --- doc/whats-new.rst | 3 +++ xarray/backends/pynio_.py | 4 ++-- xarray/tests/test_backends.py | 6 ++++++ 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index fb738f04c6d..3228744b199 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -79,6 +79,9 @@ Bug fixes :py:class:`CFTimeIndex` now results in a :py:class:`pandas.TimedeltaIndex` instead of raising a ``TypeError`` (:issue:`2671`). By `Spencer Clark `_. +- backend_kwargs are no longer ignored when using open_dataset with pynio engine + (:issue:'2380') + By 'Jonathan Joyce '_. - Fix ``open_rasterio`` creating a WKT CRS instead of PROJ.4 with ``rasterio`` 1.0.14+ (:issue:`2715`). By `David Hoese Date: Thu, 7 Feb 2019 10:30:00 -0800 Subject: [PATCH 093/108] remove references to cyordereddict (#2750) --- doc/installing.rst | 2 -- doc/whats-new.rst | 2 ++ xarray/util/print_versions.py | 1 - 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/installing.rst b/doc/installing.rst index 083ac6c450a..8054a601870 100644 --- a/doc/installing.rst +++ b/doc/installing.rst @@ -45,8 +45,6 @@ For accelerating xarray - `bottleneck `__: speeds up NaN-skipping and rolling window aggregations by a large factor (1.1 or later) -- `cyordereddict `__: speeds up most - internal operations with xarray data structures (for python versions < 3.5) For parallel computing ~~~~~~~~~~~~~~~~~~~~~~ diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 3228744b199..694b6b27ce8 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -28,6 +28,8 @@ Breaking changes `DataArray` are deprecated and will be removed in a future release. (:issue:`1188`) By `Maximilian Roos `_. +- `cyordereddict` is no longer used as an optional dependency (:issue:`2744`). + By `Joe Hamman `_. Enhancements ~~~~~~~~~~~~ diff --git a/xarray/util/print_versions.py b/xarray/util/print_versions.py index 87eb7399e69..cb624155634 100755 --- a/xarray/util/print_versions.py +++ b/xarray/util/print_versions.py @@ -102,7 +102,6 @@ def show_versions(as_json=False): ("cfgrib", lambda mod: mod.__version__), ("iris", lambda mod: mod.__version__), ("bottleneck", lambda mod: mod.__version__), - ("cyordereddict", lambda mod: mod.__version__), ("dask", lambda mod: mod.__version__), ("distributed", lambda mod: mod.__version__), ("matplotlib", lambda mod: mod.__version__), From 8a1a8a1f13462440543581cd12fb96f22f0748bc Mon Sep 17 00:00:00 2001 From: Julius Busecke Date: Thu, 7 Feb 2019 19:11:13 -0500 Subject: [PATCH 094/108] enable internal plotting with cftime datetime (#2665) enable internal plotting with cftime datetime --- ci/requirements-py37-windows.yml | 1 + ci/requirements-py37.yml | 1 + doc/installing.rst | 4 +- doc/plotting.rst | 9 +++- doc/time-series.rst | 31 +++++-------- doc/whats-new.rst | 6 ++- xarray/core/common.py | 2 +- xarray/plot/plot.py | 11 ----- xarray/plot/utils.py | 35 +++++++++++--- xarray/tests/__init__.py | 2 + xarray/tests/test_plot.py | 80 +++++++++++++++++++++++--------- xarray/util/print_versions.py | 1 + 12 files changed, 120 insertions(+), 63 deletions(-) diff --git a/ci/requirements-py37-windows.yml b/ci/requirements-py37-windows.yml index 24a7f556b2c..fb4b97cde7c 100644 --- a/ci/requirements-py37-windows.yml +++ b/ci/requirements-py37-windows.yml @@ -4,6 +4,7 @@ channels: dependencies: - python=3.7 - cftime + - nc-time-axis - dask - distributed - h5py diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 1a98e6b285c..4f4d2b1728b 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -4,6 +4,7 @@ channels: dependencies: - python=3.7 - cftime + - nc-time-axis - dask - distributed - h5py diff --git a/doc/installing.rst b/doc/installing.rst index 8054a601870..f624da18611 100644 --- a/doc/installing.rst +++ b/doc/installing.rst @@ -61,6 +61,8 @@ For plotting :ref:`plot-maps` - `seaborn `__: for better color palettes +- `nc-time-axis `__: for plotting + cftime.datetime objects (1.2.0 or later) Instructions @@ -109,4 +111,4 @@ To run these benchmark tests in a local machine, first install - `airspeed-velocity `__: a tool for benchmarking Python packages over their lifetime. and run -``asv run # this will install some conda environments in ./.asv/envs`` \ No newline at end of file +``asv run # this will install some conda environments in ./.asv/envs`` diff --git a/doc/plotting.rst b/doc/plotting.rst index 1cb7aebe96d..a705c683594 100644 --- a/doc/plotting.rst +++ b/doc/plotting.rst @@ -23,6 +23,11 @@ Matplotlib syntax and function names were copied as much as possible, which makes for an easy transition between the two. Matplotlib must be installed before xarray can plot. +To use xarray's plotting capabilities with time coordinates containing +``cftime.datetime`` objects +`nc-time-axis `_ v1.2.0 or later +needs to be installed. + For more extensive plotting applications consider the following projects: - `Seaborn `_: "provides @@ -226,7 +231,7 @@ Step plots ~~~~~~~~~~ As an alternative, also a step plot similar to matplotlib's ``plt.step`` can be -made using 1D data. +made using 1D data. .. ipython:: python @@ -248,7 +253,7 @@ when plotting data grouped with :py:func:`xarray.Dataset.groupby_bins`. plt.ylim(-20,30) @savefig plotting_example_step_groupby.png width=4in plt.title('Zonal mean temperature') - + In this case, the actual boundaries of the bins are used and the ``where`` argument is ignored. diff --git a/doc/time-series.rst b/doc/time-series.rst index b716d6cbc24..3249dad2ec6 100644 --- a/doc/time-series.rst +++ b/doc/time-series.rst @@ -74,7 +74,7 @@ will be used for indexing. :py:class:`~xarray.CFTimeIndex` enables a subset of the indexing functionality of a :py:class:`pandas.DatetimeIndex` and is only fully compatible with the standalone version of ``cftime`` (not the version packaged with earlier versions ``netCDF4``). See :ref:`CFTimeIndex` for more -information. +information. Datetime indexing ----------------- @@ -215,7 +215,7 @@ For more examples of using grouped operations on a time dimension, see .. _CFTimeIndex: - + Non-standard calendars and dates outside the Timestamp-valid range ------------------------------------------------------------------ @@ -224,14 +224,14 @@ Through the standalone ``cftime`` library and a custom subclass of functionality enabled through the standard :py:class:`pandas.DatetimeIndex` for dates from non-standard calendars commonly used in climate science or dates using a standard calendar, but outside the `Timestamp-valid range`_ -(approximately between years 1678 and 2262). +(approximately between years 1678 and 2262). .. note:: As of xarray version 0.11, by default, :py:class:`cftime.datetime` objects will be used to represent times (either in indexes, as a - :py:class:`~xarray.CFTimeIndex`, or in data arrays with dtype object) if - any of the following are true: + :py:class:`~xarray.CFTimeIndex`, or in data arrays with dtype object) if + any of the following are true: - The dates are from a non-standard calendar - Any dates are outside the Timestamp-valid range. @@ -252,7 +252,7 @@ coordinate with dates from a no-leap calendar and a dates = [DatetimeNoLeap(year, month, 1) for year, month in product(range(1, 3), range(1, 13))] da = xr.DataArray(np.arange(24), coords=[dates], dims=['time'], name='foo') - + xarray also includes a :py:func:`~xarray.cftime_range` function, which enables creating a :py:class:`~xarray.CFTimeIndex` with regularly-spaced dates. For instance, we can create the same dates and DataArray we created above using: @@ -261,12 +261,12 @@ instance, we can create the same dates and DataArray we created above using: dates = xr.cftime_range(start='0001', periods=24, freq='MS', calendar='noleap') da = xr.DataArray(np.arange(24), coords=[dates], dims=['time'], name='foo') - + For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: - `Partial datetime string indexing`_ using strictly `ISO 8601-format`_ partial datetime strings: - + .. ipython:: python da.sel(time='0001') @@ -274,7 +274,7 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: - Access of basic datetime components via the ``dt`` accessor (in this case just "year", "month", "day", "hour", "minute", "second", "microsecond", - "season", "dayofyear", and "dayofweek"): + "season", "dayofyear", and "dayofweek"): .. ipython:: python @@ -323,14 +323,7 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: da.resample(time='81T', closed='right', label='right', base=3).mean() .. note:: - - While much of the time series functionality that is possible for standard - dates has been implemented for dates from non-standard calendars, there are - still some remaining important features that have yet to be implemented, - for example: - - - Built-in plotting of data with :py:class:`cftime.datetime` coordinate axes - (:issue:`2164`). + For some use-cases it may still be useful to convert from a :py:class:`~xarray.CFTimeIndex` to a :py:class:`pandas.DatetimeIndex`, @@ -351,8 +344,8 @@ For data indexed by a :py:class:`~xarray.CFTimeIndex` xarray currently supports: do not depend on differences between dates (e.g. differentiation, interpolation, or upsampling with resample), as these could introduce subtle and silent errors due to the difference in calendar types between the dates - encoded in your data and the dates stored in memory. - + encoded in your data and the dates stored in memory. + .. _Timestamp-valid range: https://pandas.pydata.org/pandas-docs/stable/timeseries.html#timestamp-limitations .. _ISO 8601-format: https://en.wikipedia.org/wiki/ISO_8601 .. _partial datetime string indexing: https://pandas.pydata.org/pandas-docs/stable/timeseries.html#partial-string-indexing diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 694b6b27ce8..1b9ba5707e8 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -24,7 +24,7 @@ Breaking changes - Remove support for Python 2. This is the first version of xarray that is Python 3 only. (:issue:`1876`). By `Joe Hamman `_. -- The `compat` argument to `Dataset` and the `encoding` argument to +- The `compat` argument to `Dataset` and the `encoding` argument to `DataArray` are deprecated and will be removed in a future release. (:issue:`1188`) By `Maximilian Roos `_. @@ -34,6 +34,10 @@ Breaking changes Enhancements ~~~~~~~~~~~~ +- Internal plotting now supports ``cftime.datetime`` objects as time series. + (:issue:`2164`) + By `Julius Busecke `_ and + `Spencer Clark `_. - Add ``data=False`` option to ``to_dict()`` methods. (:issue:`2656`) By `Ryan Abernathey `_ - :py:meth:`~xarray.DataArray.coarsen` and diff --git a/xarray/core/common.py b/xarray/core/common.py index 30ea56f3496..2f32ca941be 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -713,7 +713,7 @@ def resample(self, indexer=None, skipna=None, closed=None, label=None, array([ 0. , 0.032258, 0.064516, ..., 10.935484, 10.967742, 11. ]) Coordinates: * time (time) datetime64[ns] 1999-12-15 1999-12-16 1999-12-17 ... - + Limit scope of upsampling method >>> da.resample(time='1D').nearest(tolerance='1D') diff --git a/xarray/plot/plot.py b/xarray/plot/plot.py index 5b60f8d73a1..8e2457603d6 100644 --- a/xarray/plot/plot.py +++ b/xarray/plot/plot.py @@ -10,8 +10,6 @@ import numpy as np import pandas as pd -from xarray.core.common import contains_cftime_datetimes - from .facetgrid import _easy_facetgrid from .utils import ( _add_colorbar, _ensure_plottable, _infer_interval_breaks, _infer_xy_labels, @@ -139,15 +137,6 @@ def plot(darray, row=None, col=None, col_wrap=None, ax=None, hue=None, """ darray = darray.squeeze() - if contains_cftime_datetimes(darray): - raise NotImplementedError( - 'Built-in plotting of arrays of cftime.datetime objects or arrays ' - 'indexed by cftime.datetime objects is currently not implemented ' - 'within xarray. A possible workaround is to use the ' - 'nc-time-axis package ' - '(https://github.com/SciTools/nc-time-axis) to convert the dates ' - 'to a plottable type and plot your data directly with matplotlib.') - plot_dims = set(darray.dims) plot_dims.discard(row) plot_dims.discard(col) diff --git a/xarray/plot/utils.py b/xarray/plot/utils.py index 6d812fbc2bc..21523ede4cd 100644 --- a/xarray/plot/utils.py +++ b/xarray/plot/utils.py @@ -10,6 +10,16 @@ from ..core.options import OPTIONS from ..core.utils import is_scalar +from distutils.version import LooseVersion + +try: + import nc_time_axis + if LooseVersion(nc_time_axis.__version__) < LooseVersion('1.2.0'): + nc_time_axis_available = False + else: + nc_time_axis_available = True +except ImportError: + nc_time_axis_available = False ROBUST_PERCENTILE = 2.0 @@ -471,16 +481,29 @@ def _ensure_plottable(*args): """ numpy_types = [np.floating, np.integer, np.timedelta64, np.datetime64] other_types = [datetime] - + try: + import cftime + cftime_datetime = [cftime.datetime] + except ImportError: + cftime_datetime = [] + other_types = other_types + cftime_datetime for x in args: if not (_valid_numpy_subdtype(np.array(x), numpy_types) or _valid_other_type(np.array(x), other_types)): raise TypeError('Plotting requires coordinates to be numeric ' - 'or dates of type np.datetime64 or ' - 'datetime.datetime or pd.Interval.') - - -def _ensure_numeric(arr): + 'or dates of type np.datetime64, ' + 'datetime.datetime, cftime.datetime or ' + 'pd.Interval.') + if (_valid_other_type(np.array(x), cftime_datetime) + and not nc_time_axis_available): + raise ImportError('Plotting of arrays of cftime.datetime ' + 'objects or arrays indexed by ' + 'cftime.datetime objects requires the ' + 'optional `nc-time-axis` (v1.2.0 or later) ' + 'package.') + + +def _numeric(arr): numpy_types = [np.floating, np.integer] return _valid_numpy_subdtype(arr, numpy_types) diff --git a/xarray/tests/__init__.py b/xarray/tests/__init__.py index a7eafa92bd7..281fc662197 100644 --- a/xarray/tests/__init__.py +++ b/xarray/tests/__init__.py @@ -63,6 +63,8 @@ def LooseVersion(vstring): has_pynio, requires_pynio = _importorskip('Nio') has_pseudonetcdf, requires_pseudonetcdf = _importorskip('PseudoNetCDF') has_cftime, requires_cftime = _importorskip('cftime') +has_nc_time_axis, requires_nc_time_axis = _importorskip('nc_time_axis', + minversion='1.2.0') has_cftime_1_0_2_1, requires_cftime_1_0_2_1 = _importorskip( 'cftime', minversion='1.0.2.1') has_dask, requires_dask = _importorskip('dask') diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py index 3b08ce706f5..c0e03b5791c 100644 --- a/xarray/tests/test_plot.py +++ b/xarray/tests/test_plot.py @@ -17,7 +17,9 @@ from . import ( assert_array_equal, assert_equal, raises_regex, requires_cftime, - requires_matplotlib, requires_matplotlib2, requires_seaborn) + requires_matplotlib, requires_matplotlib2, requires_seaborn, + requires_nc_time_axis) +from . import has_nc_time_axis # import mpl and change the backend before other mpl imports try: @@ -1828,6 +1830,61 @@ def test_datetime_line_plot(self): self.darray.plot.line() +@requires_nc_time_axis +@requires_cftime +class TestCFDatetimePlot(PlotTestCase): + @pytest.fixture(autouse=True) + def setUp(self): + ''' + Create a DataArray with a time-axis that contains cftime.datetime + objects. + ''' + # case for 1d array + data = np.random.rand(4, 12) + time = xr.cftime_range(start='2017', + periods=12, + freq='1M', + calendar='noleap') + darray = DataArray(data, dims=['x', 'time']) + darray.coords['time'] = time + + self.darray = darray + + def test_cfdatetime_line_plot(self): + self.darray.isel(x=0).plot.line() + + def test_cfdatetime_pcolormesh_plot(self): + self.darray.plot.pcolormesh() + + def test_cfdatetime_contour_plot(self): + self.darray.plot.contour() + + +@requires_cftime +@pytest.mark.skipif(has_nc_time_axis, reason='nc_time_axis is installed') +class TestNcAxisNotInstalled(PlotTestCase): + @pytest.fixture(autouse=True) + def setUp(self): + ''' + Create a DataArray with a time-axis that contains cftime.datetime + objects. + ''' + month = np.arange(1, 13, 1) + data = np.sin(2 * np.pi * month / 12.0) + darray = DataArray(data, dims=['time']) + darray.coords['time'] = xr.cftime_range(start='2017', + periods=12, + freq='1M', + calendar='noleap') + + self.darray = darray + + def test_ncaxis_notinstalled_line_plot(self): + with raises_regex(ImportError, + 'optional `nc-time-axis`'): + self.darray.plot.line() + + @requires_seaborn def test_import_seaborn_no_warning(): # GH1633 @@ -1844,27 +1901,6 @@ def test_plot_seaborn_no_import_warning(): assert len(record) == 0 -@requires_cftime -def test_plot_cftime_coordinate_error(): - cftime = _import_cftime() - time = cftime.num2date(np.arange(5), units='days since 0001-01-01', - calendar='noleap') - data = DataArray(np.arange(5), coords=[time], dims=['time']) - with raises_regex(TypeError, - 'requires coordinates to be numeric or dates'): - data.plot() - - -@requires_cftime -def test_plot_cftime_data_error(): - cftime = _import_cftime() - data = cftime.num2date(np.arange(5), units='days since 0001-01-01', - calendar='noleap') - data = DataArray(data, coords=[np.arange(5)], dims=['x']) - with raises_regex(NotImplementedError, 'cftime.datetime'): - data.plot() - - test_da_list = [DataArray(easy_array((10, ))), DataArray(easy_array((10, 3))), DataArray(easy_array((10, 3, 2)))] diff --git a/xarray/util/print_versions.py b/xarray/util/print_versions.py index cb624155634..50389df85cb 100755 --- a/xarray/util/print_versions.py +++ b/xarray/util/print_versions.py @@ -97,6 +97,7 @@ def show_versions(as_json=False): ("Nio", lambda mod: mod.__version__), ("zarr", lambda mod: mod.__version__), ("cftime", lambda mod: mod.__version__), + ("nc_time_axis", lambda mod: mod.__version__), ("PseudonetCDF", lambda mod: mod.__version__), ("rasterio", lambda mod: mod.__version__), ("cfgrib", lambda mod: mod.__version__), From 6d2076688d4f5466cf77ace2b196e910c1c0fbb8 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Thu, 7 Feb 2019 20:45:32 -0800 Subject: [PATCH 095/108] Fix mypy errors (#2753) Apparently I wasn't paying attention in my last PR :) --- ci/requirements-py36.yml | 2 +- xarray/core/alignment.py | 6 +++--- xarray/core/computation.py | 13 ++++++------- xarray/core/dataset.py | 31 +++++++++++++++++-------------- xarray/core/merge.py | 11 ++++++----- 5 files changed, 33 insertions(+), 30 deletions(-) diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index 311e4a275a8..7a3f0f53223 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -32,4 +32,4 @@ dependencies: - lxml - pip: - cfgrib>=0.9.2 - - mypy==0.650 + - mypy==0.660 diff --git a/xarray/core/alignment.py b/xarray/core/alignment.py index 7aaeff00b5e..71cdfdebb61 100644 --- a/xarray/core/alignment.py +++ b/xarray/core/alignment.py @@ -3,7 +3,7 @@ import warnings from collections import OrderedDict, defaultdict from contextlib import suppress -from typing import Any, Mapping, Optional +from typing import Any, Mapping, Optional, Tuple import numpy as np import pandas as pd @@ -317,7 +317,7 @@ def reindex_variables( # build up indexers for assignment along each dimension int_indexers = {} - targets = OrderedDict() + targets = OrderedDict() # type: OrderedDict[Any, pd.Index] masked_dims = set() unchanged_dims = set() @@ -357,7 +357,7 @@ def reindex_variables( 'the new index %r' % (dim, existing_size, new_size)) # create variables for the new dataset - reindexed = OrderedDict() + reindexed = OrderedDict() # type: OrderedDict[Any, Variable] for dim, indexer in indexers.items(): if isinstance(indexer, DataArray) and indexer.dims != (dim,): diff --git a/xarray/core/computation.py b/xarray/core/computation.py index b9303a5681d..811b216ee79 100644 --- a/xarray/core/computation.py +++ b/xarray/core/computation.py @@ -224,7 +224,7 @@ def apply_dataarray_ufunc(func, *args, **kwargs): def ordered_set_union(all_keys: List[Iterable]) -> Iterable: - result_dict = OrderedDict() + result_dict = OrderedDict() # type: OrderedDict[Any, None] for keys in all_keys: for key in keys: result_dict[key] = None @@ -284,11 +284,10 @@ def _as_variables_or_variable(arg): def _unpack_dict_tuples( - result_vars, # type: Mapping[Any, Tuple[Variable]] - num_outputs, # type: int -): - # type: (...) -> Tuple[Dict[Any, Variable], ...] - out = tuple(OrderedDict() for _ in range(num_outputs)) + result_vars: Mapping[Any, Tuple[Variable]], + num_outputs: int, +) -> 'Tuple[OrderedDict[Any, Variable], ...]': + out = tuple(OrderedDict() for _ in range(num_outputs)) # type: ignore for name, values in result_vars.items(): for value, results_dict in zip(values, out): results_dict[name] = value @@ -444,7 +443,7 @@ def unified_dim_sizes( exclude_dims: AbstractSet = frozenset(), ) -> 'OrderedDict[Any, int]': - dim_sizes = OrderedDict() + dim_sizes = OrderedDict() # type: OrderedDict[Any, int] for var in variables: if len(set(var.dims)) < len(var.dims): diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index d1323c171eb..636cff2c3ec 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -192,11 +192,11 @@ def merge_indexes( def split_indexes( - dims_or_levels, # type: Union[Any, List[Any]] - variables, # type: Dict[Any, Variable] - coord_names, # type: Set - level_coords, # type: Dict[Any, Any] - drop=False, # type: bool + dims_or_levels, # type: Union[Any, List[Any]] + variables, # type: OrderedDict[Any, Variable] + coord_names, # type: Set + level_coords, # type: Dict[Any, Any] + drop=False, # type: bool ): # type: (...) -> Tuple[OrderedDict[Any, Variable], Set] """Extract (multi-)indexes (levels) as variables. @@ -216,7 +216,7 @@ def split_indexes( dims.append(k) vars_to_replace = {} - vars_to_create = OrderedDict() + vars_to_create = OrderedDict() # type: OrderedDict[Any, Variable] vars_to_remove = [] for d in dims: @@ -696,11 +696,14 @@ def _from_vars_and_coord_names(cls, variables, coord_names, attrs=None): dims = dict(calculate_dimensions(variables)) return cls._construct_direct(variables, coord_names, dims, attrs) - def _replace( + # TODO(shoyer): renable type checking on this signature when pytype has a + # good way to handle defaulting arguments to a sentinel value: + # https://github.com/python/mypy/issues/1803 + def _replace( # type: ignore self: T, variables: 'OrderedDict[Any, Variable]' = None, coord_names: set = None, - dims: 'OrderedDict[Any, int]' = None, + dims: Dict[Any, int] = None, attrs: 'Optional[OrderedDict]' = __default, indexes: 'Optional[OrderedDict[Any, pd.Index]]' = __default, encoding: Optional[dict] = __default, @@ -745,7 +748,7 @@ def _replace( variables, coord_names, dims, attrs, indexes, encoding) return obj - def _replace_with_new_dims( + def _replace_with_new_dims( # type: ignore self: T, variables: 'OrderedDict[Any, Variable]' = None, coord_names: set = None, @@ -758,7 +761,7 @@ def _replace_with_new_dims( return self._replace( variables, coord_names, dims, attrs, indexes, inplace=inplace) - def _replace_vars_and_dims( + def _replace_vars_and_dims( # type: ignore self: T, variables: 'OrderedDict[Any, Variable]' = None, coord_names: set = None, @@ -931,7 +934,7 @@ def _copy_listed(self: T, names) -> T: """Create a new Dataset with the listed variables from this dataset and the all relevant coordinates. Skips all validation. """ - variables = OrderedDict() + variables = OrderedDict() # type: OrderedDict[Any, Variable] coord_names = set() for name in names: @@ -976,7 +979,7 @@ def _construct_dataarray(self, name) -> 'DataArray': needed_dims = set(variable.dims) - coords = OrderedDict() + coords = OrderedDict() # type: OrderedDict[Any, Variable] for k in self.coords: if set(self.variables[k].dims) <= needed_dims: coords[k] = self.variables[k] @@ -1823,12 +1826,12 @@ def relevant_keys(mapping): else: # dim is a string dim_name = dim - dim_coord = None + dim_coord = None # type: ignore reordered = self.transpose( *(list(indexer_dims) + list(non_indexed_dims))) - variables = OrderedDict() + variables = OrderedDict() # type: ignore for name, var in reordered.variables.items(): if name in indexers_dict or any( diff --git a/xarray/core/merge.py b/xarray/core/merge.py index daf400765d5..3039eecb2f8 100644 --- a/xarray/core/merge.py +++ b/xarray/core/merge.py @@ -22,13 +22,14 @@ 'no_conflicts': 4}) -def broadcast_dimension_size(variables): - # type: (List[Variable],) -> Variable +def broadcast_dimension_size( + variables: List[Variable], +) -> 'OrderedDict[Any, int]': """Extract dimension sizes from a dictionary of variables. Raises ValueError if any dimensions have different sizes. """ - dims = OrderedDict() + dims = OrderedDict() # type: OrderedDict[Any, int] for var in variables: for dim, size in zip(var.dims, var.shape): if dim in dims and size != dims[dim]: @@ -149,7 +150,7 @@ def merge_variables( # n.b. it's important to fill up merged in the original order in which # variables appear - merged = OrderedDict() + merged = OrderedDict() # type: OrderedDict[Any, Variable] for name, var_list in lookup.items(): if name in priority_vars: @@ -177,7 +178,7 @@ def merge_variables( def expand_variable_dicts( list_of_variable_dicts: 'List[Union[Dataset, OrderedDict]]', -) -> 'List[OrderedDict[Any, Variable]]': +) -> 'List[Mapping[Any, Variable]]': """Given a list of dicts with xarray object values, expand the values. Parameters From 4cd56a9edb083a3eb8d11e7a367dfb9bda76fc2e Mon Sep 17 00:00:00 2001 From: Keisuke Fujii Date: Mon, 11 Feb 2019 18:47:08 +0900 Subject: [PATCH 096/108] fix datetime_to_numeric and Variable._to_numeric (#2668) * WIP: fix regression about datetime_to_numeric * Workaround for object array * added a whatsnew * rearrange tests * lint * Added Variable._to_numeric * Fix for cftime * Update via comments * lint * Fix via comment * Fix errors * lint --- xarray/core/dataset.py | 12 ++++---- xarray/core/duck_array_ops.py | 43 +++++++++++++++++++++++++-- xarray/core/missing.py | 11 ++++--- xarray/core/utils.py | 34 --------------------- xarray/core/variable.py | 8 +++++ xarray/tests/test_dataset.py | 9 +++--- xarray/tests/test_duck_array_ops.py | 46 +++++++++++++++++++++++++++-- xarray/tests/test_interp.py | 13 ++++++++ xarray/tests/test_utils.py | 39 ------------------------ 9 files changed, 120 insertions(+), 95 deletions(-) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 636cff2c3ec..7bb085848ef 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -28,6 +28,7 @@ DatasetCoordinates, LevelCoordinatesSource, assert_coordinate_consistent, remap_label_indexers, ) +from .duck_array_ops import datetime_to_numeric from .indexes import Indexes, default_indexes, isel_variable_and_index from .merge import ( dataset_merge_method, dataset_update_method, merge_data_and_coords, @@ -35,9 +36,9 @@ from .options import OPTIONS, _get_keep_attrs from .pycompat import dask_array_type from .utils import ( - Frozen, SortedKeysDict, _check_inplace, datetime_to_numeric, - decode_numpy_dict_values, either_dict_or_kwargs, hashable, - maybe_wrap_array) + Frozen, SortedKeysDict, _check_inplace, + decode_numpy_dict_values, either_dict_or_kwargs, ensure_us_time_resolution, + hashable, maybe_wrap_array) from .variable import IndexVariable, Variable, as_variable, broadcast_variables if TYPE_CHECKING: from .dataarray import DataArray @@ -3997,15 +3998,14 @@ def differentiate(self, coord, edge_order=1, datetime_unit=None): datetime_unit, _ = np.datetime_data(coord_var.dtype) elif datetime_unit is None: datetime_unit = 's' # Default to seconds for cftime objects - coord_var = datetime_to_numeric( - coord_var, datetime_unit=datetime_unit) + coord_var = coord_var._to_numeric(datetime_unit=datetime_unit) variables = OrderedDict() for k, v in self.variables.items(): if (k in self.data_vars and dim in v.dims and k not in self.coords): if _contains_datetime_like_objects(v): - v = datetime_to_numeric(v, datetime_unit=datetime_unit) + v = v._to_numeric(datetime_unit=datetime_unit) grad = duck_array_ops.gradient( v.data, coord_var, edge_order=edge_order, axis=v.get_axis_num(dim)) diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index 36c4090297d..4d6d716a164 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -11,7 +11,7 @@ import numpy as np import pandas as pd -from . import dask_array_ops, dtypes, npcompat, nputils, utils +from . import dask_array_ops, dtypes, npcompat, nputils from .nputils import nanfirst, nanlast from .pycompat import dask_array_type @@ -289,14 +289,51 @@ def f(values, axis=None, skipna=None, **kwargs): _mean = _create_nan_agg_method('mean') +def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): + """Convert an array containing datetime-like data to an array of floats. + + Parameters + ---------- + da : array + Input data + offset: Scalar with the same type of array or None + If None, subtract minimum values to reduce round off error + datetime_unit: None or any of {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', + 'us', 'ns', 'ps', 'fs', 'as'} + dtype: target dtype + + Returns + ------- + array + """ + if offset is None: + offset = array.min() + array = array - offset + + if not hasattr(array, 'dtype'): # scalar is converted to 0d-array + array = np.array(array) + + if array.dtype.kind in 'O': + # possibly convert object array containing datetime.timedelta + array = np.asarray(pd.Series(array.ravel())).reshape(array.shape) + + if datetime_unit: + array = array / np.timedelta64(1, datetime_unit) + + # convert np.NaT to np.nan + if array.dtype.kind in 'mM': + return np.where(isnull(array), np.nan, array.astype(dtype)) + return array.astype(dtype) + + def mean(array, axis=None, skipna=None, **kwargs): """ inhouse mean that can handle datatime dtype """ array = asarray(array) - if array.dtype.kind == 'M': + if array.dtype.kind in 'Mm': offset = min(array) # xarray always uses datetime[ns] for datetime dtype = 'timedelta64[ns]' - return _mean(utils.datetime_to_numeric(array, offset), axis=axis, + return _mean(datetime_to_numeric(array, offset), axis=axis, skipna=skipna, **kwargs).astype(dtype) + offset else: return _mean(array, axis=axis, skipna=skipna, **kwargs) diff --git a/xarray/core/missing.py b/xarray/core/missing.py index 4c9435e0bf4..50c420206cd 100644 --- a/xarray/core/missing.py +++ b/xarray/core/missing.py @@ -9,8 +9,8 @@ from . import utils from .common import _contains_datetime_like_objects from .computation import apply_ufunc -from .duck_array_ops import dask_array_type -from .utils import OrderedSet, datetime_to_numeric, is_scalar +from .duck_array_ops import dask_array_type, datetime_to_numeric +from .utils import OrderedSet, is_scalar from .variable import Variable, broadcast_variables @@ -411,10 +411,9 @@ def _floatize_x(x, new_x): # We assume that the most of the bits are used to represent the # offset (min(x)) and the variation (x - min(x)) can be # represented by float. - xmin = x[i].min() - x[i] = datetime_to_numeric(x[i], offset=xmin, dtype=np.float64) - new_x[i] = datetime_to_numeric( - new_x[i], offset=xmin, dtype=np.float64) + xmin = x[i].values.min() + x[i] = x[i]._to_numeric(offset=xmin, dtype=np.float64) + new_x[i] = new_x[i]._to_numeric(offset=xmin, dtype=np.float64) return x, new_x diff --git a/xarray/core/utils.py b/xarray/core/utils.py index b8e818693c4..053a45f01cb 100644 --- a/xarray/core/utils.py +++ b/xarray/core/utils.py @@ -603,40 +603,6 @@ def __len__(self): return len(self._data) - num_hidden -def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): - """Convert an array containing datetime-like data to an array of floats. - - Parameters - ---------- - da : array - Input data - offset: Scalar with the same type of array or None - If None, subtract minimum values to reduce round off error - datetime_unit: None or any of {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', - 'us', 'ns', 'ps', 'fs', 'as'} - dtype: target dtype - - Returns - ------- - array - """ - from . import duck_array_ops - - if offset is None: - offset = array.min() - array = array - offset - - if datetime_unit: - array = array / np.timedelta64(1, datetime_unit) - # convert np.NaT to np.nan - if array.dtype.kind in 'mM': - if hasattr(array, 'isnull'): - return np.where(array.isnull(), np.nan, array.astype(dtype)) - return np.where(duck_array_ops.isnull(array), np.nan, - array.astype(dtype)) - return array - - def get_temp_dimname(dims, new_dim): """ Get an new dimension name based on new_dim, that is not used in dims. If the same name exists, we add an underscore(s) in the head. diff --git a/xarray/core/variable.py b/xarray/core/variable.py index a35f8cf02f0..85eab294619 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -1782,6 +1782,14 @@ def func(self, other): return self return func + def _to_numeric(self, offset=None, datetime_unit=None, dtype=float): + """ A (private) method to convert datetime array to numeric dtype + See duck_array_ops.datetime_to_numeric + """ + numeric_array = duck_array_ops.datetime_to_numeric( + self.data, offset, datetime_unit, dtype) + return type(self)(self.dims, numeric_array, self._attrs) + ops.inject_all_ops_and_reduce_methods(Variable) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 463c6756268..e4ffdad4260 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -16,7 +16,7 @@ ALL_DIMS, DataArray, Dataset, IndexVariable, MergeError, Variable, align, backends, broadcast, open_dataset, set_options) from xarray.core import dtypes, indexing, npcompat, utils -from xarray.core.common import full_like +from xarray.core.common import duck_array_ops, full_like from xarray.core.pycompat import integer_types from . import ( @@ -4676,7 +4676,7 @@ def test_differentiate_datetime(dask): actual = da.differentiate('x', edge_order=1, datetime_unit='D') expected_x = xr.DataArray( npcompat.gradient( - da, utils.datetime_to_numeric(da['x'], datetime_unit='D'), + da, da['x'].variable._to_numeric(datetime_unit='D'), axis=0, edge_order=1), dims=da.dims, coords=da.coords) assert_equal(expected_x, actual) @@ -4710,7 +4710,7 @@ def test_differentiate_cftime(dask): actual = da.differentiate('time', edge_order=1, datetime_unit='D') expected_data = npcompat.gradient( - da, utils.datetime_to_numeric(da['time'], datetime_unit='D'), + da, da['time'].variable._to_numeric(datetime_unit='D'), axis=0, edge_order=1) expected = xr.DataArray(expected_data, coords=da.coords, dims=da.dims) assert_equal(expected, actual) @@ -4789,7 +4789,8 @@ def test_trapz_datetime(dask, which_datetime): actual = da.integrate('time', datetime_unit='D') expected_data = np.trapz( - da, utils.datetime_to_numeric(da['time'], datetime_unit='D'), axis=0) + da, duck_array_ops.datetime_to_numeric(da['time'], datetime_unit='D'), + axis=0) expected = xr.DataArray( expected_data, dims=['y'], coords={k: v for k, v in da.coords.items() if 'time' not in v.dims}) diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index ba7f6ba5db8..ab3cafed449 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/xarray/tests/test_duck_array_ops.py @@ -7,16 +7,17 @@ import pytest from numpy import array, nan -from xarray import DataArray, Dataset, concat +from xarray import DataArray, Dataset, concat, cftime_range from xarray.core import dtypes, duck_array_ops from xarray.core.duck_array_ops import ( array_notnull_equiv, concatenate, count, first, gradient, last, mean, rolling_window, stack, where) from xarray.core.pycompat import dask_array_type -from xarray.testing import assert_allclose, assert_equal +from xarray.testing import assert_allclose, assert_equal, assert_identical from . import ( - assert_array_equal, has_dask, has_np113, raises_regex, requires_dask) + assert_array_equal, has_dask, has_np113, raises_regex, requires_cftime, + requires_dask) class TestOps(object): @@ -569,3 +570,42 @@ def test_docs(): indicated dimension(s) removed. """) assert actual == expected + + +def test_datetime_to_numeric_datetime64(): + times = pd.date_range('2000', periods=5, freq='7D').values + result = duck_array_ops.datetime_to_numeric(times, datetime_unit='h') + expected = 24 * np.arange(0, 35, 7) + np.testing.assert_array_equal(result, expected) + + offset = times[1] + result = duck_array_ops.datetime_to_numeric( + times, offset=offset, datetime_unit='h') + expected = 24 * np.arange(-7, 28, 7) + np.testing.assert_array_equal(result, expected) + + dtype = np.float32 + result = duck_array_ops.datetime_to_numeric( + times, datetime_unit='h', dtype=dtype) + expected = 24 * np.arange(0, 35, 7).astype(dtype) + np.testing.assert_array_equal(result, expected) + + +@requires_cftime +def test_datetime_to_numeric_cftime(): + times = cftime_range('2000', periods=5, freq='7D').values + result = duck_array_ops.datetime_to_numeric(times, datetime_unit='h') + expected = 24 * np.arange(0, 35, 7) + np.testing.assert_array_equal(result, expected) + + offset = times[1] + result = duck_array_ops.datetime_to_numeric( + times, offset=offset, datetime_unit='h') + expected = 24 * np.arange(-7, 28, 7) + np.testing.assert_array_equal(result, expected) + + dtype = np.float32 + result = duck_array_ops.datetime_to_numeric( + times, datetime_unit='h', dtype=dtype) + expected = 24 * np.arange(0, 35, 7).astype(dtype) + np.testing.assert_array_equal(result, expected) diff --git a/xarray/tests/test_interp.py b/xarray/tests/test_interp.py index d01929f163b..0d92f937821 100644 --- a/xarray/tests/test_interp.py +++ b/xarray/tests/test_interp.py @@ -571,3 +571,16 @@ def test_cftime_to_non_cftime_error(): with pytest.raises(TypeError): da.interp(time=0.5) + + +@requires_scipy +def test_datetime_interp_noerror(): + # GH:2667 + a = xr.DataArray( + np.arange(21).reshape(3, 7), dims=['x', 'time'], + coords={'x': [1, 2, 3], + 'time': pd.date_range('01-01-2001', periods=7, freq='D')}) + xi = xr.DataArray( + np.linspace(1, 3, 50), dims=['time'], + coords={'time': pd.date_range('01-01-2001', periods=50, freq='H')}) + a.interp(x=xi, time=xi.time) # should not raise an error diff --git a/xarray/tests/test_utils.py b/xarray/tests/test_utils.py index 09152bac284..e98ab5cde4c 100644 --- a/xarray/tests/test_utils.py +++ b/xarray/tests/test_utils.py @@ -279,42 +279,3 @@ def test_either_dict_or_kwargs(): with pytest.raises(ValueError, match=r'foo'): result = either_dict_or_kwargs(dict(a=1), dict(a=1), 'foo') - - -def test_datetime_to_numeric_datetime64(): - times = pd.date_range('2000', periods=5, freq='7D') - da = xr.DataArray(times, coords=[times], dims=['time']) - result = utils.datetime_to_numeric(da, datetime_unit='h') - expected = 24 * xr.DataArray(np.arange(0, 35, 7), coords=da.coords) - assert_identical(result, expected) - - offset = da.isel(time=1) - result = utils.datetime_to_numeric(da, offset=offset, datetime_unit='h') - expected = 24 * xr.DataArray(np.arange(-7, 28, 7), coords=da.coords) - assert_identical(result, expected) - - dtype = np.float32 - result = utils.datetime_to_numeric(da, datetime_unit='h', dtype=dtype) - expected = 24 * xr.DataArray( - np.arange(0, 35, 7), coords=da.coords).astype(dtype) - assert_identical(result, expected) - - -@requires_cftime -def test_datetime_to_numeric_cftime(): - times = xr.cftime_range('2000', periods=5, freq='7D') - da = xr.DataArray(times, coords=[times], dims=['time']) - result = utils.datetime_to_numeric(da, datetime_unit='h') - expected = 24 * xr.DataArray(np.arange(0, 35, 7), coords=da.coords) - assert_identical(result, expected) - - offset = da.isel(time=1) - result = utils.datetime_to_numeric(da, offset=offset, datetime_unit='h') - expected = 24 * xr.DataArray(np.arange(-7, 28, 7), coords=da.coords) - assert_identical(result, expected) - - dtype = np.float32 - result = utils.datetime_to_numeric(da, datetime_unit='h', dtype=dtype) - expected = 24 * xr.DataArray( - np.arange(0, 35, 7), coords=da.coords).astype(dtype) - assert_identical(result, expected) From 07cfc5a884fea41426761c634d74d2f5de53db86 Mon Sep 17 00:00:00 2001 From: Yohai Bar Sinai <6164157+yohai@users.noreply.github.com> Date: Mon, 11 Feb 2019 12:35:02 -0500 Subject: [PATCH 097/108] Fix name loss when masking (#2749) * fix renaming * formatting * added tests * shoyer's solution * what's new --- doc/whats-new.rst | 4 +++- xarray/core/computation.py | 9 +++++++-- xarray/tests/test_dataarray.py | 9 +++++++++ 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 1b9ba5707e8..1ccddfb2cd6 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -91,7 +91,9 @@ Bug fixes - Fix ``open_rasterio`` creating a WKT CRS instead of PROJ.4 with ``rasterio`` 1.0.14+ (:issue:`2715`). By `David Hoese `_. .. _whats-new.0.11.3: v0.11.3 (26 January 2019) diff --git a/xarray/core/computation.py b/xarray/core/computation.py index 811b216ee79..633e695694b 100644 --- a/xarray/core/computation.py +++ b/xarray/core/computation.py @@ -199,6 +199,7 @@ def apply_dataarray_ufunc(func, *args, **kwargs): signature = kwargs.pop('signature') join = kwargs.pop('join', 'inner') exclude_dims = kwargs.pop('exclude_dims', _DEFAULT_FROZEN_SET) + keep_attrs = kwargs.pop('keep_attrs', True) if kwargs: raise TypeError('apply_dataarray_ufunc() got unexpected keyword ' 'arguments: %s' % list(kwargs)) @@ -207,7 +208,10 @@ def apply_dataarray_ufunc(func, *args, **kwargs): args = deep_align(args, join=join, copy=False, exclude=exclude_dims, raise_on_invalid=False) - name = result_name(args) + if keep_attrs and hasattr(args[0], 'name'): + name = args[0].name + else: + name = result_name(args) result_coords = build_output_coords(args, signature, exclude_dims) data_vars = [getattr(a, 'variable', a) for a in args] @@ -985,7 +989,8 @@ def earth_mover_distance(first_samples, return apply_dataarray_ufunc(variables_ufunc, *args, signature=signature, join=join, - exclude_dims=exclude_dims) + exclude_dims=exclude_dims, + keep_attrs=keep_attrs) elif any(isinstance(a, Variable) for a in args): return variables_ufunc(*args) else: diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 20872aa4088..09c0f003888 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -3694,6 +3694,15 @@ def test_raise_no_warning_for_nan_in_binary_ops(): assert len(record) == 0 +def test_name_in_masking(): + name = 'RingoStarr' + da = xr.DataArray(range(10), coords=[('x', range(10))], name=name) + assert da.where(da > 5).name == name + assert da.where((da > 5).rename('YokoOno')).name == name + assert da.where(da > 5, drop=True).name == name + assert da.where((da > 5).rename('YokoOno'), drop=True).name == name + + class TestIrisConversion(object): @requires_iris def test_to_and_from_iris(self): From fd9b0b0f938ff7724a7e3d0a66df1c1a8cbc5e35 Mon Sep 17 00:00:00 2001 From: Joe Hamman Date: Mon, 11 Feb 2019 22:39:18 -0700 Subject: [PATCH 098/108] add h5netcdf+dask tests (#2737) * add h5netcdf+dask tests * pep8 * pass encoding through to _replace_vars_and_dims in ds.chunk() * lint * _kwargs=None in roundtrip methods --- xarray/tests/test_backends.py | 100 ++++++++++++++++++++++++++++++---- 1 file changed, 90 insertions(+), 10 deletions(-) diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index dac31b91a61..580cecb988b 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -171,8 +171,12 @@ def create_store(self): raise NotImplementedError @contextlib.contextmanager - def roundtrip(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): + if save_kwargs is None: + save_kwargs = {} + if open_kwargs is None: + open_kwargs = {} with create_tmp_file( allow_cleanup_failure=allow_cleanup_failure) as path: self.save(data, path, **save_kwargs) @@ -180,8 +184,12 @@ def roundtrip(self, data, save_kwargs={}, open_kwargs={}, yield ds @contextlib.contextmanager - def roundtrip_append(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip_append(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): + if save_kwargs is None: + save_kwargs = {} + if open_kwargs is None: + open_kwargs = {} with create_tmp_file( allow_cleanup_failure=allow_cleanup_failure) as path: for i, key in enumerate(data.variables): @@ -1194,6 +1202,17 @@ def test_read_variable_len_strings(self): with open_dataset(tmp_file, **kwargs) as actual: assert_identical(expected, actual) + def test_encoding_unlimited_dims(self): + ds = Dataset({'x': ('y', np.arange(10.0))}) + with self.roundtrip(ds, + save_kwargs=dict(unlimited_dims=['y'])) as actual: + assert actual.encoding['unlimited_dims'] == set('y') + assert_equal(ds, actual) + ds.encoding = {'unlimited_dims': ['y']} + with self.roundtrip(ds) as actual: + assert actual.encoding['unlimited_dims'] == set('y') + assert_equal(ds, actual) + @requires_netCDF4 class TestNetCDF4Data(NetCDF4Base): @@ -1276,12 +1295,17 @@ def test_autoclose_future_warning(self): @pytest.mark.filterwarnings('ignore:deallocating CachingFileManager') class TestNetCDF4ViaDaskData(TestNetCDF4Data): @contextlib.contextmanager - def roundtrip(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): + if open_kwargs is None: + open_kwargs = {} + if save_kwargs is None: + save_kwargs = {} + open_kwargs.setdefault('chunks', -1) with TestNetCDF4Data.roundtrip( self, data, save_kwargs, open_kwargs, allow_cleanup_failure) as ds: - yield ds.chunk() + yield ds def test_unsorted_index_raises(self): # Skip when using dask because dask rewrites indexers to getitem, @@ -1329,15 +1353,19 @@ def open(self, store_target, **kwargs): yield ds @contextlib.contextmanager - def roundtrip(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): + if save_kwargs is None: + save_kwargs = {} + if open_kwargs is None: + open_kwargs = {} with self.create_zarr_target() as store_target: self.save(data, store_target, **save_kwargs) with self.open(store_target, **open_kwargs) as ds: yield ds @contextlib.contextmanager - def roundtrip_append(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip_append(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): pytest.skip("zarr backend does not support appending") @@ -1618,8 +1646,12 @@ def create_store(self): yield backends.ScipyDataStore(fobj, 'w') @contextlib.contextmanager - def roundtrip(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): + if save_kwargs is None: + save_kwargs = {} + if open_kwargs is None: + open_kwargs = {} with create_tmp_file() as tmp_file: with open(tmp_file, 'wb') as f: self.save(data, f, **save_kwargs) @@ -1914,6 +1946,46 @@ def test_dump_encodings_h5py(self): assert actual.x.encoding['compression_opts'] is None +@requires_h5netcdf +@requires_dask +@pytest.mark.filterwarnings('ignore:deallocating CachingFileManager') +class TestH5NetCDFViaDaskData(TestH5NetCDFData): + + @contextlib.contextmanager + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, + allow_cleanup_failure=False): + if save_kwargs is None: + save_kwargs = {} + if open_kwargs is None: + open_kwargs = {} + open_kwargs.setdefault('chunks', -1) + with TestH5NetCDFData.roundtrip( + self, data, save_kwargs, open_kwargs, + allow_cleanup_failure) as ds: + yield ds + + def test_dataset_caching(self): + # caching behavior differs for dask + pass + + def test_write_inconsistent_chunks(self): + # Construct two variables with the same dimensions, but different + # chunk sizes. + x = da.zeros((100, 100), dtype='f4', chunks=(50, 100)) + x = DataArray(data=x, dims=('lat', 'lon'), name='x') + x.encoding['chunksizes'] = (50, 100) + x.encoding['original_shape'] = (100, 100) + y = da.ones((100, 100), dtype='f4', chunks=(100, 50)) + y = DataArray(data=y, dims=('lat', 'lon'), name='y') + y.encoding['chunksizes'] = (100, 50) + y.encoding['original_shape'] = (100, 100) + # Put them both into the same dataset + ds = Dataset({'x': x, 'y': y}) + with self.roundtrip(ds) as actual: + assert actual['x'].encoding['chunksizes'] == (50, 100) + assert actual['y'].encoding['chunksizes'] == (100, 50) + + @pytest.fixture(params=['scipy', 'netcdf4', 'h5netcdf', 'pynio']) def readengine(request): return request.param @@ -2098,7 +2170,7 @@ def create_store(self): yield Dataset() @contextlib.contextmanager - def roundtrip(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): yield data.chunk() @@ -2597,8 +2669,12 @@ def open(self, path, **kwargs): return open_dataset(path, engine='pseudonetcdf', **kwargs) @contextlib.contextmanager - def roundtrip(self, data, save_kwargs={}, open_kwargs={}, + def roundtrip(self, data, save_kwargs=None, open_kwargs=None, allow_cleanup_failure=False): + if save_kwargs is None: + save_kwargs = {} + if open_kwargs is None: + open_kwargs = {} with create_tmp_file( allow_cleanup_failure=allow_cleanup_failure) as path: self.save(data, path, **save_kwargs) @@ -2805,10 +2881,14 @@ def create_tmp_geotiff(nx=4, ny=3, nz=3, transform_args=[5000, 80000, 1000, 2000.], crs={'units': 'm', 'no_defs': True, 'ellps': 'WGS84', 'proj': 'utm', 'zone': 18}, - open_kwargs={}): + open_kwargs=None): # yields a temporary geotiff file and a corresponding expected DataArray import rasterio from rasterio.transform import from_origin + + if open_kwargs is None: + open_kwargs = {} + with create_tmp_file(suffix='.tif', allow_cleanup_failure=ON_WINDOWS) as tmp_file: # allow 2d or 3d shapes From 2089382ebe5828eeefe0590e28fd3a54156e69d0 Mon Sep 17 00:00:00 2001 From: Stephan Hoyer Date: Mon, 11 Feb 2019 21:39:36 -0800 Subject: [PATCH 099/108] Update computation.py to use Python 3 function signatures (#2756) * Update computation.py to use Python 3 function signatures This lets us remove lots of ugly explicit calls to ``kwargs.pop()``. * Lint / py35 fixup --- setup.cfg | 2 + xarray/core/computation.py | 213 ++++++++++++++++--------------------- 2 files changed, 94 insertions(+), 121 deletions(-) diff --git a/setup.cfg b/setup.cfg index c80ff300a60..18922b1647a 100644 --- a/setup.cfg +++ b/setup.cfg @@ -45,6 +45,8 @@ ignore_missing_imports = True ignore_missing_imports = True [mypy-Nio.*] ignore_missing_imports = True +[mypy-nc_time_axis.*] +ignore_missing_imports = True [mypy-numpy.*] ignore_missing_imports = True [mypy-netCDF4.*] diff --git a/xarray/core/computation.py b/xarray/core/computation.py index 633e695694b..f9fd9022de9 100644 --- a/xarray/core/computation.py +++ b/xarray/core/computation.py @@ -7,8 +7,8 @@ from collections import Counter, OrderedDict from distutils.version import LooseVersion from typing import ( - AbstractSet, Any, Dict, Iterable, List, Mapping, Union, Tuple, - TYPE_CHECKING, TypeVar + AbstractSet, Any, Callable, Iterable, List, Mapping, Optional, Sequence, + Tuple, TYPE_CHECKING, Union, ) import numpy as np @@ -190,20 +190,19 @@ def build_output_coords( return output_coords -def apply_dataarray_ufunc(func, *args, **kwargs): - """apply_dataarray_ufunc(func, *args, signature, join='inner', - exclude_dims=frozenset()) +def apply_dataarray_vfunc( + func, + *args, + signature, + join='inner', + exclude_dims=frozenset(), + keep_attrs=False +): + """Apply a variable level function over DataArray, Variable and/or ndarray + objects. """ from .dataarray import DataArray - signature = kwargs.pop('signature') - join = kwargs.pop('join', 'inner') - exclude_dims = kwargs.pop('exclude_dims', _DEFAULT_FROZEN_SET) - keep_attrs = kwargs.pop('keep_attrs', True) - if kwargs: - raise TypeError('apply_dataarray_ufunc() got unexpected keyword ' - 'arguments: %s' % list(kwargs)) - if len(args) > 1: args = deep_align(args, join=join, copy=False, exclude=exclude_dims, raise_on_invalid=False) @@ -261,15 +260,19 @@ def assert_and_return_exact_match(all_keys): } -def join_dict_keys(objects, how='inner'): - # type: (Iterable[Union[Mapping, Any]], str) -> Iterable +def join_dict_keys( + objects: Iterable[Union[Mapping, Any]], how: str = 'inner', +) -> Iterable: joiner = _JOINERS[how] all_keys = [obj.keys() for obj in objects if hasattr(obj, 'keys')] return joiner(all_keys) -def collect_dict_values(objects, keys, fill_value=None): - # type: (Iterable[Union[Mapping, Any]], Iterable, Any) -> List[list] +def collect_dict_values( + objects: Iterable[Union[Mapping, Any]], + keys: Iterable, + fill_value: object = None, +) -> List[list]: return [[obj.get(key, fill_value) if is_dict_like(obj) else obj @@ -298,17 +301,12 @@ def _unpack_dict_tuples( return out -def apply_dict_of_variables_ufunc(func, *args, **kwargs): - """apply_dict_of_variables_ufunc(func, *args, signature, join='inner', - fill_value=None): +def apply_dict_of_variables_vfunc( + func, *args, signature, join='inner', fill_value=None +): + """Apply a variable level function over dicts of DataArray, DataArray, + Variable and ndarray objects. """ - signature = kwargs.pop('signature') - join = kwargs.pop('join', 'inner') - fill_value = kwargs.pop('fill_value', None) - if kwargs: - raise TypeError('apply_dict_of_variables_ufunc() got unexpected ' - 'keyword arguments: %s' % list(kwargs)) - args = [_as_variables_or_variable(arg) for arg in args] names = join_dict_keys(args, how=join) grouped_by_name = collect_dict_values(args, names, fill_value) @@ -323,8 +321,10 @@ def apply_dict_of_variables_ufunc(func, *args, **kwargs): return result_vars -def _fast_dataset(variables, coord_variables): - # type: (OrderedDict[Any, Variable], Mapping[Any, Variable]) -> Dataset +def _fast_dataset( + variables: 'OrderedDict[Any, Variable]', + coord_variables: Mapping[Any, Variable], +) -> 'Dataset': """Create a dataset as quickly as possible. Beware: the `variables` OrderedDict is modified INPLACE. @@ -335,21 +335,20 @@ def _fast_dataset(variables, coord_variables): return Dataset._from_vars_and_coord_names(variables, coord_names) -def apply_dataset_ufunc(func, *args, **kwargs): - """apply_dataset_ufunc(func, *args, signature, join='inner', - dataset_join='inner', fill_value=None, - exclude_dims=frozenset(), keep_attrs=False): - - If dataset_join != 'inner', a non-default fill_value must be supplied - by the user. Otherwise a TypeError is raised. +def apply_dataset_vfunc( + func, + *args, + signature, + join='inner', + dataset_join='exact', + fill_value=_NO_FILL_VALUE, + exclude_dims=frozenset(), + keep_attrs=False +): + """Apply a variable level function over Dataset, dict of DataArray, + DataArray, Variable and/or ndarray objects. """ from .dataset import Dataset - signature = kwargs.pop('signature') - join = kwargs.pop('join', 'inner') - dataset_join = kwargs.pop('dataset_join', 'inner') - fill_value = kwargs.pop('fill_value', None) - exclude_dims = kwargs.pop('exclude_dims', _DEFAULT_FROZEN_SET) - keep_attrs = kwargs.pop('keep_attrs', False) first_obj = args[0] # we'll copy attrs from this in case keep_attrs=True if (dataset_join not in _JOINS_WITHOUT_FILL_VALUES and @@ -358,9 +357,6 @@ def apply_dataset_ufunc(func, *args, **kwargs): 'data variables with apply_ufunc, you must supply the ' 'dataset_fill_value argument.') - if kwargs: - raise TypeError('apply_dataset_ufunc() got unexpected keyword ' - 'arguments: %s' % list(kwargs)) if len(args) > 1: args = deep_align(args, join=join, copy=False, exclude=exclude_dims, raise_on_invalid=False) @@ -368,7 +364,7 @@ def apply_dataset_ufunc(func, *args, **kwargs): list_of_coords = build_output_coords(args, signature, exclude_dims) args = [getattr(arg, 'data_vars', arg) for arg in args] - result_vars = apply_dict_of_variables_ufunc( + result_vars = apply_dict_of_variables_vfunc( func, *args, signature=signature, join=dataset_join, fill_value=fill_value) @@ -402,7 +398,10 @@ def _iter_over_selections(obj, dim, values): yield obj_sel -def apply_groupby_ufunc(func, *args): +def apply_groupby_func(func, *args): + """Apply a dataset or datarray level function over GroupBy, Dataset, + DataArray, Variable and/or ndarray objects. + """ from .groupby import GroupBy, peek_at from .variable import Variable @@ -444,7 +443,7 @@ def apply_groupby_ufunc(func, *args): def unified_dim_sizes( variables: Iterable[Variable], - exclude_dims: AbstractSet = frozenset(), + exclude_dims: AbstractSet = frozenset() ) -> 'OrderedDict[Any, int]': dim_sizes = OrderedDict() # type: OrderedDict[Any, int] @@ -516,21 +515,20 @@ def broadcast_compat_data(variable, broadcast_dims, core_dims): return data -def apply_variable_ufunc(func, *args, **kwargs): - """apply_variable_ufunc(func, *args, signature, exclude_dims=frozenset()) +def apply_variable_ufunc( + func, + *args, + signature, + exclude_dims=frozenset(), + dask='forbidden', + output_dtypes=None, + output_sizes=None, + keep_attrs=False +): + """Apply a ndarray level function over Variable and/or ndarray objects. """ from .variable import Variable, as_compatible_data - signature = kwargs.pop('signature') - exclude_dims = kwargs.pop('exclude_dims', _DEFAULT_FROZEN_SET) - dask = kwargs.pop('dask', 'forbidden') - output_dtypes = kwargs.pop('output_dtypes', None) - output_sizes = kwargs.pop('output_sizes', None) - keep_attrs = kwargs.pop('keep_attrs', False) - if kwargs: - raise TypeError('apply_variable_ufunc() got unexpected keyword ' - 'arguments: %s' % list(kwargs)) - dim_sizes = unified_dim_sizes((a for a in args if hasattr(a, 'dims')), exclude_dims=exclude_dims) broadcast_dims = tuple(dim for dim in dim_sizes @@ -661,14 +659,8 @@ def _apply_with_dask_atop(func, args, input_dims, output_dims, signature, new_axes=output_sizes) -def apply_array_ufunc(func, *args, **kwargs): - """apply_array_ufunc(func, *args, dask='forbidden') - """ - dask = kwargs.pop('dask', 'forbidden') - if kwargs: - raise TypeError('apply_array_ufunc() got unexpected keyword ' - 'arguments: %s' % list(kwargs)) - +def apply_array_ufunc(func, *args, dask='forbidden'): + """Apply a ndarray level function over ndarray objects.""" if any(isinstance(arg, dask_array_type) for arg in args): if dask == 'forbidden': raise ValueError('apply_ufunc encountered a dask array on an ' @@ -687,23 +679,23 @@ def apply_array_ufunc(func, *args, **kwargs): return func(*args) -def apply_ufunc(func, *args, **kwargs): - """apply_ufunc(func : Callable, - *args : Any, - input_core_dims : Optional[Sequence[Sequence]] = None, - output_core_dims : Optional[Sequence[Sequence]] = ((),), - exclude_dims : Collection = frozenset(), - vectorize : bool = False, - join : str = 'exact', - dataset_join : str = 'exact', - dataset_fill_value : Any = _NO_FILL_VALUE, - keep_attrs : bool = False, - kwargs : Mapping = None, - dask : str = 'forbidden', - output_dtypes : Optional[Sequence] = None, - output_sizes : Optional[Mapping[Any, int]] = None) - - Apply a vectorized function for unlabeled arrays on xarray objects. +def apply_ufunc( + func: Callable, + *args: Any, + input_core_dims: Optional[Sequence[Sequence]] = None, + output_core_dims: Optional[Sequence[Sequence]] = ((),), + exclude_dims: AbstractSet = frozenset(), + vectorize: bool = False, + join: str = 'exact', + dataset_join: str = 'exact', + dataset_fill_value: object = _NO_FILL_VALUE, + keep_attrs: bool = False, + kwargs: Mapping = None, + dask: str = 'forbidden', + output_dtypes: Optional[Sequence] = None, + output_sizes: Optional[Mapping[Any, int]] = None +) -> Any: + """Apply a vectorized function for unlabeled arrays on xarray objects. The function will be mapped over the data variable(s) of the input arguments using xarray's standard rules for labeled computation, including @@ -907,22 +899,6 @@ def earth_mover_distance(first_samples, from .dataarray import DataArray from .variable import Variable - input_core_dims = kwargs.pop('input_core_dims', None) - output_core_dims = kwargs.pop('output_core_dims', ((),)) - vectorize = kwargs.pop('vectorize', False) - join = kwargs.pop('join', 'exact') - dataset_join = kwargs.pop('dataset_join', 'exact') - keep_attrs = kwargs.pop('keep_attrs', False) - exclude_dims = kwargs.pop('exclude_dims', frozenset()) - dataset_fill_value = kwargs.pop('dataset_fill_value', _NO_FILL_VALUE) - kwargs_ = kwargs.pop('kwargs', None) - dask = kwargs.pop('dask', 'forbidden') - output_dtypes = kwargs.pop('output_dtypes', None) - output_sizes = kwargs.pop('output_sizes', None) - if kwargs: - raise TypeError('apply_ufunc() got unexpected keyword arguments: %s' - % list(kwargs)) - if input_core_dims is None: input_core_dims = ((),) * (len(args)) elif len(input_core_dims) != len(args): @@ -931,14 +907,17 @@ def earth_mover_distance(first_samples, 'the number of arguments. Given input_core_dims: {}, ' 'number of args: {}.'.format(input_core_dims, len(args))) + if kwargs is None: + kwargs = {} + signature = _UFuncSignature(input_core_dims, output_core_dims) if exclude_dims and not exclude_dims <= signature.all_core_dims: raise ValueError('each dimension in `exclude_dims` must also be a ' 'core dimension in the function signature') - if kwargs_: - func = functools.partial(func, **kwargs_) + if kwargs: + func = functools.partial(func, **kwargs) if vectorize: if signature.all_core_dims: @@ -950,14 +929,11 @@ def earth_mover_distance(first_samples, 'dimensions.') func = np.vectorize(func, otypes=output_dtypes, - signature=signature.to_gufunc_string(), - excluded=set(kwargs)) + signature=signature.to_gufunc_string()) else: - func = np.vectorize(func, - otypes=output_dtypes, - excluded=set(kwargs)) + func = np.vectorize(func, otypes=output_dtypes) - variables_ufunc = functools.partial(apply_variable_ufunc, func, + variables_vfunc = functools.partial(apply_variable_ufunc, func, signature=signature, exclude_dims=exclude_dims, keep_attrs=keep_attrs, @@ -966,7 +942,6 @@ def earth_mover_distance(first_samples, output_sizes=output_sizes) if any(isinstance(a, GroupBy) for a in args): - # kwargs has already been added into func this_apply = functools.partial(apply_ufunc, func, input_core_dims=input_core_dims, output_core_dims=output_core_dims, @@ -976,31 +951,29 @@ def earth_mover_distance(first_samples, dataset_fill_value=dataset_fill_value, keep_attrs=keep_attrs, dask=dask) - return apply_groupby_ufunc(this_apply, *args) + return apply_groupby_func(this_apply, *args) elif any(is_dict_like(a) for a in args): - return apply_dataset_ufunc(variables_ufunc, *args, + return apply_dataset_vfunc(variables_vfunc, *args, signature=signature, join=join, exclude_dims=exclude_dims, - fill_value=dataset_fill_value, dataset_join=dataset_join, + fill_value=dataset_fill_value, keep_attrs=keep_attrs) elif any(isinstance(a, DataArray) for a in args): - return apply_dataarray_ufunc(variables_ufunc, *args, + return apply_dataarray_vfunc(variables_vfunc, *args, signature=signature, join=join, exclude_dims=exclude_dims, keep_attrs=keep_attrs) elif any(isinstance(a, Variable) for a in args): - return variables_ufunc(*args) + return variables_vfunc(*args) else: return apply_array_ufunc(func, *args, dask=dask) -def dot(*arrays, **kwargs): - """ dot(*arrays, dims=None) - - Generalized dot product for xarray objects. Like np.einsum, but +def dot(*arrays, dims=None, **kwargs): + """Generalized dot product for xarray objects. Like np.einsum, but provides a simpler interface based on array dimensions. Parameters @@ -1036,8 +1009,6 @@ def dot(*arrays, **kwargs): from .dataarray import DataArray from .variable import Variable - dims = kwargs.pop('dims', None) - if any(not isinstance(arr, (Variable, DataArray)) for arr in arrays): raise TypeError('Only xr.DataArray and xr.Variable are supported.' 'Given {}.'.format([type(arr) for arr in arrays])) From 17fa64f5314aa898f262a73fdc00d228ec380968 Mon Sep 17 00:00:00 2001 From: Yohai Bar Sinai <6164157+yohai@users.noreply.github.com> Date: Tue, 12 Feb 2019 12:41:53 -0500 Subject: [PATCH 100/108] typo in whats_new (#2763) --- doc/whats-new.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 1ccddfb2cd6..b4097405c0a 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -90,7 +90,7 @@ Bug fixes By 'Jonathan Joyce '_. - Fix ``open_rasterio`` creating a WKT CRS instead of PROJ.4 with ``rasterio`` 1.0.14+ (:issue:`2715`). - By `David Hoese `_. - Masking data arrays with :py:meth:`xarray.DataArray.where` now returns an array with the name of the original masked array (:issue:`2748` and :issue:`2457`). By `Yohai Bar-Sinai `_. From cd8e370e63f82deeaf4fc190f5c1d90463067368 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Fri, 15 Feb 2019 16:58:15 -0500 Subject: [PATCH 101/108] 'standard' now refers to 'gregorian' in cftime_range (#2771) --- doc/whats-new.rst | 6 ++++++ xarray/coding/cftime_offsets.py | 6 +++--- xarray/tests/test_cftime_offsets.py | 6 ++++++ xarray/tests/test_interp.py | 6 ++++-- 4 files changed, 19 insertions(+), 5 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index b4097405c0a..01cdca7aecf 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -94,6 +94,12 @@ Bug fixes - Masking data arrays with :py:meth:`xarray.DataArray.where` now returns an array with the name of the original masked array (:issue:`2748` and :issue:`2457`). By `Yohai Bar-Sinai `_. +- Per `CF conventions + `_, + specifying ``'standard'`` as the calendar type in + :py:meth:`~xarray.cftime_range` now correctly refers to the ``'gregorian'`` + calendar instead of the ``'proleptic_gregorian'`` calendar (:issue:`2761`). + .. _whats-new.0.11.3: v0.11.3 (26 January 2019) diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index d21139995dd..4b5770ac90a 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -68,7 +68,7 @@ def get_date_type(calendar): 'proleptic_gregorian': cftime.DatetimeProlepticGregorian, 'julian': cftime.DatetimeJulian, 'all_leap': cftime.DatetimeAllLeap, - 'standard': cftime.DatetimeProlepticGregorian + 'standard': cftime.DatetimeGregorian } return calendars[calendar] @@ -679,9 +679,9 @@ def cftime_range(start=None, end=None, periods=None, freq='D', +--------------------------------+---------------------------------------+ | Alias | Date type | +================================+=======================================+ - | standard, proleptic_gregorian | ``cftime.DatetimeProlepticGregorian`` | + | standard, gregorian | ``cftime.DatetimeGregorian`` | +--------------------------------+---------------------------------------+ - | gregorian | ``cftime.DatetimeGregorian`` | + | proleptic_gregorian | ``cftime.DatetimeProlepticGregorian`` | +--------------------------------+---------------------------------------+ | noleap, 365_day | ``cftime.DatetimeNoLeap`` | +--------------------------------+---------------------------------------+ diff --git a/xarray/tests/test_cftime_offsets.py b/xarray/tests/test_cftime_offsets.py index b9d2cf520a8..29caa88cc53 100644 --- a/xarray/tests/test_cftime_offsets.py +++ b/xarray/tests/test_cftime_offsets.py @@ -814,3 +814,9 @@ def test_dayofyear_after_cftime_range(freq): result = cftime_range('2000-02-01', periods=3, freq=freq).dayofyear expected = pd.date_range('2000-02-01', periods=3, freq=freq).dayofyear np.testing.assert_array_equal(result, expected) + + +def test_cftime_range_standard_calendar_refers_to_gregorian(): + from cftime import DatetimeGregorian + result, = cftime_range('2000', periods=1) + assert isinstance(result, DatetimeGregorian) diff --git a/xarray/tests/test_interp.py b/xarray/tests/test_interp.py index 0d92f937821..5596bfb3bfb 100644 --- a/xarray/tests/test_interp.py +++ b/xarray/tests/test_interp.py @@ -523,7 +523,8 @@ def test_cftime_type_error(): def test_cftime_list_of_strings(): from cftime import DatetimeProlepticGregorian - times = xr.cftime_range('2000', periods=24, freq='D') + times = xr.cftime_range('2000', periods=24, freq='D', + calendar='proleptic_gregorian') da = xr.DataArray(np.arange(24), coords=[times], dims='time') times_new = ['2000-01-01T12:00', '2000-01-02T12:00', '2000-01-03T12:00'] @@ -542,7 +543,8 @@ def test_cftime_list_of_strings(): def test_cftime_single_string(): from cftime import DatetimeProlepticGregorian - times = xr.cftime_range('2000', periods=24, freq='D') + times = xr.cftime_range('2000', periods=24, freq='D', + calendar='proleptic_gregorian') da = xr.DataArray(np.arange(24), coords=[times], dims='time') times_new = '2000-01-01T12:00' From 57cd76d7521526a39a6e94eeacf1e40ef7b974b6 Mon Sep 17 00:00:00 2001 From: Tom Nicholas <35968931+TomNicholas@users.noreply.github.com> Date: Tue, 19 Feb 2019 06:12:59 +0000 Subject: [PATCH 102/108] Bugfix/reduce no axis (#2769) * New test for reduce func which takes no axes * Fixed axis logic * Recorded fix in what's new * Added intermediate variable --- doc/whats-new.rst | 4 ++++ xarray/core/variable.py | 7 +++++-- xarray/tests/test_dataset.py | 21 +++++++++++++++++++-- 3 files changed, 28 insertions(+), 4 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 01cdca7aecf..fb9d9dfa910 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -94,6 +94,10 @@ Bug fixes - Masking data arrays with :py:meth:`xarray.DataArray.where` now returns an array with the name of the original masked array (:issue:`2748` and :issue:`2457`). By `Yohai Bar-Sinai `_. +- Fixed error when trying to reduce a DataArray using a function which does not + require an axis argument. (:issue:`2768`) + By `Tom Nicholas `_. + - Per `CF conventions `_, specifying ``'standard'`` as the calendar type in diff --git a/xarray/core/variable.py b/xarray/core/variable.py index 85eab294619..b675317d83d 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -1361,8 +1361,11 @@ def reduce(self, func, dim=None, axis=None, if dim is not None: axis = self.get_axis_num(dim) - data = func(self.data if allow_lazy else self.values, - axis=axis, **kwargs) + input_data = self.data if allow_lazy else self.values + if axis is not None: + data = func(input_data, axis=axis, **kwargs) + else: + data = func(input_data, **kwargs) if getattr(data, 'shape', ()) == self.shape: dims = self.dims diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index e4ffdad4260..c26968b1db0 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -3633,11 +3633,28 @@ def mean_only_one_axis(x, axis): actual = ds.reduce(mean_only_one_axis, 'y') assert_identical(expected, actual) - with raises_regex(TypeError, 'non-integer axis'): + with raises_regex(TypeError, "missing 1 required positional argument: " + "'axis'"): ds.reduce(mean_only_one_axis) with raises_regex(TypeError, 'non-integer axis'): - ds.reduce(mean_only_one_axis, ['x', 'y']) + ds.reduce(mean_only_one_axis, axis=['x', 'y']) + + def test_reduce_no_axis(self): + + def total_sum(x): + return np.sum(x.flatten()) + + ds = Dataset({'a': (['x', 'y'], [[0, 1, 2, 3, 4]])}) + expected = Dataset({'a': ((), 10)}) + actual = ds.reduce(total_sum) + assert_identical(expected, actual) + + with raises_regex(TypeError, "unexpected keyword argument 'axis'"): + ds.reduce(total_sum, axis=0) + + with raises_regex(TypeError, "unexpected keyword argument 'axis'"): + ds.reduce(total_sum, dim='x') def test_quantile(self): From 612d390f925e5490314c363e5e368b2a8bd5daf0 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Tue, 19 Feb 2019 15:47:26 -0500 Subject: [PATCH 103/108] Add use_cftime option to open_dataset (#2759) * Add use_cftime option to open_dataset * Remove f-strings * Fix test-skipping logic and remove 'dummy' from warning * Note that use_cftime is only relevant for standard calendar dates * Move use_cftime option to CFDatetimeCoder constructor --- doc/whats-new.rst | 10 +- xarray/backends/api.py | 32 +++++- xarray/coding/times.py | 138 ++++++++++++----------- xarray/conventions.py | 34 +++++- xarray/tests/test_backends.py | 176 ++++++++++++++++++++++++++++++ xarray/tests/test_coding_times.py | 105 +++++++++++++++++- 6 files changed, 420 insertions(+), 75 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index fb9d9dfa910..9ac671d5858 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -68,7 +68,15 @@ Enhancements - :py:meth:`pandas.Series.dropna` is now supported for a :py:class:`pandas.Series` indexed by a :py:class:`~xarray.CFTimeIndex` (:issue:`2688`). By `Spencer Clark `_. - +- :py:meth:`~xarray.open_dataset` now accepts a ``use_cftime`` argument, which + can be used to require that ``cftime.datetime`` objects are always used, or + never used when decoding dates encoded with a standard calendar. This can be + used to ensure consistent date types are returned when using + :py:meth:`~xarray.open_mfdataset` (:issue:`1263`) and/or to silence + serialization warnings raised if dates from a standard calendar are found to + be outside the :py:class:`pandas.Timestamp`-valid range (:issue:`2754`). By + `Spencer Clark `_. + Bug fixes ~~~~~~~~~ diff --git a/xarray/backends/api.py b/xarray/backends/api.py index e52f47a0841..61efcfdedf2 100644 --- a/xarray/backends/api.py +++ b/xarray/backends/api.py @@ -161,7 +161,7 @@ def open_dataset(filename_or_obj, group=None, decode_cf=True, mask_and_scale=None, decode_times=True, autoclose=None, concat_characters=True, decode_coords=True, engine=None, chunks=None, lock=None, cache=None, drop_variables=None, - backend_kwargs=None): + backend_kwargs=None, use_cftime=None): """Load and decode a dataset from a file or file-like object. Parameters @@ -231,6 +231,16 @@ def open_dataset(filename_or_obj, group=None, decode_cf=True, A dictionary of keyword arguments to pass on to the backend. This may be useful when backend options would improve performance or allow user control of dataset processing. + use_cftime: bool, optional + Only relevant if encoded dates come from a standard calendar + (e.g. 'gregorian', 'proleptic_gregorian', 'standard', or not + specified). If None (default), attempt to decode times to + ``np.datetime64[ns]`` objects; if this is not possible, decode times to + ``cftime.datetime`` objects. If True, always decode times to + ``cftime.datetime`` objects, regardless of whether or not they can be + represented using ``np.datetime64[ns]`` objects. If False, always + decode times to ``np.datetime64[ns]`` objects; if this is not possible + raise an error. Returns ------- @@ -269,7 +279,7 @@ def maybe_decode_store(store, lock=False): ds = conventions.decode_cf( store, mask_and_scale=mask_and_scale, decode_times=decode_times, concat_characters=concat_characters, decode_coords=decode_coords, - drop_variables=drop_variables) + drop_variables=drop_variables, use_cftime=use_cftime) _protect_dataset_variables_inplace(ds, cache) @@ -284,7 +294,8 @@ def maybe_decode_store(store, lock=False): mtime = None token = tokenize(filename_or_obj, mtime, group, decode_cf, mask_and_scale, decode_times, concat_characters, - decode_coords, engine, chunks, drop_variables) + decode_coords, engine, chunks, drop_variables, + use_cftime) name_prefix = 'open_dataset-%s' % token ds2 = ds.chunk(chunks, name_prefix=name_prefix, token=token) ds2._file_obj = ds._file_obj @@ -360,7 +371,7 @@ def open_dataarray(filename_or_obj, group=None, decode_cf=True, mask_and_scale=None, decode_times=True, autoclose=None, concat_characters=True, decode_coords=True, engine=None, chunks=None, lock=None, cache=None, drop_variables=None, - backend_kwargs=None): + backend_kwargs=None, use_cftime=None): """Open an DataArray from a netCDF file containing a single data variable. This is designed to read netCDF files with only one data variable. If @@ -428,6 +439,16 @@ def open_dataarray(filename_or_obj, group=None, decode_cf=True, A dictionary of keyword arguments to pass on to the backend. This may be useful when backend options would improve performance or allow user control of dataset processing. + use_cftime: bool, optional + Only relevant if encoded dates come from a standard calendar + (e.g. 'gregorian', 'proleptic_gregorian', 'standard', or not + specified). If None (default), attempt to decode times to + ``np.datetime64[ns]`` objects; if this is not possible, decode times to + ``cftime.datetime`` objects. If True, always decode times to + ``cftime.datetime`` objects, regardless of whether or not they can be + represented using ``np.datetime64[ns]`` objects. If False, always + decode times to ``np.datetime64[ns]`` objects; if this is not possible + raise an error. Notes ----- @@ -450,7 +471,8 @@ def open_dataarray(filename_or_obj, group=None, decode_cf=True, decode_coords=decode_coords, engine=engine, chunks=chunks, lock=lock, cache=cache, drop_variables=drop_variables, - backend_kwargs=backend_kwargs) + backend_kwargs=backend_kwargs, + use_cftime=use_cftime) if len(dataset.data_vars) != 1: raise ValueError('Given file dataset contains more than one data ' diff --git a/xarray/coding/times.py b/xarray/coding/times.py index 459e9e0956d..02303a3edc3 100644 --- a/xarray/coding/times.py +++ b/xarray/coding/times.py @@ -80,32 +80,7 @@ def _unpack_netcdf_time_units(units): return delta_units, ref_date -def _decode_datetime_with_cftime(num_dates, units, calendar): - cftime = _import_cftime() - - if cftime.__name__ == 'cftime': - dates = np.asarray(cftime.num2date(num_dates, units, calendar, - only_use_cftime_datetimes=True)) - else: - # Must be using num2date from an old version of netCDF4 which - # does not have the only_use_cftime_datetimes option. - dates = np.asarray(cftime.num2date(num_dates, units, calendar)) - - if (dates[np.nanargmin(num_dates)].year < 1678 or - dates[np.nanargmax(num_dates)].year >= 2262): - if calendar in _STANDARD_CALENDARS: - warnings.warn( - 'Unable to decode time axis into full ' - 'numpy.datetime64 objects, continuing using dummy ' - 'cftime.datetime objects instead, reason: dates out ' - 'of range', SerializationWarning, stacklevel=3) - else: - if calendar in _STANDARD_CALENDARS: - dates = cftime_to_nptime(dates) - return dates - - -def _decode_cf_datetime_dtype(data, units, calendar): +def _decode_cf_datetime_dtype(data, units, calendar, use_cftime): # Verify that at least the first and last date can be decoded # successfully. Otherwise, tracebacks end up swallowed by # Dataset.__repr__ when users try to view their lazily decoded array. @@ -115,7 +90,8 @@ def _decode_cf_datetime_dtype(data, units, calendar): last_item(values) or [0]]) try: - result = decode_cf_datetime(example_value, units, calendar) + result = decode_cf_datetime(example_value, units, calendar, + use_cftime) except Exception: calendar_msg = ('the default calendar' if calendar is None else 'calendar %r' % calendar) @@ -129,7 +105,52 @@ def _decode_cf_datetime_dtype(data, units, calendar): return dtype -def decode_cf_datetime(num_dates, units, calendar=None): +def _decode_datetime_with_cftime(num_dates, units, calendar): + cftime = _import_cftime() + + if cftime.__name__ == 'cftime': + return np.asarray(cftime.num2date(num_dates, units, calendar, + only_use_cftime_datetimes=True)) + else: + # Must be using num2date from an old version of netCDF4 which + # does not have the only_use_cftime_datetimes option. + return np.asarray(cftime.num2date(num_dates, units, calendar)) + + +def _decode_datetime_with_pandas(flat_num_dates, units, calendar): + if calendar not in _STANDARD_CALENDARS: + raise OutOfBoundsDatetime( + 'Cannot decode times from a non-standard calendar, {!r}, using ' + 'pandas.'.format(calendar)) + + delta, ref_date = _unpack_netcdf_time_units(units) + delta = _netcdf_to_numpy_timeunit(delta) + try: + ref_date = pd.Timestamp(ref_date) + except ValueError: + # ValueError is raised by pd.Timestamp for non-ISO timestamp + # strings, in which case we fall back to using cftime + raise OutOfBoundsDatetime + + # fixes: https://github.com/pydata/pandas/issues/14068 + # these lines check if the the lowest or the highest value in dates + # cause an OutOfBoundsDatetime (Overflow) error + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'invalid value encountered', + RuntimeWarning) + pd.to_timedelta(flat_num_dates.min(), delta) + ref_date + pd.to_timedelta(flat_num_dates.max(), delta) + ref_date + + # Cast input dates to integers of nanoseconds because `pd.to_datetime` + # works much faster when dealing with integers + # make _NS_PER_TIME_DELTA an array to ensure type upcasting + flat_num_dates_ns_int = (flat_num_dates.astype(np.float64) * + _NS_PER_TIME_DELTA[delta]).astype(np.int64) + + return (pd.to_timedelta(flat_num_dates_ns_int, 'ns') + ref_date).values + + +def decode_cf_datetime(num_dates, units, calendar=None, use_cftime=None): """Given an array of numeric dates in netCDF format, convert it into a numpy array of date time objects. @@ -149,41 +170,30 @@ def decode_cf_datetime(num_dates, units, calendar=None): if calendar is None: calendar = 'standard' - delta, ref_date = _unpack_netcdf_time_units(units) - - try: - if calendar not in _STANDARD_CALENDARS: - raise OutOfBoundsDatetime - - delta = _netcdf_to_numpy_timeunit(delta) + if use_cftime is None: try: - ref_date = pd.Timestamp(ref_date) - except ValueError: - # ValueError is raised by pd.Timestamp for non-ISO timestamp - # strings, in which case we fall back to using cftime - raise OutOfBoundsDatetime - - # fixes: https://github.com/pydata/pandas/issues/14068 - # these lines check if the the lowest or the highest value in dates - # cause an OutOfBoundsDatetime (Overflow) error - with warnings.catch_warnings(): - warnings.filterwarnings('ignore', 'invalid value encountered', - RuntimeWarning) - pd.to_timedelta(flat_num_dates.min(), delta) + ref_date - pd.to_timedelta(flat_num_dates.max(), delta) + ref_date - - # Cast input dates to integers of nanoseconds because `pd.to_datetime` - # works much faster when dealing with integers - # make _NS_PER_TIME_DELTA an array to ensure type upcasting - flat_num_dates_ns_int = (flat_num_dates.astype(np.float64) * - _NS_PER_TIME_DELTA[delta]).astype(np.int64) - - dates = (pd.to_timedelta(flat_num_dates_ns_int, 'ns') + - ref_date).values - - except (OutOfBoundsDatetime, OverflowError): + dates = _decode_datetime_with_pandas(flat_num_dates, units, + calendar) + except (OutOfBoundsDatetime, OverflowError): + dates = _decode_datetime_with_cftime( + flat_num_dates.astype(np.float), units, calendar) + + if (dates[np.nanargmin(num_dates)].year < 1678 or + dates[np.nanargmax(num_dates)].year >= 2262): + if calendar in _STANDARD_CALENDARS: + warnings.warn( + 'Unable to decode time axis into full ' + 'numpy.datetime64 objects, continuing using ' + 'cftime.datetime objects instead, reason: dates out ' + 'of range', SerializationWarning, stacklevel=3) + else: + if calendar in _STANDARD_CALENDARS: + dates = cftime_to_nptime(dates) + elif use_cftime: dates = _decode_datetime_with_cftime( flat_num_dates.astype(np.float), units, calendar) + else: + dates = _decode_datetime_with_pandas(flat_num_dates, units, calendar) return dates.reshape(num_dates.shape) @@ -383,6 +393,8 @@ def encode_cf_timedelta(timedeltas, units=None): class CFDatetimeCoder(VariableCoder): + def __init__(self, use_cftime=None): + self.use_cftime = use_cftime def encode(self, variable, name=None): dims, data, attrs, encoding = unpack_for_encoding(variable) @@ -403,9 +415,11 @@ def decode(self, variable, name=None): if 'units' in attrs and 'since' in attrs['units']: units = pop_to(attrs, encoding, 'units') calendar = pop_to(attrs, encoding, 'calendar') - dtype = _decode_cf_datetime_dtype(data, units, calendar) + dtype = _decode_cf_datetime_dtype(data, units, calendar, + self.use_cftime) transform = partial( - decode_cf_datetime, units=units, calendar=calendar) + decode_cf_datetime, units=units, calendar=calendar, + use_cftime=self.use_cftime) data = lazy_elemwise_func(data, transform, dtype) return Variable(dims, data, attrs, encoding) diff --git a/xarray/conventions.py b/xarray/conventions.py index c1c95a6b60e..5f41639e890 100644 --- a/xarray/conventions.py +++ b/xarray/conventions.py @@ -240,7 +240,7 @@ def encode_cf_variable(var, needs_copy=True, name=None): def decode_cf_variable(name, var, concat_characters=True, mask_and_scale=True, decode_times=True, decode_endianness=True, - stack_char_dim=True): + stack_char_dim=True, use_cftime=None): """ Decodes a variable which may hold CF encoded information. @@ -270,6 +270,16 @@ def decode_cf_variable(name, var, concat_characters=True, mask_and_scale=True, Whether to stack characters into bytes along the last dimension of this array. Passed as an argument because we need to look at the full dataset to figure out if this is appropriate. + use_cftime: bool, optional + Only relevant if encoded dates come from a standard calendar + (e.g. 'gregorian', 'proleptic_gregorian', 'standard', or not + specified). If None (default), attempt to decode times to + ``np.datetime64[ns]`` objects; if this is not possible, decode times to + ``cftime.datetime`` objects. If True, always decode times to + ``cftime.datetime`` objects, regardless of whether or not they can be + represented using ``np.datetime64[ns]`` objects. If False, always + decode times to ``np.datetime64[ns]`` objects; if this is not possible + raise an error. Returns ------- @@ -292,7 +302,7 @@ def decode_cf_variable(name, var, concat_characters=True, mask_and_scale=True, if decode_times: for coder in [times.CFTimedeltaCoder(), - times.CFDatetimeCoder()]: + times.CFDatetimeCoder(use_cftime=use_cftime)]: var = coder.decode(var, name=name) dimensions, data, attributes, encoding = ( @@ -346,7 +356,8 @@ def _update_bounds_attributes(variables): def decode_cf_variables(variables, attributes, concat_characters=True, mask_and_scale=True, decode_times=True, - decode_coords=True, drop_variables=None): + decode_coords=True, drop_variables=None, + use_cftime=None): """ Decode several CF encoded variables. @@ -387,7 +398,7 @@ def stackable(dim): new_vars[k] = decode_cf_variable( k, v, concat_characters=concat_characters, mask_and_scale=mask_and_scale, decode_times=decode_times, - stack_char_dim=stack_char_dim) + stack_char_dim=stack_char_dim, use_cftime=use_cftime) if decode_coords: var_attrs = new_vars[k].attrs if 'coordinates' in var_attrs: @@ -406,7 +417,8 @@ def stackable(dim): def decode_cf(obj, concat_characters=True, mask_and_scale=True, - decode_times=True, decode_coords=True, drop_variables=None): + decode_times=True, decode_coords=True, drop_variables=None, + use_cftime=None): """Decode the given Dataset or Datastore according to CF conventions into a new Dataset. @@ -430,6 +442,16 @@ def decode_cf(obj, concat_characters=True, mask_and_scale=True, A variable or list of variables to exclude from being parsed from the dataset. This may be useful to drop variables with problems or inconsistent values. + use_cftime: bool, optional + Only relevant if encoded dates come from a standard calendar + (e.g. 'gregorian', 'proleptic_gregorian', 'standard', or not + specified). If None (default), attempt to decode times to + ``np.datetime64[ns]`` objects; if this is not possible, decode times to + ``cftime.datetime`` objects. If True, always decode times to + ``cftime.datetime`` objects, regardless of whether or not they can be + represented using ``np.datetime64[ns]`` objects. If False, always + decode times to ``np.datetime64[ns]`` objects; if this is not possible + raise an error. Returns ------- @@ -454,7 +476,7 @@ def decode_cf(obj, concat_characters=True, mask_and_scale=True, vars, attrs, coord_names = decode_cf_variables( vars, attrs, concat_characters, mask_and_scale, decode_times, - decode_coords, drop_variables=drop_variables) + decode_coords, drop_variables=drop_variables, use_cftime=use_cftime) ds = Dataset(vars, attrs=attrs) ds = ds.set_coords(coord_names.union(extra_coords).intersection(vars)) ds._file_obj = file_obj diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 580cecb988b..f610dba1352 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -27,6 +27,7 @@ from xarray.core.options import set_options from xarray.core.pycompat import dask_array_type from xarray.tests import mock +from xarray.coding.variables import SerializationWarning from . import ( assert_allclose, assert_array_equal, assert_equal, assert_identical, @@ -35,6 +36,8 @@ requires_pathlib, requires_pseudonetcdf, requires_pydap, requires_pynio, requires_rasterio, requires_scipy, requires_scipy_or_netCDF4, requires_zarr) +from .test_coding_times import (_STANDARD_CALENDARS, _NON_STANDARD_CALENDARS, + _ALL_CALENDARS) from .test_dataset import create_test_data try: @@ -47,6 +50,12 @@ except ImportError: pass +try: + from pandas.errors import OutOfBoundsDatetime +except ImportError: + # pandas < 0.20 + from pandas.tslib import OutOfBoundsDatetime + ON_WINDOWS = sys.platform == 'win32' @@ -3536,3 +3545,170 @@ def test_source_encoding_always_present(): original.to_netcdf(tmp) with open_dataset(tmp) as ds: assert ds.encoding['source'] == tmp + + +@requires_scipy_or_netCDF4 +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +def test_use_cftime_standard_calendar_default_in_range(calendar): + x = [0, 1] + time = [0, 720] + units_date = '2000-01-01' + units = 'days since 2000-01-01' + original = DataArray(x, [('time', time)], name='x') + original = original.to_dataset() + for v in ['x', 'time']: + original[v].attrs['units'] = units + original[v].attrs['calendar'] = calendar + + x_timedeltas = np.array(x).astype('timedelta64[D]') + time_timedeltas = np.array(time).astype('timedelta64[D]') + decoded_x = np.datetime64(units_date, 'ns') + x_timedeltas + decoded_time = np.datetime64(units_date, 'ns') + time_timedeltas + expected_x = DataArray(decoded_x, [('time', decoded_time)], name='x') + expected_time = DataArray(decoded_time, [('time', decoded_time)], + name='time') + + with create_tmp_file() as tmp_file: + original.to_netcdf(tmp_file) + with pytest.warns(None) as record: + with open_dataset(tmp_file) as ds: + assert_identical(expected_x, ds.x) + assert_identical(expected_time, ds.time) + assert not record + + +@requires_cftime +@requires_scipy_or_netCDF4 +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2500]) +def test_use_cftime_standard_calendar_default_out_of_range( + calendar, + units_year): + import cftime + + x = [0, 1] + time = [0, 720] + units = 'days since {}-01-01'.format(units_year) + original = DataArray(x, [('time', time)], name='x') + original = original.to_dataset() + for v in ['x', 'time']: + original[v].attrs['units'] = units + original[v].attrs['calendar'] = calendar + + decoded_x = cftime.num2date(x, units, calendar, + only_use_cftime_datetimes=True) + decoded_time = cftime.num2date(time, units, calendar, + only_use_cftime_datetimes=True) + expected_x = DataArray(decoded_x, [('time', decoded_time)], name='x') + expected_time = DataArray(decoded_time, [('time', decoded_time)], + name='time') + + with create_tmp_file() as tmp_file: + original.to_netcdf(tmp_file) + with pytest.warns(SerializationWarning): + with open_dataset(tmp_file) as ds: + assert_identical(expected_x, ds.x) + assert_identical(expected_time, ds.time) + + +@requires_cftime +@requires_scipy_or_netCDF4 +@pytest.mark.parametrize('calendar', _ALL_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2000, 2500]) +def test_use_cftime_true( + calendar, + units_year): + import cftime + + x = [0, 1] + time = [0, 720] + units = 'days since {}-01-01'.format(units_year) + original = DataArray(x, [('time', time)], name='x') + original = original.to_dataset() + for v in ['x', 'time']: + original[v].attrs['units'] = units + original[v].attrs['calendar'] = calendar + + decoded_x = cftime.num2date(x, units, calendar, + only_use_cftime_datetimes=True) + decoded_time = cftime.num2date(time, units, calendar, + only_use_cftime_datetimes=True) + expected_x = DataArray(decoded_x, [('time', decoded_time)], name='x') + expected_time = DataArray(decoded_time, [('time', decoded_time)], + name='time') + + with create_tmp_file() as tmp_file: + original.to_netcdf(tmp_file) + with pytest.warns(None) as record: + with open_dataset(tmp_file, use_cftime=True) as ds: + assert_identical(expected_x, ds.x) + assert_identical(expected_time, ds.time) + assert not record + + +@requires_scipy_or_netCDF4 +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +def test_use_cftime_false_standard_calendar_in_range(calendar): + x = [0, 1] + time = [0, 720] + units_date = '2000-01-01' + units = 'days since 2000-01-01' + original = DataArray(x, [('time', time)], name='x') + original = original.to_dataset() + for v in ['x', 'time']: + original[v].attrs['units'] = units + original[v].attrs['calendar'] = calendar + + x_timedeltas = np.array(x).astype('timedelta64[D]') + time_timedeltas = np.array(time).astype('timedelta64[D]') + decoded_x = np.datetime64(units_date, 'ns') + x_timedeltas + decoded_time = np.datetime64(units_date, 'ns') + time_timedeltas + expected_x = DataArray(decoded_x, [('time', decoded_time)], name='x') + expected_time = DataArray(decoded_time, [('time', decoded_time)], + name='time') + + with create_tmp_file() as tmp_file: + original.to_netcdf(tmp_file) + with pytest.warns(None) as record: + with open_dataset(tmp_file, use_cftime=False) as ds: + assert_identical(expected_x, ds.x) + assert_identical(expected_time, ds.time) + assert not record + + +@requires_scipy_or_netCDF4 +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2500]) +def test_use_cftime_false_standard_calendar_out_of_range(calendar, units_year): + x = [0, 1] + time = [0, 720] + units = 'days since {}-01-01'.format(units_year) + original = DataArray(x, [('time', time)], name='x') + original = original.to_dataset() + for v in ['x', 'time']: + original[v].attrs['units'] = units + original[v].attrs['calendar'] = calendar + + with create_tmp_file() as tmp_file: + original.to_netcdf(tmp_file) + with pytest.raises((OutOfBoundsDatetime, ValueError)): + open_dataset(tmp_file, use_cftime=False) + + +@requires_scipy_or_netCDF4 +@pytest.mark.parametrize('calendar', _NON_STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2000, 2500]) +def test_use_cftime_false_nonstandard_calendar(calendar, units_year): + x = [0, 1] + time = [0, 720] + units = 'days since {}'.format(units_year) + original = DataArray(x, [('time', time)], name='x') + original = original.to_dataset() + for v in ['x', 'time']: + original[v].attrs['units'] = units + original[v].attrs['calendar'] = calendar + + with create_tmp_file() as tmp_file: + original.to_netcdf(tmp_file) + with pytest.raises((OutOfBoundsDatetime, ValueError)): + open_dataset(tmp_file, use_cftime=False) diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 863c0378835..d40abd4acc3 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -8,13 +8,20 @@ from xarray import DataArray, Variable, coding, decode_cf from xarray.coding.times import ( _import_cftime, cftime_to_nptime, decode_cf_datetime, encode_cf_datetime) +from xarray.coding.variables import SerializationWarning from xarray.conventions import _update_bounds_attributes from xarray.core.common import contains_cftime_datetimes from xarray.testing import assert_equal from . import ( assert_array_equal, has_cftime, has_cftime_or_netCDF4, has_dask, - requires_cftime_or_netCDF4) + requires_cftime_or_netCDF4, requires_cftime) + +try: + from pandas.errors import OutOfBoundsDatetime +except ImportError: + # pandas < 0.20 + from pandas.tslib import OutOfBoundsDatetime _NON_STANDARD_CALENDARS_SET = {'noleap', '365_day', '360_day', 'julian', 'all_leap', '366_day'} @@ -781,3 +788,99 @@ def test_time_units_with_timezone_roundtrip(calendar): assert result_units == expected_units assert result_calendar == calendar + + +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +def test_use_cftime_default_standard_calendar_in_range(calendar): + numerical_dates = [0, 1] + units = 'days since 2000-01-01' + expected = pd.date_range('2000', periods=2) + + with pytest.warns(None) as record: + result = decode_cf_datetime(numerical_dates, units, calendar) + np.testing.assert_array_equal(result, expected) + assert not record + + +@requires_cftime +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2500]) +def test_use_cftime_default_standard_calendar_out_of_range( + calendar, + units_year): + from cftime import num2date + + numerical_dates = [0, 1] + units = 'days since {}-01-01'.format(units_year) + expected = num2date(numerical_dates, units, calendar, + only_use_cftime_datetimes=True) + + with pytest.warns(SerializationWarning): + result = decode_cf_datetime(numerical_dates, units, calendar) + np.testing.assert_array_equal(result, expected) + + +@requires_cftime +@pytest.mark.parametrize('calendar', _NON_STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2000, 2500]) +def test_use_cftime_default_non_standard_calendar(calendar, units_year): + from cftime import num2date + + numerical_dates = [0, 1] + units = 'days since {}-01-01'.format(units_year) + expected = num2date(numerical_dates, units, calendar, + only_use_cftime_datetimes=True) + + with pytest.warns(None) as record: + result = decode_cf_datetime(numerical_dates, units, calendar) + np.testing.assert_array_equal(result, expected) + assert not record + + +@requires_cftime +@pytest.mark.parametrize('calendar', _ALL_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2000, 2500]) +def test_use_cftime_true(calendar, units_year): + from cftime import num2date + + numerical_dates = [0, 1] + units = 'days since {}-01-01'.format(units_year) + expected = num2date(numerical_dates, units, calendar, + only_use_cftime_datetimes=True) + + with pytest.warns(None) as record: + result = decode_cf_datetime(numerical_dates, units, calendar, + use_cftime=True) + np.testing.assert_array_equal(result, expected) + assert not record + + +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +def test_use_cftime_false_standard_calendar_in_range(calendar): + numerical_dates = [0, 1] + units = 'days since 2000-01-01' + expected = pd.date_range('2000', periods=2) + + with pytest.warns(None) as record: + result = decode_cf_datetime(numerical_dates, units, calendar, + use_cftime=False) + np.testing.assert_array_equal(result, expected) + assert not record + + +@pytest.mark.parametrize('calendar', _STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2500]) +def test_use_cftime_false_standard_calendar_out_of_range(calendar, units_year): + numerical_dates = [0, 1] + units = 'days since {}-01-01'.format(units_year) + with pytest.raises(OutOfBoundsDatetime): + decode_cf_datetime(numerical_dates, units, calendar, use_cftime=False) + + +@pytest.mark.parametrize('calendar', _NON_STANDARD_CALENDARS) +@pytest.mark.parametrize('units_year', [1500, 2000, 2500]) +def test_use_cftime_false_non_standard_calendar(calendar, units_year): + numerical_dates = [0, 1] + units = 'days since {}-01-01'.format(units_year) + with pytest.raises(OutOfBoundsDatetime): + decode_cf_datetime(numerical_dates, units, calendar, use_cftime=False) From 627a881fd3dacf941af062f556c29d5f46411f22 Mon Sep 17 00:00:00 2001 From: jwenfai Date: Fri, 1 Mar 2019 20:41:44 -0500 Subject: [PATCH 104/108] Quarter offset implemented (base is now latest pydata-master). (#2721) * Quarter offset implemented (base is now latest pydata-master). * Fixed issues raised in review (https://github.com/pydata/xarray/pull/2721#pullrequestreview-199346642) * Updated whats-new.rst with info on quarter offset support. * Updated whats-new.rst with info on quarter offset support. * Update doc/whats-new.rst Co-Authored-By: jwenfai * Added support for quarter frequencies when resampling CFTimeIndex. Less redundancy in CFTimeIndex resampling tests. * Removed normalization code (unnecessary for cftime_range) in cftime_offsets.py. Removed redundant lines in whats-new.rst. * Removed invalid option from _get_day_of_month docstring. Added tests back in that raises ValueError when resampling (base=24 when resampling to daily freq, e.g., '8D'). * Minor edits to docstrings/comments * lint --- doc/whats-new.rst | 4 +- xarray/coding/cftime_offsets.py | 369 ++++++++++++++++++---- xarray/core/resample_cftime.py | 8 +- xarray/tests/test_cftime_offsets.py | 221 +++++++++++-- xarray/tests/test_cftimeindex_resample.py | 62 +++- 5 files changed, 558 insertions(+), 106 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 9ac671d5858..090b6022b05 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -68,6 +68,8 @@ Enhancements - :py:meth:`pandas.Series.dropna` is now supported for a :py:class:`pandas.Series` indexed by a :py:class:`~xarray.CFTimeIndex` (:issue:`2688`). By `Spencer Clark `_. +- :py:meth:`~xarray.cftime_range` now supports QuarterBegin and QuarterEnd offsets (:issue:`2663`). + By `Jwen Fai Low `_ - :py:meth:`~xarray.open_dataset` now accepts a ``use_cftime`` argument, which can be used to require that ``cftime.datetime`` objects are always used, or never used when decoding dates encoded with a standard calendar. This can be @@ -76,7 +78,7 @@ Enhancements serialization warnings raised if dates from a standard calendar are found to be outside the :py:class:`pandas.Timestamp`-valid range (:issue:`2754`). By `Spencer Clark `_. - + Bug fixes ~~~~~~~~~ diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index 4b5770ac90a..a74c735224b 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -75,6 +75,7 @@ def get_date_type(calendar): class BaseCFTimeOffset(object): _freq = None # type: ClassVar[str] + _day_option = None def __init__(self, n=1): if not isinstance(n, int): @@ -151,6 +152,41 @@ def __str__(self): def __repr__(self): return str(self) + def _get_offset_day(self, other): + # subclass must implement `_day_option`; calling from the base class + # will raise NotImplementedError. + return _get_day_of_month(other, self._day_option) + + +def _get_day_of_month(other, day_option): + """Find the day in `other`'s month that satisfies a BaseCFTimeOffset's + onOffset policy, as described by the `day_option` argument. + + Parameters + ---------- + other : cftime.datetime + day_option : 'start', 'end' + 'start': returns 1 + 'end': returns last day of the month + + Returns + ------- + day_of_month : int + + """ + + if day_option == 'start': + return 1 + elif day_option == 'end': + days_in_month = _days_in_month(other) + return days_in_month + elif day_option is None: + # Note: unlike `_shift_month`, _get_day_of_month does not + # allow day_option = None + raise NotImplementedError + else: + raise ValueError(day_option) + def _days_in_month(date): """The number of days in the month of the given date""" @@ -186,7 +222,7 @@ def _adjust_n_years(other, n, month, reference_day): return n -def _shift_months(date, months, day_option='start'): +def _shift_month(date, months, day_option='start'): """Shift the date to a month start or end a given number of months away. """ delta_year = (date.month + months) // 12 @@ -211,12 +247,69 @@ def _shift_months(date, months, day_option='start'): return date.replace(year=year, month=month, day=day, dayofwk=-1) +def roll_qtrday(other, n, month, day_option, modby=3): + """Possibly increment or decrement the number of periods to shift + based on rollforward/rollbackward conventions. + + Parameters + ---------- + other : cftime.datetime + n : number of periods to increment, before adjusting for rolling + month : int reference month giving the first month of the year + day_option : 'start', 'end' + The convention to use in finding the day in a given month against + which to compare for rollforward/rollbackward decisions. + modby : int 3 for quarters, 12 for years + + Returns + ------- + n : int number of periods to increment + + See Also + -------- + _get_day_of_month : Find the day in a month provided an offset. + """ + + months_since = other.month % modby - month % modby + + if n > 0: + if months_since < 0 or ( + months_since == 0 and + other.day < _get_day_of_month(other, day_option)): + # pretend to roll back if on same month but + # before compare_day + n -= 1 + else: + if months_since > 0 or ( + months_since == 0 and + other.day > _get_day_of_month(other, day_option)): + # make sure to roll forward, so negate + n += 1 + return n + + +def _validate_month(month, default_month): + if month is None: + result_month = default_month + else: + result_month = month + if not isinstance(result_month, int): + raise TypeError("'self.month' must be an integer value between 1 " + "and 12. Instead, it was set to a value of " + "{!r}".format(result_month)) + elif not (1 <= result_month <= 12): + raise ValueError("'self.month' must be an integer value between 1 " + "and 12. Instead, it was set to a value of " + "{!r}".format(result_month)) + return result_month + + class MonthBegin(BaseCFTimeOffset): _freq = 'MS' def __apply__(self, other): n = _adjust_n_months(other.day, self.n, 1) - return _shift_months(other, n, 'start') + return _shift_month(other, n, 'start') def onOffset(self, date): """Check if the given date is in the set of possible dates created @@ -229,7 +322,7 @@ class MonthEnd(BaseCFTimeOffset): def __apply__(self, other): n = _adjust_n_months(other.day, self.n, _days_in_month(other)) - return _shift_months(other, n, 'end') + return _shift_month(other, n, 'end') def onOffset(self, date): """Check if the given date is in the set of possible dates created @@ -253,6 +346,105 @@ def onOffset(self, date): } +class QuarterOffset(BaseCFTimeOffset): + """Quarter representation copied off of pandas/tseries/offsets.py + """ + _freq = None # type: ClassVar[str] + _default_month = None # type: ClassVar[int] + + def __init__(self, n=1, month=None): + BaseCFTimeOffset.__init__(self, n) + self.month = _validate_month(month, self._default_month) + + def __apply__(self, other): + # months_since: find the calendar quarter containing other.month, + # e.g. if other.month == 8, the calendar quarter is [Jul, Aug, Sep]. + # Then find the month in that quarter containing an onOffset date for + # self. `months_since` is the number of months to shift other.month + # to get to this on-offset month. + months_since = other.month % 3 - self.month % 3 + qtrs = roll_qtrday(other, self.n, self.month, + day_option=self._day_option, modby=3) + months = qtrs * 3 - months_since + return _shift_month(other, months, self._day_option) + + def onOffset(self, date): + """Check if the given date is in the set of possible dates created + using a length-one version of this offset class.""" + mod_month = (date.month - self.month) % 3 + return mod_month == 0 and date.day == self._get_offset_day(date) + + def __sub__(self, other): + import cftime + + if isinstance(other, cftime.datetime): + raise TypeError('Cannot subtract cftime.datetime from offset.') + elif type(other) == type(self) and other.month == self.month: + return type(self)(self.n - other.n, month=self.month) + else: + return NotImplemented + + def __mul__(self, other): + return type(self)(n=other * self.n, month=self.month) + + def rule_code(self): + return '{}-{}'.format(self._freq, _MONTH_ABBREVIATIONS[self.month]) + + def __str__(self): + return '<{}: n={}, month={}>'.format( + type(self).__name__, self.n, self.month) + + +class QuarterBegin(QuarterOffset): + # When converting a string to an offset, pandas converts + # 'QS' to a QuarterBegin offset starting in the month of + # January. When creating a QuarterBegin offset directly + # from the constructor, however, the default month is March. + # We follow that behavior here. + _default_month = 3 + _freq = 'QS' + _day_option = 'start' + + def rollforward(self, date): + """Roll date forward to nearest start of quarter""" + if self.onOffset(date): + return date + else: + return date + QuarterBegin(month=self.month) + + def rollback(self, date): + """Roll date backward to nearest start of quarter""" + if self.onOffset(date): + return date + else: + return date - QuarterBegin(month=self.month) + + +class QuarterEnd(QuarterOffset): + # When converting a string to an offset, pandas converts + # 'Q' to a QuarterEnd offset starting in the month of + # December. When creating a QuarterEnd offset directly + # from the constructor, however, the default month is March. + # We follow that behavior here. + _default_month = 3 + _freq = 'Q' + _day_option = 'end' + + def rollforward(self, date): + """Roll date forward to nearest end of quarter""" + if self.onOffset(date): + return date + else: + return date + QuarterEnd(month=self.month) + + def rollback(self, date): + """Roll date backward to nearest end of quarter""" + if self.onOffset(date): + return date + else: + return date - QuarterEnd(month=self.month) + + class YearOffset(BaseCFTimeOffset): _freq = None # type: ClassVar[str] _day_option = None # type: ClassVar[str] @@ -260,29 +452,13 @@ class YearOffset(BaseCFTimeOffset): def __init__(self, n=1, month=None): BaseCFTimeOffset.__init__(self, n) - if month is None: - self.month = self._default_month - else: - self.month = month - if not isinstance(self.month, int): - raise TypeError("'self.month' must be an integer value between 1 " - "and 12. Instead, it was set to a value of " - "{!r}".format(self.month)) - elif not (1 <= self.month <= 12): - raise ValueError("'self.month' must be an integer value between 1 " - "and 12. Instead, it was set to a value of " - "{!r}".format(self.month)) + self.month = _validate_month(month, self._default_month) def __apply__(self, other): - if self._day_option == 'start': - reference_day = 1 - elif self._day_option == 'end': - reference_day = _days_in_month(other) - else: - raise ValueError(self._day_option) + reference_day = _get_day_of_month(other, self._day_option) years = _adjust_n_years(other, self.n, self.month, reference_day) months = years * 12 + (self.month - other.month) - return _shift_months(other, months, self._day_option) + return _shift_month(other, months, self._day_option) def __sub__(self, other): import cftime @@ -400,6 +576,8 @@ def __apply__(self, other): 'AS': YearBegin, 'Y': YearEnd, 'YS': YearBegin, + 'Q': partial(QuarterEnd, month=12), + 'QS': partial(QuarterBegin, month=1), 'M': MonthEnd, 'MS': MonthBegin, 'D': Day, @@ -430,7 +608,31 @@ def __apply__(self, other): 'A-SEP': partial(YearEnd, month=9), 'A-OCT': partial(YearEnd, month=10), 'A-NOV': partial(YearEnd, month=11), - 'A-DEC': partial(YearEnd, month=12) + 'A-DEC': partial(YearEnd, month=12), + 'QS-JAN': partial(QuarterBegin, month=1), + 'QS-FEB': partial(QuarterBegin, month=2), + 'QS-MAR': partial(QuarterBegin, month=3), + 'QS-APR': partial(QuarterBegin, month=4), + 'QS-MAY': partial(QuarterBegin, month=5), + 'QS-JUN': partial(QuarterBegin, month=6), + 'QS-JUL': partial(QuarterBegin, month=7), + 'QS-AUG': partial(QuarterBegin, month=8), + 'QS-SEP': partial(QuarterBegin, month=9), + 'QS-OCT': partial(QuarterBegin, month=10), + 'QS-NOV': partial(QuarterBegin, month=11), + 'QS-DEC': partial(QuarterBegin, month=12), + 'Q-JAN': partial(QuarterEnd, month=1), + 'Q-FEB': partial(QuarterEnd, month=2), + 'Q-MAR': partial(QuarterEnd, month=3), + 'Q-APR': partial(QuarterEnd, month=4), + 'Q-MAY': partial(QuarterEnd, month=5), + 'Q-JUN': partial(QuarterEnd, month=6), + 'Q-JUL': partial(QuarterEnd, month=7), + 'Q-AUG': partial(QuarterEnd, month=8), + 'Q-SEP': partial(QuarterEnd, month=9), + 'Q-OCT': partial(QuarterEnd, month=10), + 'Q-NOV': partial(QuarterEnd, month=11), + 'Q-DEC': partial(QuarterEnd, month=12) } @@ -624,55 +826,84 @@ def cftime_range(start=None, end=None, periods=None, freq='D', Valid simple frequency strings for use with ``cftime``-calendars include any multiples of the following. - +--------+-----------------------+ - | Alias | Description | - +========+=======================+ - | A, Y | Year-end frequency | - +--------+-----------------------+ - | AS, YS | Year-start frequency | - +--------+-----------------------+ - | M | Month-end frequency | - +--------+-----------------------+ - | MS | Month-start frequency | - +--------+-----------------------+ - | D | Day frequency | - +--------+-----------------------+ - | H | Hour frequency | - +--------+-----------------------+ - | T, min | Minute frequency | - +--------+-----------------------+ - | S | Second frequency | - +--------+-----------------------+ + +--------+--------------------------+ + | Alias | Description | + +========+==========================+ + | A, Y | Year-end frequency | + +--------+--------------------------+ + | AS, YS | Year-start frequency | + +--------+--------------------------+ + | Q | Quarter-end frequency | + +--------+--------------------------+ + | QS | Quarter-start frequency | + +--------+--------------------------+ + | M | Month-end frequency | + +--------+--------------------------+ + | MS | Month-start frequency | + +--------+--------------------------+ + | D | Day frequency | + +--------+--------------------------+ + | H | Hour frequency | + +--------+--------------------------+ + | T, min | Minute frequency | + +--------+--------------------------+ + | S | Second frequency | + +--------+--------------------------+ Any multiples of the following anchored offsets are also supported. - +----------+-------------------------------------------------------------------+ - | Alias | Description | - +==========+===================================================================+ - | A(S)-JAN | Annual frequency, anchored at the end (or beginning) of January | - +----------+-------------------------------------------------------------------+ - | A(S)-FEB | Annual frequency, anchored at the end (or beginning) of February | - +----------+-------------------------------------------------------------------+ - | A(S)-MAR | Annual frequency, anchored at the end (or beginning) of March | - +----------+-------------------------------------------------------------------+ - | A(S)-APR | Annual frequency, anchored at the end (or beginning) of April | - +----------+-------------------------------------------------------------------+ - | A(S)-MAY | Annual frequency, anchored at the end (or beginning) of May | - +----------+-------------------------------------------------------------------+ - | A(S)-JUN | Annual frequency, anchored at the end (or beginning) of June | - +----------+-------------------------------------------------------------------+ - | A(S)-JUL | Annual frequency, anchored at the end (or beginning) of July | - +----------+-------------------------------------------------------------------+ - | A(S)-AUG | Annual frequency, anchored at the end (or beginning) of August | - +----------+-------------------------------------------------------------------+ - | A(S)-SEP | Annual frequency, anchored at the end (or beginning) of September | - +----------+-------------------------------------------------------------------+ - | A(S)-OCT | Annual frequency, anchored at the end (or beginning) of October | - +----------+-------------------------------------------------------------------+ - | A(S)-NOV | Annual frequency, anchored at the end (or beginning) of November | - +----------+-------------------------------------------------------------------+ - | A(S)-DEC | Annual frequency, anchored at the end (or beginning) of December | - +----------+-------------------------------------------------------------------+ + +----------+--------------------------------------------------------------------+ + | Alias | Description | + +==========+====================================================================+ + | A(S)-JAN | Annual frequency, anchored at the end (or beginning) of January | + +----------+--------------------------------------------------------------------+ + | A(S)-FEB | Annual frequency, anchored at the end (or beginning) of February | + +----------+--------------------------------------------------------------------+ + | A(S)-MAR | Annual frequency, anchored at the end (or beginning) of March | + +----------+--------------------------------------------------------------------+ + | A(S)-APR | Annual frequency, anchored at the end (or beginning) of April | + +----------+--------------------------------------------------------------------+ + | A(S)-MAY | Annual frequency, anchored at the end (or beginning) of May | + +----------+--------------------------------------------------------------------+ + | A(S)-JUN | Annual frequency, anchored at the end (or beginning) of June | + +----------+--------------------------------------------------------------------+ + | A(S)-JUL | Annual frequency, anchored at the end (or beginning) of July | + +----------+--------------------------------------------------------------------+ + | A(S)-AUG | Annual frequency, anchored at the end (or beginning) of August | + +----------+--------------------------------------------------------------------+ + | A(S)-SEP | Annual frequency, anchored at the end (or beginning) of September | + +----------+--------------------------------------------------------------------+ + | A(S)-OCT | Annual frequency, anchored at the end (or beginning) of October | + +----------+--------------------------------------------------------------------+ + | A(S)-NOV | Annual frequency, anchored at the end (or beginning) of November | + +----------+--------------------------------------------------------------------+ + | A(S)-DEC | Annual frequency, anchored at the end (or beginning) of December | + +----------+--------------------------------------------------------------------+ + | Q(S)-JAN | Quarter frequency, anchored at the end (or beginning) of January | + +----------+--------------------------------------------------------------------+ + | Q(S)-FEB | Quarter frequency, anchored at the end (or beginning) of February | + +----------+--------------------------------------------------------------------+ + | Q(S)-MAR | Quarter frequency, anchored at the end (or beginning) of March | + +----------+--------------------------------------------------------------------+ + | Q(S)-APR | Quarter frequency, anchored at the end (or beginning) of April | + +----------+--------------------------------------------------------------------+ + | Q(S)-MAY | Quarter frequency, anchored at the end (or beginning) of May | + +----------+--------------------------------------------------------------------+ + | Q(S)-JUN | Quarter frequency, anchored at the end (or beginning) of June | + +----------+--------------------------------------------------------------------+ + | Q(S)-JUL | Quarter frequency, anchored at the end (or beginning) of July | + +----------+--------------------------------------------------------------------+ + | Q(S)-AUG | Quarter frequency, anchored at the end (or beginning) of August | + +----------+--------------------------------------------------------------------+ + | Q(S)-SEP | Quarter frequency, anchored at the end (or beginning) of September | + +----------+--------------------------------------------------------------------+ + | Q(S)-OCT | Quarter frequency, anchored at the end (or beginning) of October | + +----------+--------------------------------------------------------------------+ + | Q(S)-NOV | Quarter frequency, anchored at the end (or beginning) of November | + +----------+--------------------------------------------------------------------+ + | Q(S)-DEC | Quarter frequency, anchored at the end (or beginning) of December | + +----------+--------------------------------------------------------------------+ + Finally, the following calendar aliases are supported. diff --git a/xarray/core/resample_cftime.py b/xarray/core/resample_cftime.py index 6b6d214768e..161945f118d 100644 --- a/xarray/core/resample_cftime.py +++ b/xarray/core/resample_cftime.py @@ -38,7 +38,7 @@ from ..coding.cftimeindex import CFTimeIndex from ..coding.cftime_offsets import (cftime_range, normalize_date, - Day, MonthEnd, YearEnd, + Day, MonthEnd, QuarterEnd, YearEnd, CFTIME_TICKS, to_offset) import datetime import numpy as np @@ -50,14 +50,14 @@ class CFTimeGrouper(object): single method, the only one required for resampling in xarray. It cannot be used in a call to groupby like a pandas.Grouper object can.""" - def __init__(self, freq, closed, label, base, loffset): + def __init__(self, freq, closed=None, label=None, base=0, loffset=None): self.freq = to_offset(freq) self.closed = closed self.label = label self.base = base self.loffset = loffset - if isinstance(self.freq, (MonthEnd, YearEnd)): + if isinstance(self.freq, (MonthEnd, QuarterEnd, YearEnd)): if self.closed is None: self.closed = 'right' if self.label is None: @@ -199,7 +199,7 @@ def _adjust_bin_edges(datetime_bins, offset, closed, index, labels): This is also required for daily frequencies longer than one day and year-end frequencies. """ - is_super_daily = (isinstance(offset, (MonthEnd, YearEnd)) or + is_super_daily = (isinstance(offset, (MonthEnd, QuarterEnd, YearEnd)) or (isinstance(offset, Day) and offset.n > 1)) if is_super_daily: if closed == 'right': diff --git a/xarray/tests/test_cftime_offsets.py b/xarray/tests/test_cftime_offsets.py index 29caa88cc53..1cf257c96eb 100644 --- a/xarray/tests/test_cftime_offsets.py +++ b/xarray/tests/test_cftime_offsets.py @@ -6,9 +6,9 @@ from xarray import CFTimeIndex from xarray.coding.cftime_offsets import ( - _MONTH_ABBREVIATIONS, BaseCFTimeOffset, Day, Hour, Minute, MonthBegin, - MonthEnd, Second, YearBegin, YearEnd, _days_in_month, cftime_range, - get_date_type, to_cftime_datetime, to_offset) + _MONTH_ABBREVIATIONS, BaseCFTimeOffset, Day, Hour, Minute, Second, + MonthBegin, MonthEnd, YearBegin, YearEnd, QuarterBegin, QuarterEnd, + _days_in_month, cftime_range, get_date_type, to_cftime_datetime, to_offset) cftime = pytest.importorskip('cftime') @@ -32,9 +32,13 @@ def calendar(request): [(BaseCFTimeOffset(), 1), (YearBegin(), 1), (YearEnd(), 1), + (QuarterBegin(), 1), + (QuarterEnd(), 1), (BaseCFTimeOffset(n=2), 2), (YearBegin(n=2), 2), - (YearEnd(n=2), 2)], + (YearEnd(n=2), 2), + (QuarterBegin(n=2), 2), + (QuarterEnd(n=2), 2)], ids=_id_func ) def test_cftime_offset_constructor_valid_n(offset, expected_n): @@ -45,7 +49,9 @@ def test_cftime_offset_constructor_valid_n(offset, expected_n): ('offset', 'invalid_n'), [(BaseCFTimeOffset, 1.5), (YearBegin, 1.5), - (YearEnd, 1.5)], + (YearEnd, 1.5), + (QuarterBegin, 1.5), + (QuarterEnd, 1.5)], ids=_id_func ) def test_cftime_offset_constructor_invalid_n(offset, invalid_n): @@ -58,7 +64,11 @@ def test_cftime_offset_constructor_invalid_n(offset, invalid_n): [(YearBegin(), 1), (YearEnd(), 12), (YearBegin(month=5), 5), - (YearEnd(month=5), 5)], + (YearEnd(month=5), 5), + (QuarterBegin(), 3), + (QuarterEnd(), 3), + (QuarterBegin(month=5), 5), + (QuarterEnd(month=5), 5)], ids=_id_func ) def test_year_offset_constructor_valid_month(offset, expected_month): @@ -72,7 +82,13 @@ def test_year_offset_constructor_valid_month(offset, expected_month): (YearBegin, 13, ValueError,), (YearEnd, 13, ValueError), (YearBegin, 1.5, TypeError), - (YearEnd, 1.5, TypeError)], + (YearEnd, 1.5, TypeError), + (QuarterBegin, 0, ValueError), + (QuarterEnd, 0, ValueError), + (QuarterBegin, 1.5, TypeError), + (QuarterEnd, 1.5, TypeError), + (QuarterBegin, 13, ValueError), + (QuarterEnd, 13, ValueError)], ids=_id_func ) def test_year_offset_constructor_invalid_month( @@ -85,7 +101,8 @@ def test_year_offset_constructor_invalid_month( ('offset', 'expected'), [(BaseCFTimeOffset(), None), (MonthBegin(), 'MS'), - (YearBegin(), 'AS-JAN')], + (YearBegin(), 'AS-JAN'), + (QuarterBegin(), 'QS-MAR')], ids=_id_func ) def test_rule_code(offset, expected): @@ -95,7 +112,8 @@ def test_rule_code(offset, expected): @pytest.mark.parametrize( ('offset', 'expected'), [(BaseCFTimeOffset(), ''), - (YearBegin(), '')], + (YearBegin(), ''), + (QuarterBegin(), '')], ids=_id_func ) def test_str_and_repr(offset, expected): @@ -105,7 +123,7 @@ def test_str_and_repr(offset, expected): @pytest.mark.parametrize( 'offset', - [BaseCFTimeOffset(), MonthBegin(), YearBegin()], + [BaseCFTimeOffset(), MonthBegin(), QuarterBegin(), YearBegin()], ids=_id_func ) def test_to_offset_offset_input(offset): @@ -164,7 +182,47 @@ def test_to_offset_annual(month_label, month_int, multiple, offset_str): assert result == expected -@pytest.mark.parametrize('freq', ['Z', '7min2', 'AM', 'M-', 'AS-', '1H1min']) +_QUARTER_OFFSET_TYPES = { + 'Q': QuarterEnd, + 'QS': QuarterBegin +} + + +@pytest.mark.parametrize(('month_int', 'month_label'), + list(_MONTH_ABBREVIATIONS.items()) + [(0, '')]) +@pytest.mark.parametrize('multiple', [None, 2]) +@pytest.mark.parametrize('offset_str', ['QS', 'Q']) +def test_to_offset_quarter(month_label, month_int, multiple, offset_str): + freq = offset_str + offset_type = _QUARTER_OFFSET_TYPES[offset_str] + if month_label: + freq = '-'.join([freq, month_label]) + if multiple: + freq = '{}'.format(multiple) + freq + result = to_offset(freq) + + if multiple and month_int: + expected = offset_type(n=multiple, month=month_int) + elif multiple: + if month_int: + expected = offset_type(n=multiple) + else: + if offset_type == QuarterBegin: + expected = offset_type(n=multiple, month=1) + elif offset_type == QuarterEnd: + expected = offset_type(n=multiple, month=12) + elif month_int: + expected = offset_type(month=month_int) + else: + if offset_type == QuarterBegin: + expected = offset_type(month=1) + elif offset_type == QuarterEnd: + expected = offset_type(month=12) + assert result == expected + + +@pytest.mark.parametrize('freq', ['Z', '7min2', 'AM', 'M-', 'AS-', 'QS-', + '1H1min']) def test_invalid_to_offset_str(freq): with pytest.raises(ValueError): to_offset(freq) @@ -197,13 +255,16 @@ def test_to_cftime_datetime_error_type_error(): _EQ_TESTS_A = [ BaseCFTimeOffset(), YearBegin(), YearEnd(), YearBegin(month=2), - YearEnd(month=2), MonthBegin(), MonthEnd(), Day(), Hour(), Minute(), + YearEnd(month=2), QuarterBegin(), QuarterEnd(), QuarterBegin(month=2), + QuarterEnd(month=2), MonthBegin(), MonthEnd(), Day(), Hour(), Minute(), Second() ] _EQ_TESTS_B = [ BaseCFTimeOffset(n=2), YearBegin(n=2), YearEnd(n=2), - YearBegin(n=2, month=2), YearEnd(n=2, month=2), MonthBegin(n=2), - MonthEnd(n=2), Day(n=2), Hour(n=2), Minute(n=2), Second(n=2) + YearBegin(n=2, month=2), YearEnd(n=2, month=2), QuarterBegin(n=2), + QuarterEnd(n=2), QuarterBegin(n=2, month=2), QuarterEnd(n=2, month=2), + MonthBegin(n=2), MonthEnd(n=2), Day(n=2), Hour(n=2), Minute(n=2), + Second(n=2) ] @@ -216,8 +277,10 @@ def test_neq(a, b): _EQ_TESTS_B_COPY = [ BaseCFTimeOffset(n=2), YearBegin(n=2), YearEnd(n=2), - YearBegin(n=2, month=2), YearEnd(n=2, month=2), MonthBegin(n=2), - MonthEnd(n=2), Day(n=2), Hour(n=2), Minute(n=2), Second(n=2) + YearBegin(n=2, month=2), YearEnd(n=2, month=2), QuarterBegin(n=2), + QuarterEnd(n=2), QuarterBegin(n=2, month=2), QuarterEnd(n=2, month=2), + MonthBegin(n=2), MonthEnd(n=2), Day(n=2), Hour(n=2), Minute(n=2), + Second(n=2) ] @@ -232,6 +295,8 @@ def test_eq(a, b): (BaseCFTimeOffset(), BaseCFTimeOffset(n=3)), (YearEnd(), YearEnd(n=3)), (YearBegin(), YearBegin(n=3)), + (QuarterEnd(), QuarterEnd(n=3)), + (QuarterBegin(), QuarterBegin(n=3)), (MonthEnd(), MonthEnd(n=3)), (MonthBegin(), MonthBegin(n=3)), (Day(), Day(n=3)), @@ -256,6 +321,8 @@ def test_rmul(offset, expected): [(BaseCFTimeOffset(), BaseCFTimeOffset(n=-1)), (YearEnd(), YearEnd(n=-1)), (YearBegin(), YearBegin(n=-1)), + (QuarterEnd(), QuarterEnd(n=-1)), + (QuarterBegin(), QuarterBegin(n=-1)), (MonthEnd(), MonthEnd(n=-1)), (MonthBegin(), MonthBegin(n=-1)), (Day(), Day(n=-1)), @@ -536,6 +603,89 @@ def test_add_year_end_onOffset( assert result == expected +@pytest.mark.parametrize( + ('initial_date_args', 'offset', 'expected_date_args'), + [((1, 1, 1), QuarterBegin(), (1, 3, 1)), + ((1, 1, 1), QuarterBegin(n=2), (1, 6, 1)), + ((1, 1, 1), QuarterBegin(month=2), (1, 2, 1)), + ((1, 1, 7), QuarterBegin(n=2), (1, 6, 1)), + ((2, 2, 1), QuarterBegin(n=-1), (1, 12, 1)), + ((1, 3, 2), QuarterBegin(n=-1), (1, 3, 1)), + ((1, 1, 1, 5, 5, 5, 5), QuarterBegin(), (1, 3, 1, 5, 5, 5, 5)), + ((2, 1, 1, 5, 5, 5, 5), QuarterBegin(n=-1), (1, 12, 1, 5, 5, 5, 5))], + ids=_id_func +) +def test_add_quarter_begin(calendar, initial_date_args, offset, + expected_date_args): + date_type = get_date_type(calendar) + initial = date_type(*initial_date_args) + result = initial + offset + expected = date_type(*expected_date_args) + assert result == expected + + +@pytest.mark.parametrize( + ('initial_date_args', 'offset', 'expected_year_month', + 'expected_sub_day'), + [((1, 1, 1), QuarterEnd(), (1, 3), ()), + ((1, 1, 1), QuarterEnd(n=2), (1, 6), ()), + ((1, 1, 1), QuarterEnd(month=1), (1, 1), ()), + ((2, 3, 1), QuarterEnd(n=-1), (1, 12), ()), + ((1, 3, 1), QuarterEnd(n=-1, month=2), (1, 2), ()), + ((1, 1, 1, 5, 5, 5, 5), QuarterEnd(), (1, 3), (5, 5, 5, 5)), + ((1, 1, 1, 5, 5, 5, 5), QuarterEnd(n=2), (1, 6), (5, 5, 5, 5))], + ids=_id_func +) +def test_add_quarter_end( + calendar, initial_date_args, offset, expected_year_month, + expected_sub_day +): + date_type = get_date_type(calendar) + initial = date_type(*initial_date_args) + result = initial + offset + reference_args = expected_year_month + (1,) + reference = date_type(*reference_args) + + # Here the days at the end of each month varies based on the calendar used + expected_date_args = (expected_year_month + + (_days_in_month(reference),) + expected_sub_day) + expected = date_type(*expected_date_args) + assert result == expected + + +@pytest.mark.parametrize( + ('initial_year_month', 'initial_sub_day', 'offset', 'expected_year_month', + 'expected_sub_day'), + [((1, 12), (), QuarterEnd(), (2, 3), ()), + ((1, 12), (), QuarterEnd(n=2), (2, 6), ()), + ((1, 12), (), QuarterEnd(n=-1), (1, 9), ()), + ((1, 12), (), QuarterEnd(n=-2), (1, 6), ()), + ((1, 1), (), QuarterEnd(month=2), (1, 2), ()), + ((1, 12), (5, 5, 5, 5), QuarterEnd(), (2, 3), (5, 5, 5, 5)), + ((1, 12), (5, 5, 5, 5), QuarterEnd(n=-1), (1, 9), (5, 5, 5, 5))], + ids=_id_func +) +def test_add_quarter_end_onOffset( + calendar, initial_year_month, initial_sub_day, offset, expected_year_month, + expected_sub_day +): + date_type = get_date_type(calendar) + reference_args = initial_year_month + (1,) + reference = date_type(*reference_args) + initial_date_args = (initial_year_month + (_days_in_month(reference),) + + initial_sub_day) + initial = date_type(*initial_date_args) + result = initial + offset + reference_args = expected_year_month + (1,) + reference = date_type(*reference_args) + + # Here the days at the end of each month varies based on the calendar used + expected_date_args = (expected_year_month + + (_days_in_month(reference),) + expected_sub_day) + expected = date_type(*expected_date_args) + assert result == expected + + # Note for all sub-monthly offsets, pandas always returns True for onOffset @pytest.mark.parametrize( ('date_args', 'offset', 'expected'), @@ -543,6 +693,10 @@ def test_add_year_end_onOffset( ((1, 1, 1, 1), MonthBegin(), True), ((1, 1, 5), MonthBegin(), False), ((1, 1, 5), MonthEnd(), False), + ((1, 3, 1), QuarterBegin(), True), + ((1, 3, 1, 1), QuarterBegin(), True), + ((1, 3, 5), QuarterBegin(), False), + ((1, 12, 1), QuarterEnd(), False), ((1, 1, 1), YearBegin(), True), ((1, 1, 1, 1), YearBegin(), True), ((1, 1, 5), YearBegin(), False), @@ -565,16 +719,19 @@ def test_onOffset(calendar, date_args, offset, expected): ('year_month_args', 'sub_day_args', 'offset'), [((1, 1), (), MonthEnd()), ((1, 1), (1,), MonthEnd()), + ((1, 12), (), QuarterEnd()), + ((1, 1), (), QuarterEnd(month=1)), ((1, 12), (), YearEnd()), ((1, 1), (), YearEnd(month=1))], ids=_id_func ) -def test_onOffset_month_or_year_end( +def test_onOffset_month_or_quarter_or_year_end( calendar, year_month_args, sub_day_args, offset): date_type = get_date_type(calendar) reference_args = year_month_args + (1,) reference = date_type(*reference_args) - date_args = year_month_args + (_days_in_month(reference),) + sub_day_args + date_args = (year_month_args + (_days_in_month(reference),) + + sub_day_args) date = date_type(*date_args) result = offset.onOffset(date) assert result @@ -590,6 +747,14 @@ def test_onOffset_month_or_year_end( (YearEnd(n=2), (1, 3, 1), (1, 12)), (YearEnd(n=2, month=2), (1, 3, 1), (2, 2)), (YearEnd(n=2, month=4), (1, 4, 30), (1, 4)), + (QuarterBegin(), (1, 3, 2), (1, 6)), + (QuarterBegin(), (1, 4, 1), (1, 6)), + (QuarterBegin(n=2), (1, 4, 1), (1, 6)), + (QuarterBegin(n=2, month=2), (1, 4, 1), (1, 5)), + (QuarterEnd(), (1, 3, 1), (1, 3)), + (QuarterEnd(n=2), (1, 3, 1), (1, 3)), + (QuarterEnd(n=2, month=2), (1, 3, 1), (1, 5)), + (QuarterEnd(n=2, month=4), (1, 4, 30), (1, 4)), (MonthBegin(), (1, 3, 2), (1, 4)), (MonthBegin(), (1, 3, 1), (1, 3)), (MonthBegin(n=2), (1, 3, 2), (1, 4)), @@ -606,9 +771,9 @@ def test_rollforward(calendar, offset, initial_date_args, partial_expected_date_args): date_type = get_date_type(calendar) initial = date_type(*initial_date_args) - if isinstance(offset, (MonthBegin, YearBegin)): + if isinstance(offset, (MonthBegin, QuarterBegin, YearBegin)): expected_date_args = partial_expected_date_args + (1,) - elif isinstance(offset, (MonthEnd, YearEnd)): + elif isinstance(offset, (MonthEnd, QuarterEnd, YearEnd)): reference_args = partial_expected_date_args + (1,) reference = date_type(*reference_args) expected_date_args = (partial_expected_date_args + @@ -631,6 +796,14 @@ def test_rollforward(calendar, offset, initial_date_args, (YearEnd(n=2), (2, 3, 1), (1, 12)), (YearEnd(n=2, month=2), (2, 3, 1), (2, 2)), (YearEnd(month=4), (1, 4, 30), (1, 4)), + (QuarterBegin(), (1, 3, 2), (1, 3)), + (QuarterBegin(), (1, 4, 1), (1, 3)), + (QuarterBegin(n=2), (1, 4, 1), (1, 3)), + (QuarterBegin(n=2, month=2), (1, 4, 1), (1, 2)), + (QuarterEnd(), (2, 3, 1), (1, 12)), + (QuarterEnd(n=2), (2, 3, 1), (1, 12)), + (QuarterEnd(n=2, month=2), (2, 3, 1), (2, 2)), + (QuarterEnd(n=2, month=4), (1, 4, 30), (1, 4)), (MonthBegin(), (1, 3, 2), (1, 3)), (MonthBegin(n=2), (1, 3, 2), (1, 3)), (MonthBegin(), (1, 3, 1), (1, 3)), @@ -647,9 +820,9 @@ def test_rollback(calendar, offset, initial_date_args, partial_expected_date_args): date_type = get_date_type(calendar) initial = date_type(*initial_date_args) - if isinstance(offset, (MonthBegin, YearBegin)): + if isinstance(offset, (MonthBegin, QuarterBegin, YearBegin)): expected_date_args = partial_expected_date_args + (1,) - elif isinstance(offset, (MonthEnd, YearEnd)): + elif isinstance(offset, (MonthEnd, QuarterEnd, YearEnd)): reference_args = partial_expected_date_args + (1,) reference = date_type(*reference_args) expected_date_args = (partial_expected_date_args + @@ -687,7 +860,9 @@ def test_rollback(calendar, offset, initial_date_args, ('0010', None, 4, YearBegin(n=-2), None, False, [(10, 1, 1), (8, 1, 1), (6, 1, 1), (4, 1, 1)]), ('0001-01-01', '0001-01-04', 4, None, None, False, - [(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 1, 4)]) + [(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 1, 4)]), + ('0001-06-01', None, 4, '3QS-JUN', None, False, + [(1, 6, 1), (2, 3, 1), (2, 12, 1), (3, 9, 1)]) ] diff --git a/xarray/tests/test_cftimeindex_resample.py b/xarray/tests/test_cftimeindex_resample.py index 0b56f1d1fc6..636f9ef7b0e 100644 --- a/xarray/tests/test_cftimeindex_resample.py +++ b/xarray/tests/test_cftimeindex_resample.py @@ -4,6 +4,7 @@ import numpy as np import pandas as pd import xarray as xr +from xarray.core.resample_cftime import CFTimeGrouper pytest.importorskip('cftime') pytest.importorskip('pandas', minversion='0.24') @@ -13,10 +14,10 @@ params=[ dict(start='2004-01-01T12:07:01', periods=91, freq='3D'), dict(start='1892-01-03T12:07:01', periods=15, freq='41987T'), - dict(start='2004-01-01T12:07:01', periods=31, freq='2MS'), + dict(start='2004-01-01T12:07:01', periods=7, freq='3Q-AUG'), dict(start='1892-01-03T12:07:01', periods=10, freq='3AS-JUN') ], - ids=['3D', '41987T', '2MS', '3AS_JUN'] + ids=['3D', '41987T', '3Q_AUG', '3AS_JUN'] ) def time_range_kwargs(request): return request.param @@ -40,15 +41,18 @@ def da(index): @pytest.mark.parametrize('freq', [ '700T', '8001T', '12H', '8001H', - '3D', '8D', '8001D', - '2MS', '2M', '3MS', '3M', '4MS', '4M', - '3AS', '3A', '4AS', '4A']) -@pytest.mark.parametrize('closed', [None, 'left', 'right']) -@pytest.mark.parametrize('label', [None, 'left', 'right']) -@pytest.mark.parametrize('base', [17, 24]) + '8D', '8001D', + '2MS', '3MS', + '2QS-AUG', '3QS-SEP', + '3AS-MAR', '4A-MAY']) +@pytest.mark.parametrize('closed', [None, 'right']) +@pytest.mark.parametrize('label', [None, 'right']) +@pytest.mark.parametrize('base', [24, 31]) def test_resampler(freq, closed, label, base, datetime_index, cftime_index): # Fairly extensive testing for standard/proleptic Gregorian calendar + # For any frequencies which are not greater-than-day and anchored + # at the end, the default values for closed and label are 'left'. loffset = '12H' try: da_datetime = da(datetime_index).resample( @@ -67,11 +71,51 @@ def test_resampler(freq, closed, label, base, xr.testing.assert_identical(da_cftime, da_datetime) +@pytest.mark.parametrize('freq', [ + '2M', '3M', + '2Q-JUN', '3Q-JUL', + '3A-FEB', '4A-APR']) +@pytest.mark.parametrize('closed', ['left', None]) +@pytest.mark.parametrize('label', ['left', None]) +@pytest.mark.parametrize('base', [17, 24]) +def test_resampler_end_super_day(freq, closed, label, base, + datetime_index, cftime_index): + # Fairly extensive testing for standard/proleptic Gregorian calendar. + # For greater-than-day frequencies anchored at the end, the default values + # for closed and label are 'right'. + loffset = '12H' + try: + da_datetime = da(datetime_index).resample( + time=freq, closed=closed, label=label, base=base, + loffset=loffset).mean() + except ValueError: + with pytest.raises(ValueError): + da(cftime_index).resample( + time=freq, closed=closed, label=label, base=base, + loffset=loffset).mean() + else: + da_cftime = da(cftime_index).resample(time=freq, closed=closed, + label=label, base=base, + loffset=loffset).mean() + da_cftime['time'] = da_cftime.indexes['time'].to_datetimeindex() + xr.testing.assert_identical(da_cftime, da_datetime) + + +@pytest.mark.parametrize( + ('freq', 'expected'), + [('S', 'left'), ('T', 'left'), ('H', 'left'), ('D', 'left'), + ('M', 'right'), ('MS', 'left'), ('Q', 'right'), ('QS', 'left'), + ('A', 'right'), ('AS', 'left')]) +def test_closed_label_defaults(freq, expected): + assert CFTimeGrouper(freq=freq).closed == expected + assert CFTimeGrouper(freq=freq).label == expected + + @pytest.mark.parametrize('calendar', ['gregorian', 'noleap', 'all_leap', '360_day', 'julian']) def test_calendars(calendar): # Limited testing for non-standard calendars - freq, closed, label, base = '81T', None, None, 17 + freq, closed, label, base = '8001T', None, None, 17 loffset = datetime.timedelta(hours=12) xr_index = xr.cftime_range(start='2004-01-01T12:07:01', periods=7, freq='3D', calendar=calendar) From e8eb83bd730f3697b7026d9e5ef770a5235020e3 Mon Sep 17 00:00:00 2001 From: Kevin Squire Date: Sun, 3 Mar 2019 11:39:39 -0800 Subject: [PATCH 105/108] Add `Dataset.drop_dims` (#2767) * ENH: Add Dataset.drop_dims() * Drops full dimensions and any corresponding variables in a Dataset * Fixes GH1949 * DOC: Add Dataset.drop_dims() documentation --- doc/api.rst | 1 + doc/data-structures.rst | 7 +++++++ doc/indexing.rst | 11 +++++++++-- doc/whats-new.rst | 3 +++ xarray/core/dataset.py | 31 +++++++++++++++++++++++++++++++ xarray/tests/test_dataset.py | 20 ++++++++++++++++++++ 6 files changed, 71 insertions(+), 2 deletions(-) diff --git a/doc/api.rst b/doc/api.rst index 552582a553f..00b33959eed 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -87,6 +87,7 @@ Dataset contents Dataset.swap_dims Dataset.expand_dims Dataset.drop + Dataset.drop_dims Dataset.set_coords Dataset.reset_coords diff --git a/doc/data-structures.rst b/doc/data-structures.rst index 618ccccff3e..a8887471ec7 100644 --- a/doc/data-structures.rst +++ b/doc/data-structures.rst @@ -408,6 +408,13 @@ operations keep around coordinates: list(ds[['x']]) list(ds.drop('temperature')) +To remove a dimension, you can use :py:meth:`~xarray.Dataset.drop_dims` method. +Any variables using that dimension are dropped: + +.. ipython:: python + + ds.drop_dims('time') + As an alternate to dictionary-like modifications, you can use :py:meth:`~xarray.Dataset.assign` and :py:meth:`~xarray.Dataset.assign_coords`. These methods return a new dataset with additional (or replaced) or values: diff --git a/doc/indexing.rst b/doc/indexing.rst index 77ec7428991..9af9db227bc 100644 --- a/doc/indexing.rst +++ b/doc/indexing.rst @@ -229,8 +229,8 @@ arrays). However, you can do normal indexing with dimension names: Using indexing to *assign* values to a subset of dataset (e.g., ``ds[dict(space=0)] = 1``) is not yet supported. -Dropping labels ---------------- +Dropping labels and dimensions +------------------------------ The :py:meth:`~xarray.Dataset.drop` method returns a new object with the listed index labels along a dimension dropped: @@ -241,6 +241,13 @@ index labels along a dimension dropped: ``drop`` is both a ``Dataset`` and ``DataArray`` method. +Use :py:meth:`~xarray.Dataset.drop_dims` to drop a full dimension from a Dataset. +Any variables with these dimensions are also dropped: + +.. ipython:: python + + ds.drop_dims('time') + .. _masking with where: diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 090b6022b05..aad6bb41873 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -78,6 +78,9 @@ Enhancements serialization warnings raised if dates from a standard calendar are found to be outside the :py:class:`pandas.Timestamp`-valid range (:issue:`2754`). By `Spencer Clark `_. + +- Added :py:meth:`~xarray.Dataset.drop_dims` (:issue:`1949`). + By `Kevin Squire `_. Bug fixes ~~~~~~~~~ diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 7bb085848ef..f3e6cac1c5b 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -2797,6 +2797,37 @@ def _drop_vars(self, names): coord_names = set(k for k in self._coord_names if k in variables) return self._replace_vars_and_dims(variables, coord_names) + def drop_dims(self, drop_dims): + """Drop dimensions and associated variables from this dataset. + + Parameters + ---------- + drop_dims : str or list + Dimension or dimensions to drop. + + Returns + ------- + obj : Dataset + The dataset without the given dimensions (or any variables + containing those dimensions) + """ + if utils.is_scalar(drop_dims): + drop_dims = [drop_dims] + + missing_dimensions = [d for d in drop_dims if d not in self.dims] + if missing_dimensions: + raise ValueError('Dataset does not contain the dimensions: %s' + % missing_dimensions) + + drop_vars = set(k for k, v in self._variables.items() + for d in v.dims if d in drop_dims) + + variables = OrderedDict((k, v) for k, v in self._variables.items() + if k not in drop_vars) + coord_names = set(k for k in self._coord_names if k in variables) + + return self._replace_with_new_dims(variables, coord_names) + def transpose(self, *dims): """Return a new Dataset object with all array dimensions transposed. diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index c26968b1db0..7063e217ac2 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -1863,6 +1863,26 @@ def test_drop_index_labels(self): ValueError, 'does not have coordinate labels'): data.drop(1, 'y') + def test_drop_dims(self): + data = xr.Dataset({'A': (['x', 'y'], np.random.randn(2, 3)), + 'B': ('x', np.random.randn(2)), + 'x': ['a', 'b'], 'z': np.pi}) + + actual = data.drop_dims('x') + expected = data.drop(['A', 'B', 'x']) + assert_identical(expected, actual) + + actual = data.drop_dims('y') + expected = data.drop('A') + assert_identical(expected, actual) + + actual = data.drop_dims(['x', 'y']) + expected = data.drop(['A', 'B', 'x']) + assert_identical(expected, actual) + + with pytest.raises((ValueError, KeyError)): + data.drop_dims('z') # not a dimension + def test_copy(self): data = create_test_data() From c33dab237a0aca316b7f6d4ba10857829a895a25 Mon Sep 17 00:00:00 2001 From: Tom Nicholas <35968931+TomNicholas@users.noreply.github.com> Date: Mon, 4 Mar 2019 05:39:20 +0000 Subject: [PATCH 106/108] Improve name concat (#2792) * Added tests of desired name inferring behaviour * Infers names * updated what's new --- doc/whats-new.rst | 5 +++++ xarray/core/combine.py | 6 +++++- xarray/tests/test_combine.py | 9 +++++++++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index aad6bb41873..4218771848c 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -110,6 +110,11 @@ Bug fixes - Fixed error when trying to reduce a DataArray using a function which does not require an axis argument. (:issue:`2768`) By `Tom Nicholas `_. +- Concatenating a sequence of :py:class:`~xarray.DataArray` with varying names + sets the name of the output array to ``None``, instead of the name of the + first input array. If the names are the same it sets the name to that, + instead to the name of the first DataArray in the list as it did before. + (:issue:`2775`). By `Tom Nicholas `_. - Per `CF conventions `_, diff --git a/xarray/core/combine.py b/xarray/core/combine.py index 11961dff520..1abd14cd20b 100644 --- a/xarray/core/combine.py +++ b/xarray/core/combine.py @@ -9,6 +9,7 @@ from .merge import merge from .variable import IndexVariable, Variable, as_variable from .variable import concat as concat_vars +from .computation import result_name def concat(objs, dim=None, data_vars='all', coords='different', @@ -336,7 +337,10 @@ def _dataarray_concat(arrays, dim, data_vars, coords, compat, ds = _dataset_concat(datasets, dim, data_vars, coords, compat, positions) - return arrays[0]._from_temp_dataset(ds, name) + result = arrays[0]._from_temp_dataset(ds, name) + + result.name = result_name(arrays) + return result def _auto_concat(datasets, dim=None, data_vars='all', coords='different'): diff --git a/xarray/tests/test_combine.py b/xarray/tests/test_combine.py index c37abc98f07..0d03b6e0cdf 100644 --- a/xarray/tests/test_combine.py +++ b/xarray/tests/test_combine.py @@ -285,6 +285,15 @@ def test_concat_encoding(self): assert concat([foo, foo], dim="x").encoding == foo.encoding assert concat([ds, ds], dim="x").encoding == ds.encoding + @pytest.mark.parametrize("colors, expected_name", + [(['blue', 'green', 'red'], None), + (['red', 'red', 'red'], 'red')]) + def test_concat_determine_name(self, colors, expected_name): + das = [DataArray(np.random.random((2, 2)), dims=['x', 'y'], name=k) + for k in colors] + result = concat(das, dim="band") + assert result.name is expected_name + @requires_dask def test_concat_lazy(self): import dask.array as da From 0c534b00ef6463239320475eccd1ef3f12ebf6b7 Mon Sep 17 00:00:00 2001 From: TimoRoth Date: Wed, 6 Mar 2019 00:00:28 +0100 Subject: [PATCH 107/108] Don't use deprecated np.asscalar() (#2800) It got deprecated in numpy 1.16 and throws a ton of warnings due to that. All the function does is returning .item() anyway, which is why it got deprecated. --- xarray/convert.py | 2 +- xarray/core/utils.py | 2 +- xarray/tests/test_dataarray.py | 2 +- xarray/tests/test_dataset.py | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/xarray/convert.py b/xarray/convert.py index efcdd079a9f..b8c0c2a7eca 100644 --- a/xarray/convert.py +++ b/xarray/convert.py @@ -247,7 +247,7 @@ def from_iris(cube): if coord_dims: coords[_name(coord)] = (coord_dims, coord.points, coord_attrs) else: - coords[_name(coord)] = ((), np.asscalar(coord.points), coord_attrs) + coords[_name(coord)] = ((), coord.points.item(), coord_attrs) array_attrs = _iris_obj_to_attrs(cube) cell_methods = _iris_cell_methods_to_str(cube.cell_methods) diff --git a/xarray/core/utils.py b/xarray/core/utils.py index 053a45f01cb..fd1330a4e1f 100644 --- a/xarray/core/utils.py +++ b/xarray/core/utils.py @@ -550,7 +550,7 @@ def decode_numpy_dict_values(attrs): if isinstance(v, np.ndarray): attrs[k] = v.tolist() elif isinstance(v, np.generic): - attrs[k] = np.asscalar(v) + attrs[k] = v.item() return attrs diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index 09c0f003888..ab05f19dbbe 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -2963,7 +2963,7 @@ def test_to_dict_with_numpy_attrs(self): 'maintainer': 'bar'} da = DataArray(x, {'t': t, 'lat': lat}, dims=['t', 'lat'], attrs=attrs) - expected_attrs = {'created': np.asscalar(attrs['created']), + expected_attrs = {'created': attrs['created'].item(), 'coords': attrs['coords'].tolist(), 'maintainer': 'bar'} actual = da.to_dict() diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 7063e217ac2..d130363a7c0 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -3152,7 +3152,7 @@ def test_to_dict_with_numpy_attrs(self): ds = Dataset(OrderedDict([('a', ('t', x, attrs)), ('b', ('t', y, attrs)), ('t', ('t', t))])) - expected_attrs = {'created': np.asscalar(attrs['created']), + expected_attrs = {'created': attrs['created'].item(), 'coords': attrs['coords'].tolist(), 'maintainer': 'bar'} actual = ds.to_dict() From c770eec39c401d49d01ec87c5c8499893da08cb5 Mon Sep 17 00:00:00 2001 From: Spencer Clark Date: Wed, 6 Mar 2019 14:47:47 -0500 Subject: [PATCH 108/108] Add support for cftime.datetime coordinates with coarsen (#2778) --- doc/whats-new.rst | 4 ++++ xarray/core/common.py | 13 +++++++++---- xarray/core/duck_array_ops.py | 26 +++++++++++++++++++++++--- xarray/tests/test_dataset.py | 11 ++++++++++- xarray/tests/test_duck_array_ops.py | 25 +++++++++++++++++++++++++ 5 files changed, 71 insertions(+), 8 deletions(-) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index 4218771848c..260c20d0b31 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -45,6 +45,10 @@ Enhancements See :ref:`comput.coarsen` for details. (:issue:`2525`) By `Keisuke Fujii `_. +- Taking the mean of arrays of :py:class:`cftime.datetime` objects, and + by extension, use of :py:meth:`~xarray.DataArray.coarsen` with + :py:class:`cftime.datetime` coordinates is now possible. By `Spencer Clark + `_. - Upsampling an array via interpolation with resample is now dask-compatible, as long as the array is not chunked along the resampling dimension. By `Spencer Clark `_. diff --git a/xarray/core/common.py b/xarray/core/common.py index 2f32ca941be..6ec07156160 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -997,15 +997,15 @@ def is_np_datetime_like(dtype): np.issubdtype(dtype, np.timedelta64)) -def contains_cftime_datetimes(var): - """Check if a variable contains cftime datetime objects""" +def _contains_cftime_datetimes(array): + """Check if an array contains cftime.datetime objects""" try: from cftime import datetime as cftime_datetime except ImportError: return False else: - if var.dtype == np.dtype('O') and var.data.size > 0: - sample = var.data.ravel()[0] + if array.dtype == np.dtype('O') and array.size > 0: + sample = array.ravel()[0] if isinstance(sample, dask_array_type): sample = sample.compute() if isinstance(sample, np.ndarray): @@ -1015,6 +1015,11 @@ def contains_cftime_datetimes(var): return False +def contains_cftime_datetimes(var): + """Check if an xarray.Variable contains cftime.datetime objects""" + return _contains_cftime_datetimes(var.data) + + def _contains_datetime_like_objects(var): """Check if a variable contains datetime like objects (either np.datetime64, np.timedelta64, or cftime.datetime)""" diff --git a/xarray/core/duck_array_ops.py b/xarray/core/duck_array_ops.py index 4d6d716a164..b67a220ed4c 100644 --- a/xarray/core/duck_array_ops.py +++ b/xarray/core/duck_array_ops.py @@ -294,7 +294,7 @@ def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): Parameters ---------- - da : array + da : np.array Input data offset: Scalar with the same type of array or None If None, subtract minimum values to reduce round off error @@ -306,6 +306,7 @@ def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): ------- array """ + # TODO: make this function dask-compatible? if offset is None: offset = array.min() array = array - offset @@ -326,15 +327,34 @@ def datetime_to_numeric(array, offset=None, datetime_unit=None, dtype=float): return array.astype(dtype) +def _to_pytimedelta(array, unit='us'): + index = pd.TimedeltaIndex(array.ravel(), unit=unit) + return index.to_pytimedelta().reshape(array.shape) + + def mean(array, axis=None, skipna=None, **kwargs): - """ inhouse mean that can handle datatime dtype """ + """inhouse mean that can handle np.datetime64 or cftime.datetime + dtypes""" + from .common import _contains_cftime_datetimes + array = asarray(array) if array.dtype.kind in 'Mm': offset = min(array) - # xarray always uses datetime[ns] for datetime + # xarray always uses np.datetime64[ns] for np.datetime64 data dtype = 'timedelta64[ns]' return _mean(datetime_to_numeric(array, offset), axis=axis, skipna=skipna, **kwargs).astype(dtype) + offset + elif _contains_cftime_datetimes(array): + if isinstance(array, dask_array_type): + raise NotImplementedError( + 'Computing the mean of an array containing ' + 'cftime.datetime objects is not yet implemented on ' + 'dask arrays.') + offset = min(array) + timedeltas = datetime_to_numeric(array, offset, datetime_unit='us') + mean_timedeltas = _mean(timedeltas, axis=axis, skipna=skipna, + **kwargs) + return _to_pytimedelta(mean_timedeltas, unit='us') + offset else: return _mean(array, axis=axis, skipna=skipna, **kwargs) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index d130363a7c0..8e8c6c4b419 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -23,7 +23,7 @@ InaccessibleArray, UnexpectedDataAccess, assert_allclose, assert_array_equal, assert_equal, assert_identical, has_cftime, has_dask, raises_regex, requires_bottleneck, requires_dask, requires_scipy, - source_ndarray) + source_ndarray, requires_cftime) try: import dask.array as da @@ -4530,6 +4530,15 @@ def test_coarsen_coords(ds, dask): actual = da.coarsen(time=2).mean() +@requires_cftime +def test_coarsen_coords_cftime(): + times = xr.cftime_range('2000', periods=6) + da = xr.DataArray(range(6), [('time', times)]) + actual = da.coarsen(time=3).mean() + expected_times = xr.cftime_range('2000-01-02', freq='3D', periods=2) + np.testing.assert_array_equal(actual.time, expected_times) + + def test_rolling_properties(ds): # catching invalid args with pytest.raises(ValueError) as exception: diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index ab3cafed449..5d425f648bd 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/xarray/tests/test_duck_array_ops.py @@ -270,6 +270,31 @@ def test_datetime_reduce(dask): assert da['time'][0].mean() == da['time'][:1].mean() +@requires_cftime +def test_cftime_datetime_mean(): + times = cftime_range('2000', periods=4) + da = DataArray(times, dims=['time']) + + assert da.isel(time=0).mean() == da.isel(time=0) + + expected = DataArray(times.date_type(2000, 1, 2, 12)) + result = da.mean() + assert_equal(result, expected) + + da_2d = DataArray(times.values.reshape(2, 2)) + result = da_2d.mean() + assert_equal(result, expected) + + +@requires_cftime +@requires_dask +def test_cftime_datetime_mean_dask_error(): + times = cftime_range('2000', periods=4) + da = DataArray(times, dims=['time']).chunk() + with pytest.raises(NotImplementedError): + da.mean() + + @pytest.mark.parametrize('dim_num', [1, 2]) @pytest.mark.parametrize('dtype', [float, int, np.float32, np.bool_]) @pytest.mark.parametrize('dask', [False, True])