Remove some warnings in tests

xarray/coding/times.py

@@ -362,7 +362,7 @@ def infer_calendar_name(dates) -> CFCalendar:
     elif dates.dtype == np.dtype("O") and dates.size > 0:
         # Logic copied from core.common.contains_cftime_datetimes.
         if cftime is not None:
-            sample = dates.ravel()[0]
+            sample = np.asarray(dates).flat[0]
             if is_duck_dask_array(sample):
                 sample = sample.compute()
                 if isinstance(sample, np.ndarray):
@@ -587,7 +587,7 @@ def encode_datetime(d):
 
 
 def cast_to_int_if_safe(num):
-    int_num = np.array(num, dtype=np.int64)
+    int_num = np.asarray(num, dtype=np.int64)
     if (num == int_num).all():
         num = int_num
     return num

xarray/core/common.py

@@ -1076,7 +1076,9 @@ def _dataarray_indexer(dim: Hashable) -> DataArray:
                 return cond.any(dim=(d for d in cond.dims if d != dim))
 
             def _dataset_indexer(dim: Hashable) -> DataArray:
-                cond_wdim = cond.drop(var for var in cond if dim not in cond[var].dims)
+                cond_wdim = cond.drop_vars(
+                    var for var in cond if dim not in cond[var].dims
+                )
                 keepany = cond_wdim.any(dim=(d for d in cond.dims.keys() if d != dim))
                 return keepany.to_array().any("variable")
 
@@ -1758,7 +1760,7 @@ def _contains_cftime_datetimes(array) -> bool:
         return False
     else:
         if array.dtype == np.dtype("O") and array.size > 0:
-            sample = array.ravel()[0]
+            sample = np.asarray(array).flat[0]
             if is_duck_dask_array(sample):
                 sample = sample.compute()
                 if isinstance(sample, np.ndarray):

xarray/core/merge.py

