Document how to verify Hypothesis example counts

.git-blame-ignore-revs

@@ -7,3 +7,10 @@ e807ffe526c7330691e8f39d31347dc2b3106de3
 bd42e84d2e5aae26ade8d70384e74effd1de89cb
 f7e822883b7e24b5aa540e2413759a85128b42ef
 a37f348ba27b6818e92fda8aee2406c653c671ea
+# gh-396
+ec5a3b4e185c262b0a5f5b1631b84a09f766d80e
+9058908b58ce627467ac34e768098a25f5863d31
+c80e1823c2e738381ca02f27cea1e2b89dde0ac5
+# gh-402
+bdc84e8316046cb5bdc637067460057eef17d0f1
+

.github/workflows/lint.yml

@@ -7,9 +7,9 @@ jobs:
 
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: "3.10"
     - name: Run pre-commit hook

.github/workflows/test.yml

@@ -11,11 +11,11 @@ jobs:
         python-version: ["3.10", "3.12", "3.13", "3.14"]
     steps:
     - name: Checkout array-api-tests
-      uses: actions/checkout@v1
+      uses: actions/checkout@v6
       with:
         submodules: 'true'
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies

array-api-strict-skips.txt

@@ -32,3 +32,21 @@ array_api_tests/test_data_type_functions.py::test_finfo
 array_api_tests/test_data_type_functions.py::test_finfo_dtype
 array_api_tests/test_data_type_functions.py::test_iinfo
 array_api_tests/test_data_type_functions.py::test_iinfo_dtype
+
+
+# complex special cases which failed "forever"
+array_api_tests/test_special_cases.py::test_unary[expm1(real(x_i) is +infinity and imag(x_i) is +0) -> +infinity + 0j]
+array_api_tests/test_special_cases.py::test_unary[expm1(real(x_i) is -infinity and imag(x_i) is +infinity) -> -1 + 0j]
+array_api_tests/test_special_cases.py::test_unary[expm1(real(x_i) is +infinity and imag(x_i) is +infinity) -> infinity + NaN j]
+array_api_tests/test_special_cases.py::test_unary[expm1(real(x_i) is -infinity and imag(x_i) is NaN) -> -1 + 0j]
+array_api_tests/test_special_cases.py::test_unary[expm1(real(x_i) is +infinity and imag(x_i) is NaN) -> infinity + NaN j]
+array_api_tests/test_special_cases.py::test_unary[expm1(real(x_i) is NaN and imag(x_i) is +0) -> NaN + 0j]
+array_api_tests/test_special_cases.py::test_unary[expm1((real(x_i) is +0 or real(x_i) == -0) and imag(x_i) is +0) -> 0 + 0j]
+
+array_api_tests/test_special_cases.py::test_unary[sign((real(x_i) is -0 or real(x_i) == +0) and (imag(x_i) is -0 or imag(x_i) == +0)) -> 0 + 0j]
+array_api_tests/test_special_cases.py::test_unary[tanh(real(x_i) is +infinity and isfinite(imag(x_i)) and imag(x_i) > 0) -> 1 + 0j]
+
+# this acosh failure is only seen with python==3.10 and numpy==2.2.6, and not e.g. python 3.12 & numpy 2.4.1
+array_api_tests/test_special_cases.py::test_unary[acosh(real(x_i) is +0 and imag(x_i) is NaN) -> NaN \xb1 \u03c0j/2]
+
+array_api_tests/test_special_cases.py::test_unary[sqrt(real(x_i) is +infinity and isfinite(imag(x_i)) and imag(x_i) > 0) -> +0 + infinity j]

array_api_tests/dtype_helpers.py

@@ -199,6 +199,39 @@ def is_scalar(x):
     return isinstance(x, (int, float, complex, bool))
 
 
