Make hh.shapes a wrapper function, rudimentary test_concat

Author: honno

array_api_tests/hypothesis_helpers.py

@@ -113,15 +113,21 @@ def tuples(elements, *, min_size=0, max_size=None, unique_by=None, unique=False)
 
 # Use this to avoid memory errors with NumPy.
 # See https://github.com/numpy/numpy/issues/15753
-shapes = xps.array_shapes(min_dims=0, min_side=0).filter(
-    lambda shape: prod(i for i in shape if i) < MAX_ARRAY_SIZE
-)
+def shapes(**kw):
+    if 'min_dims' not in kw.keys():
+        kw['min_dims'] = 0
+    if 'min_side' not in kw.keys():
+        kw['min_side'] = 0
+    return xps.array_shapes(**kw).filter(
+        lambda shape: prod(i for i in shape if i) < MAX_ARRAY_SIZE
+    )
+
 
 one_d_shapes = xps.array_shapes(min_dims=1, max_dims=1, min_side=0, max_side=SQRT_MAX_ARRAY_SIZE)
 
 # Matrix shapes assume stacks of matrices
 @composite
-def matrix_shapes(draw, stack_shapes=shapes):
+def matrix_shapes(draw, stack_shapes=shapes()):
     stack_shape = draw(stack_shapes)
     mat_shape = draw(xps.array_shapes(max_dims=2, min_dims=2))
     shape = stack_shape + mat_shape
@@ -159,13 +165,13 @@ def positive_definite_matrices(draw, dtypes=xps.floating_dtypes()):
     # using something like
     # https://github.com/scikit-learn/scikit-learn/blob/844b4be24/sklearn/datasets/_samples_generator.py#L1351.
     n = draw(integers(0))
-    shape = draw(shapes) + (n, n)
+    shape = draw(shapes()) + (n, n)
     assume(prod(i for i in shape if i) < MAX_ARRAY_SIZE)
     dtype = draw(dtypes)
     return broadcast_to(eye(n, dtype=dtype), shape)
 
 @composite
-def invertible_matrices(draw, dtypes=xps.floating_dtypes(), stack_shapes=shapes):
+def invertible_matrices(draw, dtypes=xps.floating_dtypes(), stack_shapes=shapes()):
     # For now, just generate stacks of diagonal matrices.
     n = draw(integers(0, SQRT_MAX_ARRAY_SIZE),)
     stack_shape = draw(stack_shapes)

array_api_tests/meta_tests/test_hypothesis_helpers.py

@@ -32,7 +32,7 @@ def valid_shape(shape) -> bool:
     )
 
 
-@given(hh.shapes)
+@given(hh.shapes())
 def test_shapes(shape):
     assert valid_shape(shape)
 

array_api_tests/test_broadcasting.py

@@ -110,7 +110,7 @@ def test_broadcast_shapes_explicit_spec():
 @pytest.mark.parametrize('func_name', [i for i in
                                        elementwise_functions.__all__ if
                                        nargs(i) > 1])
-@given(shape1=shapes, shape2=shapes, data=data())
+@given(shape1=shapes(), shape2=shapes(), data=data())
 def test_broadcasting_hypothesis(func_name, shape1, shape2, data):
     # Internal consistency checks
     assert nargs(func_name) == 2

array_api_tests/test_creation_functions.py

@@ -70,7 +70,7 @@ def test_arange(start, stop, step, dtype):
                  or step < 0 and stop <= start)):
             assert a.size == ceil(asarray((stop-start)/step)), "arange() produced an array of the incorrect size"
 
-@given(shapes, kwargs(dtype=none() | shared_dtypes))
+@given(shapes(), kwargs(dtype=none() | shared_dtypes))
 def test_empty(shape, kw):
     out = empty(shape, **kw)
     dtype = kw.get("dtype", None) or xp.float64
@@ -84,7 +84,7 @@ def test_empty(shape, kw):
 
 
 @given(
-    x=xps.arrays(dtype=xps.scalar_dtypes(), shape=shapes),
+    x=xps.arrays(dtype=xps.scalar_dtypes(), shape=shapes()),
     kw=kwargs(dtype=none() | xps.scalar_dtypes())
 )
 def test_empty_like(x, kw):
@@ -136,7 +136,7 @@ def full_fill_values(draw):
 
 
 @given(
-    shape=shapes,
+    shape=shapes(),
     fill_value=full_fill_values(),
     kw=shared(kwargs(dtype=none() | xps.scalar_dtypes()), key="full_kw"),
 )
@@ -174,7 +174,7 @@ def full_like_fill_values(draw):
 
 
 @given(
-    x=xps.arrays(dtype=shared_dtypes, shape=shapes),
+    x=xps.arrays(dtype=shared_dtypes, shape=shapes()),
     fill_value=full_like_fill_values(),
     kw=shared(kwargs(dtype=none() | xps.scalar_dtypes()), key="full_like_kw"),
 )
