Automatic duck array testing - reductions

.github/workflows/ci.yaml

@@ -59,6 +59,15 @@ jobs:
           - env: "flaky"
             python-version: "3.10"
             os: ubuntu-latest
+          - env: "duckarrays"
+            python-version: "3.10"
+            os: "ubuntu-latest"
+          - env: "duckarrays"
+            python-version: "3.10"
+            os: "windows-latest"
+          - env: "duckarrays"
+            python-version: "3.10"
+            os: "macos-latest"
     steps:
       - uses: actions/checkout@v3
         with:
@@ -70,17 +79,20 @@ jobs:
           if [[ ${{ matrix.os }} == windows* ]] ;
           then
             echo "CONDA_ENV_FILE=ci/requirements/environment-windows.yml" >> $GITHUB_ENV
-          elif [[ "${{ matrix.env }}" != "" ]] ;
+          else
+            echo "CONDA_ENV_FILE=ci/requirements/environment.yml" >> $GITHUB_ENV
+          fi
+
+          if [[ "${{ matrix.env }}" != "" ]] ;
           then
-            if [[ "${{ matrix.env }}" == "flaky" ]] ;
-            then
+            if [[ "${{ matrix.env }}" == "flaky" ]] ; then
               echo "CONDA_ENV_FILE=ci/requirements/environment.yml" >> $GITHUB_ENV
               echo "PYTEST_EXTRA_FLAGS=--run-flaky --run-network-tests" >> $GITHUB_ENV
+            elif [[ "${{ matrix.env }}" == "duckarrays" ]] ; then
+              echo "PYTEST_EXTRA_FLAGS=--run-duckarray-tests xarray/tests/duckarrays/" >> $GITHUB_ENV
             else
               echo "CONDA_ENV_FILE=ci/requirements/${{ matrix.env }}.yml" >> $GITHUB_ENV
             fi
-          else
-            echo "CONDA_ENV_FILE=ci/requirements/environment.yml" >> $GITHUB_ENV
           fi
 
           echo "PYTHON_VERSION=${{ matrix.python-version }}" >> $GITHUB_ENV
@@ -96,7 +108,7 @@ jobs:
       # We only want to install this on one run, because otherwise we'll have
       # duplicate annotations.
       - name: Install error reporter
-        if: ${{ matrix.os }} == 'ubuntu-latest' and ${{ matrix.python-version }} == '3.10'
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.10' && matrix.env == ''
         run: |
           python -m pip install pytest-github-actions-annotate-failures
 

conftest.py

@@ -11,6 +11,11 @@ def pytest_addoption(parser):
         action="store_true",
         help="runs tests requiring a network connection",
     )
+    parser.addoption(
+        "--run-duckarray-tests",
+        action="store_true",
+        help="runs the duckarray hypothesis tests",
+    )
 
 
 def pytest_runtest_setup(item):
@@ -21,6 +26,10 @@ def pytest_runtest_setup(item):
         pytest.skip(
             "set --run-network-tests to run test requiring an internet connection"
         )
+    if "duckarrays" in item.keywords and not item.config.getoption(
+        "--run-duckarray-tests"
+    ):
+        pytest.skip("set --run-duckarray-tests option to run duckarray tests")
 
 
 @pytest.fixture(autouse=True)

setup.cfg

@@ -144,6 +144,7 @@ markers =
     flaky: flaky tests
     network: tests requiring a network connection
     slow: slow tests
+    duckarrays: duckarray tests
 
 [flake8]
 ignore =

xarray/tests/conftest.py

@@ -12,6 +12,48 @@ def backend(request):
     return request.param
 
 
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers",
+        "apply_marks(marks): function to attach marks to tests and test variants",
+    )
+
+
+def always_sequence(obj):
+    if not isinstance(obj, (list, tuple)):
+        obj = [obj]
+
+    return obj
+
+
+def pytest_collection_modifyitems(session, config, items):
+    for item in items:
+        mark = item.get_closest_marker("apply_marks")
+        if mark is None:
+            continue
+
+        marks = mark.args[0]
+        if not isinstance(marks, dict):
+            continue
+
+        possible_marks = marks.get(item.originalname)
+        if possible_marks is None:
+            continue
+
+        if not isinstance(possible_marks, dict):
+            for mark in always_sequence(possible_marks):
+                item.add_marker(mark)
+            continue
+
+        variant = item.name[len(item.originalname) :]
+        to_attach = possible_marks.get(variant)
+        if to_attach is None:
+            continue
+
+        for mark in always_sequence(to_attach):
+            item.add_marker(mark)
+
+
 @pytest.fixture(params=[1])
 def ds(request, backend):
     if request.param == 1:

xarray/tests/duckarrays/base/__init__.py

@@ -0,0 +1,7 @@
+from .reduce import DataArrayReduceTests, DatasetReduceTests, VariableReduceTests
+
+__all__ = [
+    "VariableReduceTests",
+    "DataArrayReduceTests",
+    "DatasetReduceTests",
+]

xarray/tests/duckarrays/base/reduce.py

@@ -0,0 +1,144 @@
+import hypothesis.strategies as st
+import numpy as np
+import pytest
+from hypothesis import given, note, settings
+
+from ... import assert_identical
+from . import strategies
+
+
+class VariableReduceTests:
+    def check_reduce(self, obj, op, *args, **kwargs):
+        actual = getattr(obj, op)(*args, **kwargs)
+
+        data = np.asarray(obj.data)
+        expected = getattr(obj.copy(data=data), op)(*args, **kwargs)
+
+        note(f"actual:\n{actual}")
+        note(f"expected:\n{expected}")
+
+        assert_identical(actual, expected)
+
+    @staticmethod
+    def create(shape, dtypes):
+        return strategies.numpy_array(shape)
+
+    @pytest.mark.parametrize(
+        "method",
+        (
+            "all",
+            "any",
+            "cumprod",
+            "cumsum",
+            "max",
+            "mean",
+            "median",
+            "min",
+            "prod",
+            "std",
+            "sum",
+            "var",
+        ),
+    )
+    @given(st.data())
+    @settings(deadline=None)
+    def test_reduce(self, method, data):
+        var = data.draw(
+            strategies.variable(lambda shape, dtypes: self.create(shape, dtypes))
+        )
+
+        reduce_dims = data.draw(strategies.valid_dims(var.dims))
+
+        self.check_reduce(var, method, dim=reduce_dims)
+
+
+class DataArrayReduceTests:
+    def check_reduce(self, obj, op, *args, **kwargs):
+        actual = getattr(obj, op)(*args, **kwargs)
+
+        data = np.asarray(obj.data)
+        expected = getattr(obj.copy(data=data), op)(*args, **kwargs)
+
+        note(f"actual:\n{actual}")
+        note(f"expected:\n{expected}")
+
+        assert_identical(actual, expected)
+
+    @staticmethod
+    def create(op, shape, dtypes):
+        return strategies.numpy_array(shape, dtypes)
+
+    @pytest.mark.parametrize(
+        "method",
+        (
+            "all",
+            "any",
+            "cumprod",
+            "cumsum",
+            "max",
+            "mean",
+            "median",
+            "min",
+            "prod",
+            "std",
+            "sum",
+            "var",
+        ),
+    )
+    @given(st.data())
+    @settings(deadline=None)
+    def test_reduce(self, method, data):
+        arr = data.draw(
+            strategies.data_array(lambda shape, dtypes: self.create(shape, dtypes))
+        )
+
+        reduce_dims = data.draw(strategies.valid_dims(arr.dims))
+
+        self.check_reduce(arr, method, dim=reduce_dims)
+
+
+class DatasetReduceTests:
+    def check_reduce(self, obj, op, *args, **kwargs):
+        actual = getattr(obj, op)(*args, **kwargs)
+
+        data = {name: np.asarray(obj.data) for name, obj in obj.variables.items()}
+        expected = getattr(obj.copy(data=data), op)(*args, **kwargs)
+
+        note(f"actual:\n{actual}")
+        note(f"expected:\n{expected}")
+
+        assert_identical(actual, expected)
+
+    @staticmethod
+    def create(shape, dtypes):
+        return strategies.numpy_array(shape, dtypes)
+
+    @pytest.mark.parametrize(
+        "method",
+        (
+            "all",
+            "any",
+            "cumprod",
+            "cumsum",
+            "max",
+            "mean",
+            "median",
+            "min",
+            "prod",
+            "std",
+            "sum",
+            "var",
+        ),
+    )
+    @given(st.data())
+    @settings(deadline=None)
+    def test_reduce(self, method, data):
+        ds = data.draw(
+            strategies.dataset(
+                lambda shape, dtypes: self.create(shape, dtypes), max_size=5
+            )
+        )
+
+        reduce_dims = data.draw(strategies.valid_dims(ds.dims))
+
+        self.check_reduce(ds, method, dim=reduce_dims)