+def complex_dtype_for(dtyp):
+    """Complex dtype for a float or complex."""
+    if dtyp in complex_dtypes:
+        return dtyp
+    if dtyp not in real_float_dtypes:
+        raise ValueError(f"no complex dtype to match {dtyp}")
+
+    real_name = dtype_to_name[dtyp]
+    complex_name = {"float32": "complex64", "float64": "complex128"}[real_name]
+
+    complex_dtype = _name_to_dtype.get(complex_name, None)
+    if complex_dtype is None:
+        raise ValueError(f"no complex dtype to match {dtyp}")
+    return complex_dtype
+
+
+def real_dtype_for(dtyp):
+    """Real float dtype for a float or complex."""
+    if dtyp in real_float_dtypes:
+        return dtyp
+    if dtyp not in complex_dtypes:
+        raise ValueError(f"no real float dtype to match {dtyp}")
+
+    complex_name = dtype_to_name[dtyp]
+    real_name = {"complex64": "float32", "complex128": "float64"}[complex_name]
+
+    real_dtype = _name_to_dtype.get(real_name, None)
+    if real_dtype is None:
+        raise ValueError(f"no real dtype to match {dtyp}")
+    return real_dtype
+
+
+
 def _make_dtype_mapping_from_names(mapping: Dict[str, Any]) -> EqualityMapping:
     dtype_value_pairs = []
     for name, value in mapping.items():

array_api_tests/hypothesis_helpers.py

