diff --git a/xarray/coding/times.py b/xarray/coding/times.py index 74e14556c1f..2c03abc04ff 100644 --- a/xarray/coding/times.py +++ b/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 diff --git a/xarray/core/common.py b/xarray/core/common.py index f98c36329a4..e02b35f9680 100644 --- a/xarray/core/common.py +++ b/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): diff --git a/xarray/core/merge.py b/xarray/core/merge.py index 6262e031a2c..1bc328b778d 100644 --- a/xarray/core/merge.py +++ b/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) diff --git a/xarray/tests/test_array_api.py b/xarray/tests/test_array_api.py index 649bf3eec2b..a15492028dd 100644 --- a/xarray/tests/test_array_api.py +++ b/xarray/tests/test_array_api.py @@ -1,4 +1,6 @@ -from typing import Tuple +from __future__ import annotations + +import warnings import pytest @@ -7,19 +9,21 @@ 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 @@ -27,7 +31,7 @@ def test_arithmetic(arrays) -> None: 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) @@ -35,7 +39,7 @@ def test_aggregation(arrays) -> None: 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] @@ -43,13 +47,13 @@ def test_indexing(arrays) -> None: 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() diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index e8550bb12b2..37fd13c8d3e 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/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]"), diff --git a/xarray/tests/test_weighted.py b/xarray/tests/test_weighted.py index d440bdf6844..1a739bea001 100644 --- a/xarray/tests/test_weighted.py +++ b/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)