promotable_dtypes() strategy

* Used in test_*_like() tests
* Refactors construction of dtype_pairs table
* mutually_promotable_dtypes -> mutually_promotable_dtype_pairs for clarity
* Rudimentary meta tests

Author: honno

array_api_tests/hypothesis_helpers.py

@@ -17,7 +17,7 @@
                             integer_or_boolean_dtype_objects, dtype_objects)
 from ._array_module import (ones, full, float32, float64, bool as bool_dtype, _UndefinedStub)
 from . import _array_module
-from ._array_module import mod as xp
+from . import _array_module as xp
 
 from .function_stubs import elementwise_functions
 
@@ -50,8 +50,7 @@
 
 shared_dtypes = shared(dtypes)
 
-@composite
-def mutually_promotable_dtypes(draw, dtype_objects=dtype_objects):
+def make_dtype_pairs():
     from .test_type_promotion import dtype_mapping, promotion_table
     # sort for shrinking (sampled_from shrinks to the earlier elements in the
     # list). Give pairs of the same dtypes first, then smaller dtypes,
@@ -61,17 +60,25 @@ def mutually_promotable_dtypes(draw, dtype_objects=dtype_objects):
     # pairs (XXX: Can we redesign the strategies so that they can prefer
     # shrinking dtypes over values?)
     sorted_table = sorted(promotion_table)
-    sorted_table = sorted(sorted_table, key=lambda ij: -1 if ij[0] == ij[1] else sorted_table.index(ij))
-    dtype_pairs = [(dtype_mapping[i], dtype_mapping[j]) for i, j in
-                   sorted_table]
-
-    filtered_dtype_pairs = [(i, j) for i, j in dtype_pairs if i in
-                            dtype_objects and j in dtype_objects]
+    sorted_table = sorted(
+        sorted_table, key=lambda ij: -1 if ij[0] == ij[1] else sorted_table.index(ij)
+    )
+    dtype_pairs = [(dtype_mapping[i], dtype_mapping[j]) for i, j in sorted_table]
     if FILTER_UNDEFINED_DTYPES:
-        filtered_dtype_pairs = [(i, j) for i, j in filtered_dtype_pairs
-                                if not isinstance(i, _UndefinedStub)
-                                and not isinstance(j, _UndefinedStub)]
-    return draw(sampled_from(filtered_dtype_pairs))
+        dtype_pairs = [(i, j) for i, j in dtype_pairs
+                       if not isinstance(i, _UndefinedStub)
+                       and not isinstance(j, _UndefinedStub)]
+    return dtype_pairs
+
+def promotable_dtypes(dtype):
+    dtype_pairs = make_dtype_pairs()
+    dtypes = [j for i, j in dtype_pairs if i == dtype]
+    return sampled_from(dtypes)
+
+def mutually_promotable_dtype_pairs(dtype_objects=dtype_objects):
+    dtype_pairs = make_dtype_pairs()
+    dtype_pairs = [(i, j) for i, j in dtype_pairs if i in dtype_objects and j in dtype_objects]
+    return sampled_from(dtype_pairs)
 
 # shared() allows us to draw either the function or the function name and they
 # will both correspond to the same function.

array_api_tests/meta_tests/test_hypothesis_helpers.py

@@ -0,0 +1,37 @@
+import pytest
+from hypothesis import given, strategies as st
+
+from .. import _array_module as xp
+from .._array_module import _UndefinedStub
+from ..array_helpers import dtype_objects
+from ..hypothesis_helpers import (mutually_promotable_dtype_pairs,
+                                  promotable_dtypes)
+
+UNDEFINED_DTYPES = any(isinstance(d, _UndefinedStub) for d in dtype_objects)
+pytestmark = [pytest.mark.skipif(UNDEFINED_DTYPES, reason="undefined dtypes")]
+
+
+def test_promotable_dtypes():
+    dtypes = set()
+    @given(promotable_dtypes(xp.uint16))
+    def run(dtype):
+        dtypes.add(dtype)
+    run()
+    assert dtypes == {
+        xp.uint8, xp.uint16, xp.uint32, xp.uint64, xp.int8, xp.int16, xp.int32, xp.int64
+    }
+
+
+def test_mutually_promotable_dtype_pairs():
+    pairs = set()
+    @given(mutually_promotable_dtype_pairs([xp.float32, xp.float64]))
+    def run(pair):
+        pairs.add(pair)
+    run()
+    assert pairs == {
+        (xp.float32, xp.float32),
+        (xp.float32, xp.float64),
+        (xp.float64, xp.float32),
+        (xp.float64, xp.float64),
+    }
+

