Unpin array api strict (#10983)

* pre-commit

* invert assert_equal array, instead of copying

* add ignore for mypy

* convert arrays to np array

* easier to read

---------

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

Author: JJFlorian

ci/requirements/environment.yml

@@ -4,7 +4,7 @@ channels:
   - nodefaults
 dependencies:
   - aiobotocore
-  - array-api-strict<2.4
+  - array-api-strict
   - boto3
   - bottleneck
   - cartopy

pixi.toml

@@ -111,7 +111,7 @@ scipy = "1.13.*"
 # - Update the min version lower-bound in the corresponding feature(s) where applicable
 # - Update this section to pin to the min version
 
-array-api-strict = "1.1.*" # dependency for testing the array api compat
+array-api-strict = "2.4.*" # dependency for testing the array api compat
 boto3 = "1.34.*"
 bottleneck = "1.4.*"
 cartopy = "0.23.*"
@@ -198,7 +198,7 @@ cartopy = "*"
 seaborn = "*"
 
 [feature.test.dependencies]
-array-api-strict = "<2.4"
+array-api-strict = "*"
 pytest = "*"
 pytest-asyncio = "*"
 pytest-cov = "*"

xarray/tests/test_array_api.py

@@ -32,23 +32,26 @@ def test_arithmetic(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     expected = np_arr + 7
     actual = xp_arr + 7
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_aggregation(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr.sum()
     actual = xp_arr.sum()
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_aggregation_skipna(arrays) -> 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)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 # casting nan warns
@@ -59,7 +62,8 @@ def test_astype(arrays) -> None:
     actual = xp_arr.astype(xp.int64)
     assert actual.dtype == xp.int64
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_broadcast(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
@@ -72,7 +76,8 @@ def test_broadcast(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     assert len(actual) == len(expected)
     for a, e in zip(actual, expected, strict=True):
         assert isinstance(a.data, Array)
-        assert_equal(a, e)
+        a_np = a.copy(data=np.asarray(a.data))
+        assert_equal(a_np, e)
 
 
 def test_broadcast_during_arithmetic(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
@@ -83,28 +88,32 @@ def test_broadcast_during_arithmetic(arrays: tuple[xr.DataArray, xr.DataArray])
     expected = np_arr * np_arr2
     actual = xp_arr * xp_arr2
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
     expected = np_arr2 * np_arr
     actual = xp_arr2 * xp_arr
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_concat(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = xr.concat((np_arr, np_arr), dim="x")
     actual = xr.concat((xp_arr, xp_arr), dim="x")
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 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)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_properties(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
@@ -120,23 +129,26 @@ def test_reorganizing_operation(arrays: tuple[xr.DataArray, xr.DataArray]) -> No
     expected = np_arr.transpose()
     actual = xp_arr.transpose()
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_stack(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr.stack(z=("x", "y"))
     actual = xp_arr.stack(z=("x", "y"))
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_unstack(arrays: tuple[xr.DataArray, xr.DataArray]) -> None:
     np_arr, xp_arr = arrays
     expected = np_arr.stack(z=("x", "y")).unstack()
     actual = xp_arr.stack(z=("x", "y")).unstack()
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)
 
 
 def test_where() -> None:
@@ -145,4 +157,5 @@ def test_where() -> None:
     expected = xr.where(np_arr, 1, 0)
     actual = xr.where(xp_arr, 1, 0)
     assert isinstance(actual.data, Array)
-    assert_equal(actual, expected)
+    actual_np = actual.copy(data=np.asarray(actual.data))
+    assert_equal(actual_np, expected)

xarray/tests/test_dtypes.py

@@ -15,7 +15,7 @@ class DummyArrayAPINamespace:
         int32 = None  # type: ignore[unused-ignore,var-annotated]
         float64 = None  # type: ignore[unused-ignore,var-annotated]
 
-    array_api_strict = DummyArrayAPINamespace
+    array_api_strict = DummyArrayAPINamespace  # type: ignore[misc, assignment, unused-ignore]
 
 
 @pytest.mark.parametrize(