@@ -245,7 +245,7 @@ def make_one(dtype):
         return True
 
 
-@given(shapes, kwargs(dtype=none() | xps.scalar_dtypes()))
+@given(shapes(), kwargs(dtype=none() | xps.scalar_dtypes()))
 def test_ones(shape, kw):
     out = ones(shape, **kw)
     dtype = kw.get("dtype", None) or xp.float64
@@ -258,7 +258,7 @@ def test_ones(shape, kw):
 
 
 @given(
-    x=xps.arrays(dtype=dtypes, shape=shapes),
+    x=xps.arrays(dtype=dtypes, shape=shapes()),
     kw=kwargs(dtype=none() | xps.scalar_dtypes()),
 )
 def test_ones_like(x, kw):
@@ -281,7 +281,7 @@ def make_zero(dtype):
         return False
 
 
-@given(shapes, kwargs(dtype=none() | xps.scalar_dtypes()))
+@given(shapes(), kwargs(dtype=none() | xps.scalar_dtypes()))
 def test_zeros(shape, kw):
     out = zeros(shape, **kw)
     dtype = kw.get("dtype", None) or xp.float64
@@ -294,7 +294,7 @@ def test_zeros(shape, kw):
 
 
 @given(
-    x=xps.arrays(dtype=dtypes, shape=shapes),
+    x=xps.arrays(dtype=dtypes, shape=shapes()),
     kw=kwargs(dtype=none() | xps.scalar_dtypes()),
 )
 def test_zeros_like(x, kw):

array_api_tests/test_elementwise_functions.py

@@ -49,7 +49,7 @@ def sanity_check(x1, x2):
     except ValueError:
         raise RuntimeError("Error in test generation (probably a bug in the test suite")
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_abs(x):
     if dh.is_int_dtype(x.dtype):
         minval = dh.dtype_ranges[x.dtype][0]
@@ -66,7 +66,7 @@ def test_abs(x):
     # abs(x) = x for x >= 0
     ah.assert_exactly_equal(a[ah.logical_not(less_zero)], x[ah.logical_not(less_zero)])
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_acos(x):
     a = xp.acos(x)
     ONE = ah.one(x.shape, x.dtype)
@@ -80,7 +80,7 @@ def test_acos(x):
     # nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_acosh(x):
     a = xp.acosh(x)
     ONE = ah.one(x.shape, x.dtype)
@@ -102,7 +102,7 @@ def test_add(x1, x2):
     ah.assert_exactly_equal(a, b)
     # TODO: Test that add is actually addition
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_asin(x):
     a = xp.asin(x)
     ONE = ah.one(x.shape, x.dtype)