array_api_tests/test_creation_functions.py

@@ -3,7 +3,7 @@
                             zeros, zeros_like, isnan)
 from .array_helpers import (is_integer_dtype, dtype_ranges,
                             assert_exactly_equal, isintegral, is_float_dtype)
-from .hypothesis_helpers import (numeric_dtypes, dtypes, MAX_ARRAY_SIZE,
+from .hypothesis_helpers import (numeric_dtypes, dtypes, MAX_ARRAY_SIZE, promotable_dtypes,
                                  shapes, sizes, sqrt_sizes, shared_dtypes,
                                  scalars, xps)
 
@@ -84,7 +84,7 @@ def test_empty(shape, dtype):
         dtype=shared_dtypes,
         shape=xps.array_shapes(),
     ),
-    dtype=one_of(none(), shared_dtypes),
+    dtype=one_of(none(), shared_dtypes.flatmap(promotable_dtypes)),
 )
 def test_empty_like(a, dtype):
     kwargs = {} if dtype is None else {'dtype': dtype}
@@ -96,7 +96,7 @@ def test_empty_like(a, dtype):
         # assert is_float_dtype(a_like.dtype), "empty_like() should produce an array with the default floating point dtype"
         pass
     else:
-        assert a_like.dtype == a.dtype, "empty_like() produced an array with an incorrect dtype"
+        assert a_like.dtype == dtype, "empty_like() produced an array with an incorrect dtype"
 
     assert a_like.shape == a.shape, "empty_like() produced an array with an incorrect shape"
 
@@ -155,8 +155,8 @@ def test_full(shape, fill_value, dtype):
         dtype=shared_dtypes,
         shape=xps.array_shapes(),
     ),
-    fill_value=shared_dtypes.flatmap(xps.from_dtype),
-    dtype=one_of(none(), shared_dtypes),
+    fill_value=shared_dtypes.flatmap(promotable_dtypes).flatmap(xps.from_dtype),
+    dtype=one_of(none(), shared_dtypes.flatmap(promotable_dtypes)),
 )
 def test_full_like(a, fill_value, dtype):
     kwargs = {} if dtype is None else {'dtype': dtype}
@@ -167,13 +167,13 @@ def test_full_like(a, fill_value, dtype):
         # TODO: Should it actually match a.dtype?
         pass
     else:
-        assert a_like.dtype == a.dtype
+        assert a_like.dtype == dtype
 
     assert a_like.shape == a.shape, "full_like() produced an array with incorrect shape"
     if is_float_dtype(a_like.dtype) and isnan(asarray(fill_value)):
         assert all(isnan(a_like)), "full_like() array did not equal the fill value"
     else:
-        assert all(equal(a_like, asarray(fill_value, dtype=a.dtype))), "full_like() array did not equal the fill value"
+        assert all(equal(a_like, asarray(fill_value, dtype=a_like.dtype))), "full_like() array did not equal the fill value"
 
 
 @given(scalars(shared_dtypes, finite=True),
@@ -247,7 +247,7 @@ def test_ones(shape, dtype):
         dtype=shared_dtypes,
         shape=xps.array_shapes(),
     ),
-    dtype=one_of(none(), shared_dtypes),
+    dtype=one_of(none(), shared_dtypes.flatmap(promotable_dtypes)),
 )
 def test_ones_like(a, dtype):
     kwargs = {} if dtype is None else {'dtype': dtype}
