Specify hh.specified_kwargs() arguments as named tuple, test it

Author: honno

array_api_tests/hypothesis_helpers.py

@@ -1,25 +1,24 @@
+import itertools
 from functools import reduce
-from operator import mul
 from math import sqrt
-import itertools
-from typing import Tuple, Optional, List
+from operator import mul
+from typing import Any, List, NamedTuple, Optional, Tuple
 
 from hypothesis import assume
-from hypothesis.strategies import (lists, integers, sampled_from,
-                                   shared, floats, just, composite, one_of,
-                                   none, booleans, SearchStrategy)
+from hypothesis.strategies import (SearchStrategy, booleans, composite, floats,
+                                   integers, just, lists, none, one_of,
+                                   sampled_from, shared)
 
-from .pytest_helpers import nargs
-from .array_helpers import ndindex
-from .typing import DataType, Shape
-from . import dtype_helpers as dh
-from ._array_module import (full, float32, float64, bool as bool_dtype,
-                            _UndefinedStub, eye, broadcast_to)
 from . import _array_module as xp
+from . import dtype_helpers as dh
 from . import xps
-
+from ._array_module import _UndefinedStub
+from ._array_module import bool as bool_dtype
+from ._array_module import broadcast_to, eye, float32, float64, full
+from .array_helpers import ndindex
 from .function_stubs import elementwise_functions
-
+from .pytest_helpers import nargs
+from .typing import DataType, Shape
 
 # Set this to True to not fail tests just because a dtype isn't implemented.
 # If no compatible dtype is implemented for a given test, the test will fail
@@ -382,3 +381,24 @@ def test_f(x, kw):
         if draw(booleans()):
             result[k] = draw(strat)
     return result
+
+
+class KVD(NamedTuple):
+    keyword: str
+    value: Any
+    default: Any
+
+
+@composite
+def specified_kwargs(draw, *keys_values_defaults: KVD):
+    """Generates valid kwargs given expected defaults.
+
+    When we can't realistically use hh.kwargs() and thus test whether xp infact
+    defaults correctly, this strategy lets us remove generated arguments if they
+    are of the default value anyway.
+    """
+    kw = {}
+    for keyword, value, default in keys_values_defaults:
+        if value is not default or draw(booleans()):
+            kw[keyword] = value
+    return kw

array_api_tests/meta/test_hypothesis_helpers.py

@@ -4,6 +4,7 @@
 from hypothesis import given, strategies as st, settings
 
 from .. import _array_module as xp
+from .. import xps
 from .._array_module import _UndefinedStub
 from .. import array_helpers as ah
 from .. import dtype_helpers as dh
@@ -76,6 +77,37 @@ def run(kw):
     assert len(c_results) > 0
     assert all(isinstance(kw["c"], str) for kw in c_results)
 
+
+def test_specified_kwargs():
+    results = []
+
+    @given(n=st.integers(0, 10), d=st.none() | xps.scalar_dtypes(), data=st.data())
+    @settings(max_examples=100)
+    def run(n, d, data):
+        kw = data.draw(
+            hh.specified_kwargs(
+                hh.KVD("n", n, 0),
+                hh.KVD("d", d, None),
+            ),
+            label="kw",
+        )
+        results.append(kw)
+    run()
+
+    assert all(isinstance(kw, dict) for kw in results)
+
+    assert any(len(kw) == 0 for kw in results)
+
+    assert any("n" not in kw.keys() for kw in results)
+    assert any("n" in kw.keys() and kw["n"] == 0 for kw in results)
+    assert any("n" in kw.keys() and kw["n"] != 0 for kw in results)
+
+    assert any("d" not in kw.keys() for kw in results)
+    assert any("d" in kw.keys() and kw["d"] is None for kw in results)
+    assert any("d" in kw.keys() and kw["d"] is xp.float64 for kw in results)
+
+
+
 @given(m=hh.symmetric_matrices(hh.shared_floating_dtypes,
                                      finite=st.shared(st.booleans(), key='finite')),
        dtype=hh.shared_floating_dtypes,

array_api_tests/test_creation_functions.py

@@ -1,6 +1,6 @@
 import math
 from itertools import count
-from typing import Any, Iterator, NamedTuple, Tuple, Union
+from typing import Iterator, NamedTuple, Union
 
 from hypothesis import assume, given
 from hypothesis import strategies as st
@@ -14,21 +14,6 @@
 from .typing import DataType, Scalar
 
 
-@st.composite
-def specified_kwargs(draw, *keys_values_defaults: Tuple[str, Any, Any]):
-    """Generates valid kwargs given expected defaults.
-
-    When we can't realistically use hh.kwargs() and thus test whether xp infact
-    defaults correctly, this strategy lets us remove generated arguments if they
-    are of the default value anyway.
-    """
-    kw = {}
-    for key, value, default in keys_values_defaults:
-        if value is not default or draw(st.booleans()):
-            kw[key] = value
-    return kw
-
-
 class frange(NamedTuple):
     start: float
     stop: float
@@ -147,10 +132,10 @@ def test_arange(dtype, data):
     ), f"{size=} should be no more than {hh.MAX_ARRAY_SIZE}"  # sanity check
 
     kw = data.draw(
-        specified_kwargs(
-            ("stop", stop, None),
-            ("step", step, None),
-            ("dtype", dtype, None),
+        hh.specified_kwargs(
+            hh.KVD("stop", stop, None),
+            hh.KVD("step", step, None),
+            hh.KVD("dtype", dtype, None),
         ),
         label="kw",
     )
@@ -360,9 +345,9 @@ def test_linspace(num, dtype, endpoint, data):
             stop = data.draw(int_stops(start, num, _dtype, endpoint), label="stop")
 
     kw = data.draw(
-        specified_kwargs(
-            ("dtype", dtype, None),
-            ("endpoint", endpoint, True),
+        hh.specified_kwargs(
+            hh.KVD("dtype", dtype, None),
+            hh.KVD("endpoint", endpoint, True),
         ),
         label="kw",
     )