@@ -487,7 +487,7 @@ def coerce_pandas_values(objects: Iterable[CoercibleMapping]) -> list[DatasetLik
         else:
             variables = {}
             if isinstance(obj, PANDAS_TYPES):
-                obj = dict(obj.iteritems())
+                obj = dict(obj.items())
             for k, v in obj.items():
                 if isinstance(v, PANDAS_TYPES):
                     v = DataArray(v)

xarray/tests/test_array_api.py

@@ -1,4 +1,6 @@
-from typing import Tuple
+from __future__ import annotations
+
+import warnings
 
 import pytest
 
@@ -7,49 +9,51 @@
 
 np = pytest.importorskip("numpy", minversion="1.22")
 
-import numpy.array_api as xp  # isort:skip
-from numpy.array_api._array_object import Array  # isort:skip
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    import numpy.array_api as xp  # isort:skip
+    from numpy.array_api._array_object import Array  # isort:skip
 
 
 @pytest.fixture
-def arrays() -> Tuple[xr.DataArray, xr.DataArray]:
+def arrays() -> tuple[xr.DataArray, xr.DataArray]:
     np_arr = xr.DataArray(np.ones((2, 3)), dims=("x", "y"), coords={"x": [10, 20]})
     xp_arr = xr.DataArray(xp.ones((2, 3)), dims=("x", "y"), coords={"x": [10, 20]})
     assert isinstance(xp_arr.data, Array)
     return np_arr, xp_arr
 
 
-def test_arithmetic(arrays) -> None:
+def test_arithmetic(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr + 7
     actual = xp_arr + 7
     assert isinstance(actual.data, Array)
     assert_equal(actual, expected)
 
 
-def test_aggregation(arrays) -> None:
+def test_aggregation(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr.sum(skipna=False)
     actual = xp_arr.sum(skipna=False)
     assert isinstance(actual.data, Array)
     assert_equal(actual, expected)
 
 
-def test_indexing(arrays) -> None:
+def test_indexing(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr[:, 0]
     actual = xp_arr[:, 0]
     assert isinstance(actual.data, Array)
     assert_equal(actual, expected)
 
 
-def test_properties(arrays) -> None:
+def test_properties(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     assert np_arr.nbytes == np_arr.data.nbytes
     assert xp_arr.nbytes == np_arr.data.nbytes
 
 
-def test_reorganizing_operation(arrays) -> None:
+def test_reorganizing_operation(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr.transpose()
     actual = xp_arr.transpose()

xarray/tests/test_duck_array_ops.py

@@ -286,9 +286,9 @@ def assert_dask_array(da, dask):
 
 
 @arm_xfail
-@pytest.mark.filterwarnings("ignore::RuntimeWarning")
+@pytest.mark.filterwarnings("ignore:All-NaN .* encountered:RuntimeWarning")
 @pytest.mark.parametrize("dask", [False, True] if has_dask else [False])
-def test_datetime_mean(dask):
+def test_datetime_mean(dask: bool) -> None:
     # Note: only testing numpy, as dask is broken upstream
     da = DataArray(
         np.array(["2010-01-01", "NaT", "2010-01-03", "NaT", "NaT"], dtype="M8[ns]"),

xarray/tests/test_weighted.py

@@ -6,28 +6,28 @@
 import pytest
 
 import xarray as xr
-from xarray import DataArray
+from xarray import DataArray, Dataset
 from xarray.tests import assert_allclose, assert_equal
 
 from . import raise_if_dask_computes, requires_cftime, requires_dask
 
 
 @pytest.mark.parametrize("as_dataset", (True, False))
-def test_weighted_non_DataArray_weights(as_dataset):
+def test_weighted_non_DataArray_weights(as_dataset: bool) -> None:
 
-    data = DataArray([1, 2])
+    data: DataArray | Dataset = DataArray([1, 2])
     if as_dataset:
         data = data.to_dataset(name="data")
 
     with pytest.raises(ValueError, match=r"`weights` must be a DataArray"):
-        data.weighted([1, 2])
+        data.weighted([1, 2])  # type: ignore
 
 
 @pytest.mark.parametrize("as_dataset", (True, False))
 @pytest.mark.parametrize("weights", ([np.nan, 2], [np.nan, np.nan]))
-def test_weighted_weights_nan_raises(as_dataset, weights):
+def test_weighted_weights_nan_raises(as_dataset: bool, weights: list[float]) -> None:
 
-    data = DataArray([1, 2])
+    data: DataArray | Dataset = DataArray([1, 2])
     if as_dataset:
         data = data.to_dataset(name="data")
 
@@ -271,22 +271,30 @@ def test_weighted_quantile_nan(skipna):
 @pytest.mark.parametrize(
     "da",
     (
-        [1, 1.9, 2.2, 3, 3.7, 4.1, 5],
-        [1, 1.9, 2.2, 3, 3.7, 4.1, np.nan],
-        [np.nan, np.nan, np.nan],
+        pytest.param([1, 1.9, 2.2, 3, 3.7, 4.1, 5], id="nonan"),
+        pytest.param([1, 1.9, 2.2, 3, 3.7, 4.1, np.nan], id="singlenan"),
+        pytest.param(
+            [np.nan, np.nan, np.nan],
+            id="allnan",
+            marks=pytest.mark.filterwarnings(
+                "ignore:All-NaN slice encountered:RuntimeWarning"
+            ),
+        ),
     ),
 )
 @pytest.mark.parametrize("q", (0.5, (0.2, 0.8)))
 @pytest.mark.parametrize("skipna", (True, False))
 @pytest.mark.parametrize("factor", [1, 3.14])
-def test_weighted_quantile_equal_weights(da, q, skipna, factor):
+def test_weighted_quantile_equal_weights(
+    da: list[float], q: float | tuple[float, ...], skipna: bool, factor: float
+) -> None:
     # if all weights are equal (!= 0), should yield the same result as quantile
 
-    da = DataArray(da)
-    weights = xr.full_like(da, factor)
+    data = DataArray(da)
+    weights = xr.full_like(data, factor)
 
-    expected = da.quantile(q, skipna=skipna)
-    result = da.weighted(weights).quantile(q, skipna=skipna)
+    expected = data.quantile(q, skipna=skipna)
+    result = data.weighted(weights).quantile(q, skipna=skipna)
 
     assert_allclose(expected, result)