@@ -113,7 +113,7 @@ def test_asin(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_asinh(x):
     a = xp.asinh(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -123,7 +123,7 @@ def test_asinh(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_atan(x):
     a = xp.atan(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -170,7 +170,7 @@ def test_atan2(x1, x2):
     ah.assert_exactly_equal(ah.logical_or(ah.logical_and(negx1, posx2),
                                     ah.logical_and(negx1, negx2)), nega)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_atanh(x):
     a = xp.atanh(x)
     ONE = ah.one(x.shape, x.dtype)
@@ -230,7 +230,7 @@ def test_bitwise_left_shift(x1, x2):
         vals_shift = ah.int_to_dtype(vals_shift, dh.dtype_nbits[out.dtype], dh.dtype_signed[out.dtype])
         assert vals_shift == res
 
-@given(xps.arrays(dtype=hh.integer_or_boolean_dtypes, shape=hh.shapes))
+@given(xps.arrays(dtype=hh.integer_or_boolean_dtypes, shape=hh.shapes()))
 def test_bitwise_invert(x):
     out = xp.bitwise_invert(x)
     # Compare against the Python ~ operator.
@@ -322,7 +322,7 @@ def test_bitwise_xor(x1, x2):
             vals_xor = ah.int_to_dtype(vals_xor, dh.dtype_nbits[out.dtype], dh.dtype_signed[out.dtype])
             assert vals_xor == res
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_ceil(x):
     # This test is almost identical to test_floor()
     a = xp.ceil(x)
@@ -333,7 +333,7 @@ def test_ceil(x):
     integers = ah.isintegral(x)
     ah.assert_exactly_equal(a[integers], x[integers])
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_cos(x):
     a = xp.cos(x)
     ONE = ah.one(x.shape, x.dtype)
@@ -344,7 +344,7 @@ def test_cos(x):
     # to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_cosh(x):
     a = xp.cosh(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -379,7 +379,7 @@ def test_equal(x1, x2):
 
     # First we broadcast the arrays so that they can be indexed uniformly.
     # TODO: it should be possible to skip this step if we instead generate
-    # indices to x1 and x2 that correspond to the broadcasted hh.shapes. This
+    # indices to x1 and x2 that correspond to the broadcasted shapes. This
     # would avoid the dependence in this test on broadcast_to().
     shape = broadcast_shapes(x1.shape, x2.shape)
     _x1 = xp.broadcast_to(x1, shape)
@@ -414,7 +414,7 @@ def test_equal(x1, x2):
         assert aidx.shape == x1idx.shape == x2idx.shape
         assert bool(aidx) == (scalar_func(x1idx) == scalar_func(x2idx))
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_exp(x):
     a = xp.exp(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -425,7 +425,7 @@ def test_exp(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_expm1(x):
     a = xp.expm1(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -436,7 +436,7 @@ def test_expm1(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_floor(x):
     # This test is almost identical to test_ceil
     a = xp.floor(x)
@@ -529,7 +529,7 @@ def test_greater_equal(x1, x2):
         assert aidx.shape == x1idx.shape == x2idx.shape
         assert bool(aidx) == (scalar_func(x1idx) >= scalar_func(x2idx))
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_isfinite(x):
     a = ah.isfinite(x)
     TRUE = ah.true(x.shape)
@@ -545,7 +545,7 @@ def test_isfinite(x):
             s = float(x[idx])
             assert bool(a[idx]) == math.isfinite(s)
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_isinf(x):
     a = xp.isinf(x)
     FALSE = ah.false(x.shape)
@@ -560,7 +560,7 @@ def test_isinf(x):
             s = float(x[idx])
             assert bool(a[idx]) == math.isinf(s)
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_isnan(x):
     a = ah.isnan(x)
     FALSE = ah.false(x.shape)
@@ -633,7 +633,7 @@ def test_less_equal(x1, x2):
         assert aidx.shape == x1idx.shape == x2idx.shape
         assert bool(aidx) == (scalar_func(x1idx) <= scalar_func(x2idx))
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_log(x):
     a = xp.log(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -644,7 +644,7 @@ def test_log(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_log1p(x):
     a = xp.log1p(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -655,7 +655,7 @@ def test_log1p(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_log2(x):
     a = xp.log2(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -666,7 +666,7 @@ def test_log2(x):
     # mapped to nan, which is already tested in the special cases.
     ah.assert_exactly_equal(domain, codomain)
 
-@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.floating_dtypes(), shape=hh.shapes()))
 def test_log10(x):
     a = xp.log10(x)
     INFINITY = ah.infinity(x.shape, x.dtype)
@@ -698,7 +698,7 @@ def test_logical_and(x1, x2):
     for idx in ah.ndindex(shape):
         assert a[idx] == (bool(_x1[idx]) and bool(_x2[idx]))
 
-@given(xps.arrays(dtype=xp.bool, shape=hh.shapes))
+@given(xps.arrays(dtype=xp.bool, shape=hh.shapes()))
 def test_logical_not(x):
     a = ah.logical_not(x)
 
@@ -740,7 +740,7 @@ def test_multiply(x1, x2):
     # multiply is commutative
     ah.assert_exactly_equal(a, b)
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_negative(x):
     out = ah.negative(x)
 
@@ -790,7 +790,7 @@ def test_not_equal(x1, x2):
         assert bool(aidx) == (scalar_func(x1idx) != scalar_func(x2idx))
 
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_positive(x):
     out = xp.positive(x)
     # Positive does nothing
@@ -817,7 +817,7 @@ def test_remainder(x1, x2):
     not_nan = ah.logical_not(ah.logical_or(ah.isnan(out), ah.isnan(x2)))
     ah.assert_same_sign(out[not_nan], x2[not_nan])
 
-@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes))
+@given(xps.arrays(dtype=xps.numeric_dtypes(), shape=hh.shapes()))
 def test_round(x):
     a = xp.round(x)
 

array_api_tests/test_indexing.py

@@ -58,8 +58,8 @@ def test_slicing(size, s):
     for i in range(len(sliced_list)):
         assert sliced_array[i] == sliced_list[i], "Slice index did not give the same elements as slicing an equivalent Python list"
 
-@given(shared(shapes, key='array_shapes'),
-       multiaxis_indices(shapes=shared(shapes, key='array_shapes')))
+@given(shared(shapes(), key='array_shapes'),
+       multiaxis_indices(shapes=shared(shapes(), key='array_shapes')))
 def test_multiaxis_indexing(shape, idx):
     # NOTE: Out of bounds indices (both integer and slices) are out of scope
     # for the spec. If you get a (valid) out of bounds error, it indicates a