Remove some use of array_helpers.py which just mirrored xp funcs

The uses which weren't directly imported, i.e. used the alias `ah`

Author: honno

array_api_tests/pytest_helpers.py

@@ -3,7 +3,6 @@
 from typing import Any, Dict, Optional, Sequence, Tuple, Union
 
 from . import _array_module as xp
-from . import array_helpers as ah
 from . import dtype_helpers as dh
 from . import shape_helpers as sh
 from . import stubs
@@ -370,9 +369,9 @@ def assert_fill(
     """
     msg = f"out not filled with {fill_value} [{func_name}({fmt_kw(kw)})]\n{out=}"
     if math.isnan(fill_value):
-        assert ah.all(ah.isnan(out)), msg
+        assert xp.all(xp.isnan(out)), msg
     else:
-        assert ah.all(ah.equal(out, ah.asarray(fill_value, dtype=dtype))), msg
+        assert xp.all(xp.equal(out, xp.asarray(fill_value, dtype=dtype))), msg
 
 
 def assert_array(func_name: str, out: Array, expected: Array, /, **kw):

array_api_tests/test_creation_functions.py

@@ -7,7 +7,6 @@
 from hypothesis import strategies as st
 
 from . import _array_module as xp
-from . import array_helpers as ah
 from . import dtype_helpers as dh
 from . import hypothesis_helpers as hh
 from . import pytest_helpers as ph
@@ -181,12 +180,12 @@ def test_arange(dtype, data):
     if dh.is_int_dtype(_dtype):
         elements = list(r)
         assume(out.size == len(elements))
-        ah.assert_exactly_equal(out, ah.asarray(elements, dtype=_dtype))
+        ph.assert_array("arange", out, xp.asarray(elements, dtype=_dtype))
     else:
         assume(out.size == size)
         if out.size > 0:
-            assert ah.equal(
-                out[0], ah.asarray(_start, dtype=out.dtype)
+            assert xp.equal(
+                out[0], xp.asarray(_start, dtype=out.dtype)
             ), f"out[0]={out[0]}, but should be {_start} {f_func}"
 
 
@@ -421,8 +420,8 @@ def test_linspace(num, dtype, endpoint, data):
     start = data.draw(xps.from_dtype(_dtype, **finite_kw), label="start")
     stop = data.draw(xps.from_dtype(_dtype, **finite_kw), label="stop")
     # avoid overflow errors
-    assume(not ah.isnan(ah.asarray(stop - start, dtype=_dtype)))
-    assume(not ah.isnan(ah.asarray(start - stop, dtype=_dtype)))
+    assume(not xp.isnan(xp.asarray(stop - start, dtype=_dtype)))
+    assume(not xp.isnan(xp.asarray(start - stop, dtype=_dtype)))
 
     kw = data.draw(
         hh.specified_kwargs(
@@ -440,20 +439,20 @@ def test_linspace(num, dtype, endpoint, data):
     ph.assert_shape("linspace", out.shape, num, start=stop, stop=stop, num=num)
     f_func = f"[linspace({start}, {stop}, {num})]"
     if num > 0:
-        assert ah.equal(
-            out[0], ah.asarray(start, dtype=out.dtype)
+        assert xp.equal(
+            out[0], xp.asarray(start, dtype=out.dtype)
         ), f"out[0]={out[0]}, but should be {start} {f_func}"
     if endpoint:
         if num > 1:
-            assert ah.equal(
-                out[-1], ah.asarray(stop, dtype=out.dtype)
+            assert xp.equal(
+                out[-1], xp.asarray(stop, dtype=out.dtype)
             ), f"out[-1]={out[-1]}, but should be {stop} {f_func}"
     else:
         # linspace(..., num, endpoint=True) should return an array equivalent to
         # the first num elements when endpoint=False
         expected = xp.linspace(start, stop, num + 1, dtype=dtype, endpoint=True)
         expected = expected[:-1]
-        ah.assert_exactly_equal(out, expected)
+        ph.assert_array("linspace", out, expected)
 
 
 @given(dtype=xps.numeric_dtypes(), data=st.data())

array_api_tests/test_operators_and_elementwise_functions.py

@@ -409,7 +409,7 @@ def func(l: Array, r: Union[Scalar, Array]) -> Array:
 
                 def func(l: Array, r: Union[Scalar, Array]) -> Array:
                     locals_ = {}
-                    locals_[left_sym] = ah.asarray(l, copy=True)  # prevents mutating l
+                    locals_[left_sym] = xp.asarray(l, copy=True)  # prevents mutating l
                     locals_[right_sym] = r
                     exec(expr, locals_)
                     return locals_[left_sym]
@@ -659,7 +659,7 @@ def test_bitwise_left_shift(ctx, data):
     if ctx.right_is_scalar:
         assume(right >= 0)
     else:
-        assume(not ah.any(ah.isnegative(right)))
+        assume(not xp.any(ah.isnegative(right)))
 
     res = ctx.func(left, right)
 
@@ -718,7 +718,7 @@ def test_bitwise_right_shift(ctx, data):
     if ctx.right_is_scalar:
         assume(right >= 0)
     else:
-        assume(not ah.any(ah.isnegative(right)))
+        assume(not xp.any(ah.isnegative(right)))
 
     res = ctx.func(left, right)
 
@@ -851,13 +851,13 @@ def test_floor(x):
 @given(data=st.data())
 def test_floor_divide(ctx, data):
     left = data.draw(
-        ctx.left_strat.filter(lambda x: not ah.any(x == 0)), label=ctx.left_sym
+        ctx.left_strat.filter(lambda x: not xp.any(x == 0)), label=ctx.left_sym
     )
     right = data.draw(ctx.right_strat, label=ctx.right_sym)
     if ctx.right_is_scalar:
         assume(right != 0)
     else:
-        assume(not ah.any(right == 0))
+        assume(not xp.any(right == 0))
 
     res = ctx.func(left, right)
 
@@ -908,7 +908,7 @@ def test_greater_equal(ctx, data):
 
 @given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_isfinite(x):
-    out = ah.isfinite(x)
+    out = xp.isfinite(x)
     ph.assert_dtype("isfinite", x.dtype, out.dtype, xp.bool)
     ph.assert_shape("isfinite", out.shape, x.shape)
     unary_assert_against_refimpl("isfinite", x, out, math.isfinite, res_stype=bool)
@@ -924,7 +924,7 @@ def test_isinf(x):
 
 @given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_isnan(x):
-    out = ah.isnan(x)
+    out = xp.isnan(x)
     ph.assert_dtype("isnan", x.dtype, out.dtype, xp.bool)
     ph.assert_shape("isnan", out.shape, x.shape)
     unary_assert_against_refimpl("isnan", x, out, math.isnan, res_stype=bool)
@@ -1024,7 +1024,7 @@ def test_logaddexp(x1, x2):
 
 @given(*hh.two_mutual_arrays([xp.bool]))
 def test_logical_and(x1, x2):
-    out = ah.logical_and(x1, x2)
+    out = xp.logical_and(x1, x2)
     ph.assert_dtype("logical_and", [x1.dtype, x2.dtype], out.dtype)
     ph.assert_result_shape("logical_and", [x1.shape, x2.shape], out.shape)
     binary_assert_against_refimpl(
@@ -1034,7 +1034,7 @@ def test_logical_and(x1, x2):
 
 @given(xps.arrays(dtype=xp.bool, shape=hh.shapes()))
 def test_logical_not(x):
-    out = ah.logical_not(x)
+    out = xp.logical_not(x)
     ph.assert_dtype("logical_not", x.dtype, out.dtype)
     ph.assert_shape("logical_not", out.shape, x.shape)
     unary_assert_against_refimpl(
@@ -1044,7 +1044,7 @@ def test_logical_not(x):
 
 @given(*hh.two_mutual_arrays([xp.bool]))
 def test_logical_or(x1, x2):
-    out = ah.logical_or(x1, x2)
+    out = xp.logical_or(x1, x2)
     ph.assert_dtype("logical_or", [x1.dtype, x2.dtype], out.dtype)
     ph.assert_result_shape("logical_or", [x1.shape, x2.shape], out.shape)
     binary_assert_against_refimpl(
@@ -1157,7 +1157,7 @@ def test_remainder(ctx, data):
     if ctx.right_is_scalar:
         assume(right != 0)
     else:
-        assume(not ah.any(right == 0))
+        assume(not xp.any(right == 0))
 
     res = ctx.func(left, right)