Silencing numpy warnings (#4369)

* WIP on silencing numpy warnings

* Remove testing expected warning

* Remove ignore warnings in tests; add xfail test for corner case

* _

* @keewis feedback

* Formatting

* Update xarray/tests/test_dataset.py

Co-authored-by: keewis <[email protected]>

* Update xarray/core/dataarray.py

* whatsnew

* Add note to xfailing test

* _

* Pacify pylance linter

* Add more tests for no errors

* Convert to docstring

Co-authored-by: keewis <[email protected]>

Author: max-sixty

doc/whats-new.rst

@@ -105,6 +105,8 @@ Internal Changes
   By `Maximilian Roos <https://github.com/max-sixty>`_
 - Only load resource files when running inside a Jupyter Notebook
   (:issue:`4294`) By `Guido Imperiale <https://github.com/crusaderky>`_
+- Silenced most ``numpy`` warnings such as ``Mean of empty slice``. (:pull:`4369`)
+  By `Maximilian Roos <https://github.com/max-sixty>`_
 - Enable type checking for :py:func:`concat` (:issue:`4238`)
   By `Mathias Hauser <https://github.com/mathause>`_.
 - Updated plot functions for matplotlib version 3.3 and silenced warnings in the

xarray/core/dataarray.py

@@ -1,5 +1,6 @@
 import datetime
 import functools
+import warnings
 from numbers import Number
 from typing import (
     TYPE_CHECKING,
@@ -1583,9 +1584,7 @@ def swap_dims(self, dims_dict: Mapping[Hashable, Hashable]) -> "DataArray":
         --------
 
         >>> arr = xr.DataArray(
-        ...     data=[0, 1],
-        ...     dims="x",
-        ...     coords={"x": ["a", "b"], "y": ("x", [0, 1])},
+        ...     data=[0, 1], dims="x", coords={"x": ["a", "b"], "y": ("x", [0, 1])},
         ... )
         >>> arr
         <xarray.DataArray (x: 2)>
@@ -2709,8 +2708,13 @@ def __rmatmul__(self, other):
     def _unary_op(f: Callable[..., Any]) -> Callable[..., "DataArray"]:
         @functools.wraps(f)
         def func(self, *args, **kwargs):
-            with np.errstate(all="ignore"):
-                return self.__array_wrap__(f(self.variable.data, *args, **kwargs))
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", r"All-NaN (slice|axis) encountered")
+                warnings.filterwarnings(
+                    "ignore", r"Mean of empty slice", category=RuntimeWarning
+                )
+                with np.errstate(all="ignore"):
+                    return self.__array_wrap__(f(self.variable.data, *args, **kwargs))
 
         return func
 
@@ -3424,9 +3428,7 @@ def map_blocks(
         to the function being applied in ``xr.map_blocks()``:
 
         >>> array.map_blocks(
-        ...     calculate_anomaly,
-        ...     kwargs={"groupby_type": "time.year"},
-        ...     template=array,
+        ...     calculate_anomaly, kwargs={"groupby_type": "time.year"}, template=array,
         ... )  # doctest: +ELLIPSIS
         <xarray.DataArray (time: 24)>
         dask.array<calculate_anomaly-...-<this, shape=(24,), dtype=float64, chunksize=(24,), chunktype=numpy.ndarray>

xarray/core/nanops.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 
 from . import dtypes, nputils, utils
@@ -133,10 +135,14 @@ def nanmean(a, axis=None, dtype=None, out=None):
     if a.dtype.kind == "O":
         return _nanmean_ddof_object(0, a, axis=axis, dtype=dtype)
 
-    if isinstance(a, dask_array_type):
-        return dask_array.nanmean(a, axis=axis, dtype=dtype)
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore", r"Mean of empty slice", category=RuntimeWarning
+        )
+        if isinstance(a, dask_array_type):
+            return dask_array.nanmean(a, axis=axis, dtype=dtype)
 
-    return np.nanmean(a, axis=axis, dtype=dtype)
+        return np.nanmean(a, axis=axis, dtype=dtype)
 
 
 def nanmedian(a, axis=None, out=None):

xarray/core/variable.py

@@ -1635,10 +1635,14 @@ def reduce(
 
         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)
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore", r"Mean of empty slice", category=RuntimeWarning
+            )
+            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

xarray/tests/test_dataarray.py

@@ -6186,24 +6186,21 @@ def test_isin(da):
     assert_equal(result, expected)
 
 
+@pytest.mark.filterwarnings("error:Mean of empty slice")
 @pytest.mark.parametrize("da", (1, 2), indirect=True)
 def test_rolling_iter(da):
 
     rolling_obj = da.rolling(time=7)
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", "Mean of empty slice")
-        rolling_obj_mean = rolling_obj.mean()
+    rolling_obj_mean = rolling_obj.mean()
 
     assert len(rolling_obj.window_labels) == len(da["time"])
     assert_identical(rolling_obj.window_labels, da["time"])
 
     for i, (label, window_da) in enumerate(rolling_obj):
         assert label == da["time"].isel(time=i)
 
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "Mean of empty slice")
-            actual = rolling_obj_mean.isel(time=i)
-            expected = window_da.mean("time")
+        actual = rolling_obj_mean.isel(time=i)
+        expected = window_da.mean("time")
 
         # TODO add assert_allclose_with_nan, which compares nan position
         # as well as the closeness of the values.