@@ -457,13 +457,12 @@ def scalars(draw, dtypes, finite=False, **kwds):
     dtypes should be one of the shared_* dtypes strategies.
     """
     dtype = draw(dtypes)
-    mM = kwds.pop('mM', None)
     if dh.is_int_dtype(dtype):
-        if mM is None:
-            m, M = dh.dtype_ranges[dtype]
-        else:
-            m, M = mM
-        return draw(integers(m, M))
+        m, M = dh.dtype_ranges[dtype]
+        min_value = kwds.get('min_value', m)
+        max_value = kwds.get('max_value', M)
+
+        return draw(integers(min_value, max_value))
     elif dtype == bool_dtype:
         return draw(booleans())
     elif dtype == float64:
@@ -593,20 +592,32 @@ def two_mutual_arrays(
 
 
 @composite
-def array_and_py_scalar(draw, dtypes, mM=None, positive=False):
+def array_and_py_scalar(draw, dtypes, **kwds):
     """Draw a pair: (array, scalar) or (scalar, array)."""
     dtype = draw(sampled_from(dtypes))
 
-    scalar_var = draw(scalars(just(dtype), finite=True, mM=mM))
-    if positive:
-        assume (scalar_var > 0)
+    # draw the scalar: for float arrays, draw a float or an int
+    if dtype in dh.real_float_dtypes:
+        scalar_strategy = sampled_from([xp.int32, dtype])
+    else:
+        scalar_strategy = just(dtype)
+    scalar_var = draw(scalars(scalar_strategy, finite=True, **kwds))
 
+    # draw the array.
+    # XXX artificially limit the range of values for floats, otherwise value testing is flaky
     elements={}
     if dtype in dh.real_float_dtypes:
-        elements = {'allow_nan': False, 'allow_infinity': False,
-                    'min_value': 1.0 / (2<<5), 'max_value': 2<<5}
-    if positive:
-        elements = {'min_value': 0}
+        elements = {
+            'allow_nan': False,
+            'allow_infinity': False,
+            'min_value': kwds.get('min_value', 1.0 / (2<<5)),
+            'max_value': kwds.get('max_value', 2<<5)
+        }
+    elif dtype in dh.int_dtypes:
+        elements = {
+            'min_value': kwds.get('min_value', None),
+            'max_value': kwds.get('max_value', None)
+        }
     array_var = draw(arrays(dtype, shape=shapes(min_dims=1), elements=elements))
 
     if draw(booleans()):

array_api_tests/test_array_object.py

@@ -86,7 +86,6 @@ def test_getitem(shape, dtype, data):
     key = data.draw(xps.indices(shape=shape, allow_newaxis=True), label="key")
 
     repro_snippet = ph.format_snippet(f"{x!r}[{key!r}]")
-
     try:
         out = x[key]
 
@@ -109,6 +108,7 @@ def test_getitem(shape, dtype, data):
         ph.add_note(exc, repro_snippet)
         raise
 
+
 @pytest.mark.unvectorized
 @given(
     shape=hh.shapes(),
@@ -133,28 +133,34 @@ def test_setitem(shape, dtypes, data):
     value = data.draw(value_strat, label="value")
 
     res = xp.asarray(x, copy=True)
-    res[key] = value
-
-    ph.assert_dtype("__setitem__", in_dtype=x.dtype, out_dtype=res.dtype, repr_name="x.dtype")
-    ph.assert_shape("__setitem__", out_shape=res.shape, expected=x.shape, repr_name="x.shape")
-    f_res = sh.fmt_idx("x", key)
-    if isinstance(value, get_args(Scalar)):
-        msg = f"{f_res}={res[key]!r}, but should be {value=} [__setitem__()]"
-        if cmath.isnan(value):
-            assert xp.isnan(res[key]), msg
+
+    repro_snippet = ph.format_snippet(f"{res!r}[{key!r}] = {value!r}")
+    try:
+        res[key] = value
+
+        ph.assert_dtype("__setitem__", in_dtype=x.dtype, out_dtype=res.dtype, repr_name="x.dtype")
+        ph.assert_shape("__setitem__", out_shape=res.shape, expected=x.shape, repr_name="x.shape")
+        f_res = sh.fmt_idx("x", key)
+        if isinstance(value, get_args(Scalar)):
+            msg = f"{f_res}={res[key]!r}, but should be {value=} [__setitem__()]"
+            if cmath.isnan(value):
+                assert xp.isnan(res[key]), msg
+            else:
+                assert res[key] == value, msg
         else:
-            assert res[key] == value, msg
-    else:
-        ph.assert_array_elements("__setitem__", out=res[key], expected=value, out_repr=f_res)
-    unaffected_indices = set(sh.ndindex(res.shape)) - set(product(*axes_indices))
-    for idx in unaffected_indices:
-        ph.assert_0d_equals(
-            "__setitem__",
-            x_repr=f"old {f_res}",
-            x_val=x[idx],
-            out_repr=f"modified {f_res}",
-            out_val=res[idx],
-        )
+            ph.assert_array_elements("__setitem__", out=res[key], expected=value, out_repr=f_res)
+        unaffected_indices = set(sh.ndindex(res.shape)) - set(product(*axes_indices))
+        for idx in unaffected_indices:
+            ph.assert_0d_equals(
+                "__setitem__",
+                x_repr=f"old {f_res}",
+                x_val=x[idx],
+                out_repr=f"modified {f_res}",
+                out_val=res[idx],
+            )
+    except Exception as exc:
+        ph.add_note(exc, repro_snippet)
+        raise
 
 
 @pytest.mark.unvectorized
@@ -178,29 +184,34 @@ def test_getitem_masking(shape, data):
             x[key]
         return
 
-    out = x[key]
+    repro_snippet = ph.format_snippet(f"out = {x!r}[{key!r}]")
+    try:
+        out = x[key]
 
-    ph.assert_dtype("__getitem__", in_dtype=x.dtype, out_dtype=out.dtype)
-    if key.ndim == 0:
-        expected_shape = (1,) if key else (0,)
-        expected_shape += x.shape
-    else:
-        size = int(xp.sum(xp.astype(key, xp.uint8)))
-        expected_shape = (size,) + x.shape[key.ndim :]
-    ph.assert_shape("__getitem__", out_shape=out.shape, expected=expected_shape)
-    if not any(s == 0 for s in key.shape):
-        assume(key.ndim == x.ndim)  # TODO: test key.ndim < x.ndim scenarios
-        out_indices = sh.ndindex(out.shape)
-        for x_idx in sh.ndindex(x.shape):
-            if key[x_idx]:
-                out_idx = next(out_indices)
-                ph.assert_0d_equals(
-                    "__getitem__",
-                    x_repr=f"x[{x_idx}]",
-                    x_val=x[x_idx],
-                    out_repr=f"out[{out_idx}]",
-                    out_val=out[out_idx],
-                )
+        ph.assert_dtype("__getitem__", in_dtype=x.dtype, out_dtype=out.dtype)
+        if key.ndim == 0:
+            expected_shape = (1,) if key else (0,)
+            expected_shape += x.shape
+        else:
+            size = int(xp.sum(xp.astype(key, xp.uint8)))
+            expected_shape = (size,) + x.shape[key.ndim :]
+        ph.assert_shape("__getitem__", out_shape=out.shape, expected=expected_shape)
+        if not any(s == 0 for s in key.shape):
+            assume(key.ndim == x.ndim)  # TODO: test key.ndim < x.ndim scenarios
+            out_indices = sh.ndindex(out.shape)
+            for x_idx in sh.ndindex(x.shape):
+                if key[x_idx]:
+                    out_idx = next(out_indices)
+                    ph.assert_0d_equals(
+                        "__getitem__",
+                        x_repr=f"x[{x_idx}]",
+                        x_val=x[x_idx],
+                        out_repr=f"out[{out_idx}]",
+                        out_val=out[out_idx],
+                    )
+    except Exception as exc:
+        ph.add_note(exc, repro_snippet)
+        raise
 
 
 @pytest.mark.unvectorized
@@ -213,38 +224,44 @@ def test_setitem_masking(shape, data):
     )
 
     res = xp.asarray(x, copy=True)
-    res[key] = value
-
-    ph.assert_dtype("__setitem__", in_dtype=x.dtype, out_dtype=res.dtype, repr_name="x.dtype")
-    ph.assert_shape("__setitem__", out_shape=res.shape, expected=x.shape, repr_name="x.dtype")
-    scalar_type = dh.get_scalar_type(x.dtype)
-    for idx in sh.ndindex(x.shape):
-        if key[idx]:
-            if isinstance(value, get_args(Scalar)):
-                ph.assert_scalar_equals(
-                    "__setitem__",
-                    type_=scalar_type,
-                    idx=idx,
-                    out=scalar_type(res[idx]),
-                    expected=value,
-                    repr_name="modified x",
-                )
+
+    repro_snippet = ph.format_snippet(f"{res}[{key!r}] = {value!r}")
+    try:
+        res[key] = value
+
+        ph.assert_dtype("__setitem__", in_dtype=x.dtype, out_dtype=res.dtype, repr_name="x.dtype")
+        ph.assert_shape("__setitem__", out_shape=res.shape, expected=x.shape, repr_name="x.dtype")
+        scalar_type = dh.get_scalar_type(x.dtype)
+        for idx in sh.ndindex(x.shape):
+            if key[idx]:
+                if isinstance(value, get_args(Scalar)):
+                    ph.assert_scalar_equals(
+                        "__setitem__",
+                        type_=scalar_type,
+                        idx=idx,
+                        out=scalar_type(res[idx]),
+                        expected=value,
+                        repr_name="modified x",
+                    )
+                else:
+                    ph.assert_0d_equals(
+                        "__setitem__",
+                        x_repr="value",
+                        x_val=value,
+                        out_repr=f"modified x[{idx}]",
+                        out_val=res[idx]
+                    )
             else:
                 ph.assert_0d_equals(
                     "__setitem__",
-                    x_repr="value",
-                    x_val=value,
+                    x_repr=f"old x[{idx}]",
+                    x_val=x[idx],
                     out_repr=f"modified x[{idx}]",
                     out_val=res[idx]
                 )
-        else:
-            ph.assert_0d_equals(
-                "__setitem__",
-                x_repr=f"old x[{idx}]",
-                x_val=x[idx],
-                out_repr=f"modified x[{idx}]",
-                out_val=res[idx]
-            )
+    except Exception as exc:
+        ph.add_note(exc, repro_snippet)
+        raise
 
 
 # ### Fancy indexing ###
@@ -309,15 +326,20 @@ def _test_getitem_arrays_and_ints(shape, data, idx_max_dims):
             key.append(data.draw(st.integers(-shape[i], shape[i]-1)))
 
     key = tuple(key)
-    out = x[key]
+    repro_snippet = ph.format_snippet(f"out = {x!r}[{key!r}]")
+    try:
+        out = x[key]
 
-    arrays = [xp.asarray(k) for k in key]
-    bcast_shape = sh.broadcast_shapes(*[arr.shape for arr in arrays])
-    bcast_key = [xp.broadcast_to(arr, bcast_shape) for arr in arrays]
+        arrays = [xp.asarray(k) for k in key]
+        bcast_shape = sh.broadcast_shapes(*[arr.shape for arr in arrays])
+        bcast_key = [xp.broadcast_to(arr, bcast_shape) for arr in arrays]
 
-    for idx in sh.ndindex(bcast_shape):
-        tpl = tuple(k[idx] for k in bcast_key)
-        assert out[idx] == x[tpl], f"failing at {idx = } w/ {key = }"
+        for idx in sh.ndindex(bcast_shape):
+            tpl = tuple(k[idx] for k in bcast_key)
+            assert out[idx] == x[tpl], f"failing at {idx = } w/ {key = }"
+    except Exception as exc:
+        ph.add_note(exc, repro_snippet)
+        raise
 
 
 def make_scalar_casting_param(