Merge remote-tracking branch 'upstream/main' into sparse-unstack

dcherian · dcherian · commit 79e2cdd316b0 · 2021-12-01T19:14:18.000-07:00
* upstream/main: fix grammatical typo in docs (pydata#6034) Use condas dask-core in ci instead of dask to speedup ci and reduce dependencies (pydata#6007) Use complex nan by default when interpolating out of bounds (pydata#6019) Simplify missing value handling in xarray.corr (pydata#6025) Add pyXpcm to Related Projects doc page (pydata#6031) Make xr.corr and xr.map_blocks work without dask (pydata#5731)
diff --git a/ci/requirements/doc.yml b/ci/requirements/doc.yml
@@ -8,7 +8,7 @@ dependencies:
   - bottleneck
   - cartopy
   - cfgrib>=0.9
-  - dask>=2.10
+  - dask-core>=2.30
   - h5netcdf>=0.7.4
   - ipykernel
   - ipython
diff --git a/ci/requirements/environment-windows.yml b/ci/requirements/environment-windows.yml
@@ -8,7 +8,7 @@ dependencies:
   # - cdms2  # Not available on Windows
   # - cfgrib  # Causes Python interpreter crash on Windows: https://github.com/pydata/xarray/pull/3340
   - cftime
-  - dask
+  - dask-core
   - distributed
   - fsspec!=2021.7.0
   - h5netcdf
diff --git a/ci/requirements/environment.yml b/ci/requirements/environment.yml
@@ -10,7 +10,7 @@ dependencies:
   - cdms2
   - cfgrib
   - cftime
-  - dask
+  - dask-core
   - distributed
   - fsspec!=2021.7.0
   - h5netcdf
diff --git a/ci/requirements/py37-min-all-deps.yml b/ci/requirements/py37-min-all-deps.yml
@@ -16,7 +16,7 @@ dependencies:
   - cfgrib=0.9
   - cftime=1.2
   - coveralls
-  - dask=2.30
+  - dask-core=2.30
   - distributed=2.30
   - h5netcdf=0.8
   - h5py=2.10
diff --git a/doc/ecosystem.rst b/doc/ecosystem.rst
@@ -13,6 +13,7 @@ Geosciences
 ~~~~~~~~~~~
 
 - `aospy <https://aospy.readthedocs.io>`_: Automated analysis and management of gridded climate data.
+- `argopy <https://github.com/euroargodev/argopy>`_: xarray-based Argo data access, manipulation and visualisation for standard users as well as Argo experts.
 - `climpred <https://climpred.readthedocs.io>`_: Analysis of ensemble forecast models for climate prediction.
 - `geocube <https://corteva.github.io/geocube>`_: Tool to convert geopandas vector data into rasterized xarray data.
 - `GeoWombat <https://github.com/jgrss/geowombat>`_: Utilities for analysis of remotely sensed and gridded raster data at scale (easily tame Landsat, Sentinel, Quickbird, and PlanetScope).
diff --git a/doc/user-guide/computation.rst b/doc/user-guide/computation.rst
@@ -546,7 +546,7 @@ two gaussian peaks:
 Broadcasting by dimension name
 ==============================
 
-``DataArray`` objects are automatically align themselves ("broadcasting" in
+``DataArray`` objects automatically align themselves ("broadcasting" in
 the numpy parlance) by dimension name instead of axis order. With xarray, you
 do not need to transpose arrays or insert dimensions of length 1 to get array
 operations to work, as commonly done in numpy with :py:func:`numpy.reshape` or
diff --git a/doc/whats-new.rst b/doc/whats-new.rst
@@ -26,14 +26,17 @@ New Features
 
 Breaking changes
 ~~~~~~~~~~~~~~~~
-
+- Use complex nan when interpolating complex values out of bounds by default (instead of real nan) (:pull:`6019`).
+  By `Alexandre Poux <https://github.com/pums974>`_.
 
 Deprecations
 ~~~~~~~~~~~~
 
 
 Bug fixes
 ~~~~~~~~~
+- :py:func:`xr.map_blocks` and :py:func:`xr.corr` now work when dask is not installed (:issue:`3391`, :issue:`5715`, :pull:`5731`).
+  By `Gijom <https://github.com/Gijom>`_.
 - Fix plot.line crash for data of shape ``(1, N)`` in _title_for_slice on format_item (:pull:`5948`).
   By `Sebastian Weigand <https://github.com/s-weigand>`_.
 - Fix a regression in the removal of duplicate backend entrypoints (:issue:`5944`, :pull:`5959`)
diff --git a/xarray/core/computation.py b/xarray/core/computation.py
@@ -1346,24 +1346,10 @@ def _cov_corr(da_a, da_b, dim=None, ddof=0, method=None):
 
     # 2. Ignore the nans
     valid_values = da_a.notnull() & da_b.notnull()
+    da_a = da_a.where(valid_values)
+    da_b = da_b.where(valid_values)
     valid_count = valid_values.sum(dim) - ddof
 
-    def _get_valid_values(da, other):
-        """
-        Function to lazily mask da_a and da_b
-        following a similar approach to
-        https://github.com/pydata/xarray/pull/4559
-        """
-        missing_vals = np.logical_or(da.isnull(), other.isnull())
-        if missing_vals.any():
-            da = da.where(~missing_vals)
-            return da
-        else:
-            return da
-
-    da_a = da_a.map_blocks(_get_valid_values, args=[da_b])
-    da_b = da_b.map_blocks(_get_valid_values, args=[da_a])
-
     # 3. Detrend along the given dim
     demeaned_da_a = da_a - da_a.mean(dim=dim)
     demeaned_da_b = da_b - da_b.mean(dim=dim)
diff --git a/xarray/core/missing.py b/xarray/core/missing.py
@@ -82,9 +82,11 @@ def __init__(self, xi, yi, method="linear", fill_value=None, period=None):
         self._xi = xi
         self._yi = yi
 
+        nan = np.nan if yi.dtype.kind != "c" else np.nan + np.nan * 1j
+
         if fill_value is None:
-            self._left = np.nan
-            self._right = np.nan
+            self._left = nan
+            self._right = nan
         elif isinstance(fill_value, Sequence) and len(fill_value) == 2:
             self._left = fill_value[0]
             self._right = fill_value[1]
@@ -143,10 +145,12 @@ def __init__(
         self.cons_kwargs = kwargs
         self.call_kwargs = {}
 
+        nan = np.nan if yi.dtype.kind != "c" else np.nan + np.nan * 1j
+
         if fill_value is None and method == "linear":
-            fill_value = np.nan, np.nan
+            fill_value = nan, nan
         elif fill_value is None:
-            fill_value = np.nan
+            fill_value = nan
 
         self.f = interp1d(
             xi,
diff --git a/xarray/core/parallel.py b/xarray/core/parallel.py
@@ -23,6 +23,7 @@
 from .alignment import align
 from .dataarray import DataArray
 from .dataset import Dataset
+from .pycompat import is_dask_collection
 
 try:
     import dask
@@ -328,13 +329,13 @@ def _wrapper(
         raise TypeError("kwargs must be a mapping (for example, a dict)")
 
     for value in kwargs.values():
-        if dask.is_dask_collection(value):
+        if is_dask_collection(value):
             raise TypeError(
                 "Cannot pass dask collections in kwargs yet. Please compute or "
                 "load values before passing to map_blocks."
             )
 
-    if not dask.is_dask_collection(obj):
+    if not is_dask_collection(obj):
         return func(obj, *args, **kwargs)
 
     all_args = [obj] + list(args)
diff --git a/xarray/core/pycompat.py b/xarray/core/pycompat.py
@@ -43,15 +43,19 @@ def __init__(self, mod):
         self.available = duck_array_module is not None
 
 
-def is_duck_dask_array(x):
+def is_dask_collection(x):
     if DuckArrayModule("dask").available:
         from dask.base import is_dask_collection
 
-        return is_duck_array(x) and is_dask_collection(x)
+        return is_dask_collection(x)
     else:
         return False
 
 
+def is_duck_dask_array(x):
+    return is_duck_array(x) and is_dask_collection(x)
+
+
 dsk = DuckArrayModule("dask")
 dask_version = dsk.version
 dask_array_type = dsk.type
diff --git a/xarray/tests/test_computation.py b/xarray/tests/test_computation.py
@@ -24,8 +24,6 @@
 
 from . import has_dask, raise_if_dask_computes, requires_dask
 
-dask = pytest.importorskip("dask")
-
 
 def assert_identical(a, b):
     """A version of this function which accepts numpy arrays"""
@@ -1420,6 +1418,7 @@ def arrays_w_tuples():
     ],
 )
 @pytest.mark.parametrize("dim", [None, "x", "time"])
+@requires_dask
 def test_lazy_corrcov(da_a, da_b, dim, ddof) -> None:
     # GH 5284
     from dask import is_dask_collection
@@ -1554,6 +1553,28 @@ def test_covcorr_consistency(da_a, da_b, dim) -> None:
     assert_allclose(actual, expected)
 
 
+@requires_dask
+@pytest.mark.parametrize("da_a, da_b", arrays_w_tuples()[1])
+@pytest.mark.parametrize("dim", [None, "time", "x"])
+def test_corr_lazycorr_consistency(da_a, da_b, dim) -> None:
+    da_al = da_a.chunk()
+    da_bl = da_b.chunk()
+    c_abl = xr.corr(da_al, da_bl, dim=dim)
+    c_ab = xr.corr(da_a, da_b, dim=dim)
+    c_ab_mixed = xr.corr(da_a, da_bl, dim=dim)
+    assert_allclose(c_ab, c_abl)
+    assert_allclose(c_ab, c_ab_mixed)
+
+
+@requires_dask
+def test_corr_dtype_error():
+    da_a = xr.DataArray([[1, 2], [2, 1]], dims=["x", "time"])
+    da_b = xr.DataArray([[1, 2], [1, np.nan]], dims=["x", "time"])
+
+    xr.testing.assert_equal(xr.corr(da_a, da_b), xr.corr(da_a.chunk(), da_b.chunk()))
+    xr.testing.assert_equal(xr.corr(da_a, da_b), xr.corr(da_a, da_b.chunk()))
+
+
 @pytest.mark.parametrize(
     "da_a",
     arrays_w_tuples()[0],
diff --git a/xarray/tests/test_interp.py b/xarray/tests/test_interp.py
@@ -907,3 +907,16 @@ def test_coord_attrs(x, expect_same_attrs):
 
     has_same_attrs = ds.interp(x=x).x.attrs == base_attrs
     assert expect_same_attrs == has_same_attrs
+
+
+@requires_scipy
+def test_interp1d_complex_out_of_bounds():
+    """Ensure complex nans are used by default"""
+    da = xr.DataArray(
+        np.exp(0.3j * np.arange(4)),
+        [("time", np.arange(4))],
+    )
+
+    expected = da.interp(time=3.5, kwargs=dict(fill_value=np.nan + np.nan * 1j))
+    actual = da.interp(time=3.5)
+    assert_identical(actual, expected)
diff --git a/xarray/tests/test_missing.py b/xarray/tests/test_missing.py
@@ -687,3 +687,25 @@ def test_interpolate_na_2d(coords):
         coords=coords,
     )
     assert_equal(actual, expected_x)
+
+
+@requires_scipy
+def test_interpolators_complex_out_of_bounds():
+    """Ensure complex nans are used for complex data"""
+
+    xi = np.array([-1, 0, 1, 2, 5], dtype=np.float64)
+    yi = np.exp(1j * xi)
+    x = np.array([-2, 1, 6], dtype=np.float64)
+
+    expected = np.array(
+        [np.nan + np.nan * 1j, np.exp(1j), np.nan + np.nan * 1j], dtype=yi.dtype
+    )
+
+    for method, interpolator in [
+        ("linear", NumpyInterpolator),
+        ("linear", ScipyInterpolator),
+    ]:
+
+        f = interpolator(xi, yi, method=method)
+        actual = f(x)
+        assert_array_equal(actual, expected)