@@ -6489,6 +6486,11 @@ def test_raise_no_warning_for_nan_in_binary_ops():
     assert len(record) == 0
 
 
+@pytest.mark.filterwarnings("error")
+def test_no_warning_for_all_nan():
+    _ = xr.DataArray([np.NaN, np.NaN]).mean()
+
+
 def test_name_in_masking():
     name = "RingoStarr"
     da = xr.DataArray(range(10), coords=[("x", range(10))], name=name)

xarray/tests/test_dataset.py

@@ -6027,6 +6027,8 @@ def test_rolling_wrapped_bottleneck(ds, name, center, min_periods, key):
         expected = getattr(bn, func_name)(
             ds[key].values, window=7, axis=0, min_count=min_periods
         )
+    else:
+        raise ValueError
     assert_array_equal(actual[key].values, expected)
 
     # Test center
@@ -6191,6 +6193,32 @@ def test_raise_no_warning_for_nan_in_binary_ops():
     assert len(record) == 0
 
 
+@pytest.mark.filterwarnings("error")
+@pytest.mark.parametrize("ds", (2,), indirect=True)
+def test_raise_no_warning_assert_close(ds):
+    assert_allclose(ds, ds)
+
+
+@pytest.mark.xfail(reason="See https://github.com/pydata/xarray/pull/4369 or docstring")
+@pytest.mark.filterwarnings("error")
+@pytest.mark.parametrize("ds", (2,), indirect=True)
+@pytest.mark.parametrize("name", ("mean", "max"))
+def test_raise_no_warning_dask_rolling_assert_close(ds, name):
+    """
+    This is a puzzle — I can't easily find the source of the warning. It
+    requires `assert_allclose` to be run, for the `ds` param to be 2, and is
+    different for `mean` and `max`. `sum` raises no warning.
+    """
+
+    ds = ds.chunk({"x": 4})
+
+    rolling_obj = ds.rolling(time=4, x=3)
+
+    actual = getattr(rolling_obj, name)()
+    expected = getattr(getattr(ds.rolling(time=4), name)().rolling(x=3), name)()
+    assert_allclose(actual, expected)
+
+
 @pytest.mark.parametrize("dask", [True, False])
 @pytest.mark.parametrize("edge_order", [1, 2])
 def test_differentiate(dask, edge_order):

xarray/tests/test_duck_array_ops.py

@@ -120,11 +120,9 @@ def test_concatenate_type_promotion(self):
         result = concatenate([[1], ["b"]])
         assert_array_equal(result, np.array([1, "b"], dtype=object))
 
+    @pytest.mark.filterwarnings("error")
     def test_all_nan_arrays(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "All-NaN slice")
-            warnings.filterwarnings("ignore", "Mean of empty slice")
-            assert np.isnan(mean([np.nan, np.nan]))
+        assert np.isnan(mean([np.nan, np.nan]))
 
 
 def test_cumsum_1d():

xarray/tests/test_groupby.py

@@ -447,8 +447,7 @@ def test_groupby_drops_nans():
 
     # reduction operation along a different dimension
     actual = grouped.mean("time")
-    with pytest.warns(RuntimeWarning):  # mean of empty slice
-        expected = ds.mean("time").where(ds.id.notnull())
+    expected = ds.mean("time").where(ds.id.notnull())
     assert_identical(actual, expected)
 
     # NaN in non-dimensional coordinate

xarray/tests/test_weighted.py

@@ -119,7 +119,7 @@ def test_weighted_sum_nan(weights, expected, skipna):
     assert_equal(expected, result)
 
 
-@pytest.mark.filterwarnings("ignore:Mean of empty slice")
+@pytest.mark.filterwarnings("error")
 @pytest.mark.parametrize("da", ([1.0, 2], [1, np.nan], [np.nan, np.nan]))
 @pytest.mark.parametrize("skipna", (True, False))
 @pytest.mark.parametrize("factor", [1, 2, 3.14])