@@ -260,11 +260,11 @@ def test_ones_like(a, dtype):
 
     a_like = ones_like(a, **kwargs)
 
-    if kwargs is None:
+    if dtype is None:
         # TODO: Should it actually match a.dtype?
         pass
     else:
-        assert a_like.dtype == a.dtype, "ones_like() produced an array with an incorrect dtype"
+        assert a_like.dtype == dtype, "ones_like() produced an array with an incorrect dtype"
 
     assert a_like.shape == a.shape, "ones_like() produced an array with an incorrect shape"
     assert all(equal(a_like, full((), ONE, dtype=a_like.dtype))), "ones_like() array did not equal 1"
@@ -298,7 +298,7 @@ def test_zeros(shape, dtype):
         dtype=shared_dtypes,
         shape=xps.array_shapes(),
     ),
-    dtype=one_of(none(), shared_dtypes),
+    dtype=one_of(none(), shared_dtypes.flatmap(promotable_dtypes)),
 )
 def test_zeros_like(a, dtype):
     kwargs = {} if dtype is None else {'dtype': dtype}
@@ -311,11 +311,11 @@ def test_zeros_like(a, dtype):
 
     a_like = zeros_like(a, **kwargs)
 
-    if kwargs is None:
+    if dtype is None:
         # TODO: Should it actually match a.dtype?
         pass
     else:
-        assert a_like.dtype == a.dtype, "zeros_like() produced an array with an incorrect dtype"
+        assert a_like.dtype == dtype, "zeros_like() produced an array with an incorrect dtype"
 
     assert a_like.shape == a.shape, "zeros_like() produced an array with an incorrect shape"
     assert all(equal(a_like, full((), ZERO, dtype=a_like.dtype))), "zeros_like() array did not equal 0"

array_api_tests/test_elementwise_functions.py

@@ -25,7 +25,7 @@
                                  integer_or_boolean_dtype_objects,
                                  boolean_dtype_objects, floating_dtypes,
                                  numeric_dtypes, integer_or_boolean_dtypes,
-                                 boolean_dtypes, mutually_promotable_dtypes,
+                                 boolean_dtypes, mutually_promotable_dtype_pairs,
                                  array_scalars, xps)
 from .array_helpers import (assert_exactly_equal, negative,
                             positive_mathematical_sign,
@@ -50,17 +50,17 @@
 integer_or_boolean_scalars = array_scalars(integer_or_boolean_dtypes)
 boolean_scalars = array_scalars(boolean_dtypes)
 
-two_integer_dtypes = mutually_promotable_dtypes(integer_dtype_objects)
-two_floating_dtypes = mutually_promotable_dtypes(floating_dtype_objects)
-two_numeric_dtypes = mutually_promotable_dtypes(numeric_dtype_objects)
-two_integer_or_boolean_dtypes = mutually_promotable_dtypes(integer_or_boolean_dtype_objects)
-two_boolean_dtypes = mutually_promotable_dtypes(boolean_dtype_objects)
-two_any_dtypes = mutually_promotable_dtypes()
+two_integer_dtypes = mutually_promotable_dtype_pairs(integer_dtype_objects)
+two_floating_dtypes = mutually_promotable_dtype_pairs(floating_dtype_objects)
+two_numeric_dtypes = mutually_promotable_dtype_pairs(numeric_dtype_objects)
+two_integer_or_boolean_dtypes = mutually_promotable_dtype_pairs(integer_or_boolean_dtype_objects)
+two_boolean_dtypes = mutually_promotable_dtype_pairs(boolean_dtype_objects)
+two_any_dtypes = mutually_promotable_dtype_pairs()
 
 @composite
 def two_array_scalars(draw, dtype1, dtype2):
     # two_dtypes should be a strategy that returns two dtypes (like
-    # mutually_promotable_dtypes())
+    # mutually_promotable_dtype_pairs())
     return draw(array_scalars(just(dtype1))), draw(array_scalars(just(dtype2)))
 
 def sanity_check(x1, x2):