Merge pull request #3275 from honno/parametrize-xp-tests

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,13 @@
+RELEASE_TYPE: patch
+
+This patch simplifies the repr of the strategies namespace returned in
+:func:`~hypothesis.extra.array_api.make_strategies_namespace`, e.g.
+
+.. code-block:: pycon
+
+    >>> from hypothesis.extra.array_api import make_strategies_namespace
+    >>> from numpy import array_api as xp
+    >>> xps = make_strategies_namespace(xp)
+    >>> xps
+    make_strategies_namespace(numpy.array_api)
+

hypothesis-python/src/hypothesis/extra/array_api.py

@@ -863,7 +863,11 @@ def floating_dtypes(
     unsigned_integer_dtypes.__doc__ = _unsigned_integer_dtypes.__doc__
     floating_dtypes.__doc__ = _floating_dtypes.__doc__
 
-    return SimpleNamespace(
+    class PrettySimpleNamespace(SimpleNamespace):
+        def __repr__(self):
+            return f"make_strategies_namespace({xp.__name__})"
+
+    return PrettySimpleNamespace(
         from_dtype=from_dtype,
         arrays=arrays,
         array_shapes=array_shapes,

hypothesis-python/tests/array_api/README.md

@@ -0,0 +1,32 @@
+This folder contains tests for `hypothesis.extra.array_api`.
+
+## Running against different array modules
+
+By default it will run against `numpy.array_api`. If that's not available
+(likely because an older NumPy version is installed), these tests will fallback
+to using the mock defined at the bottom of `src/hypothesis/extra/array_api.py`.
+
+You can test other array modules which adopt the Array API via the
+`HYPOTHESIS_TEST_ARRAY_API` environment variable. There are two recognized
+options:
+
+* `"default"`: only uses `numpy.array_api`, or if not available, fallbacks to the mock.
+* `"all"`: uses all array modules found via entry points, _and_ the mock.
+
+If neither of these, the test suite will then try resolve the variable like so:
+
+1. If the variable matches a name of an available entry point, load said entry point.
+2. If the variables matches a valid import path, import said path.
+
+For example, to specify NumPy's Array API implementation, you could use its
+entry point (**1.**),
+
+    HYPOTHESIS_TEST_ARRAY_API=numpy pytest tests/array_api
+
+or use the import path (**2.**),
+
+    HYPOTHESIS_TEST_ARRAY_API=numpy.array_api pytest tests/array_api
+
+The former method is more ergonomic, but as entry points are optional for
+adopting the Array API, you will need to use the latter method for libraries
+that opt-out.

hypothesis-python/tests/array_api/common.py

@@ -10,19 +10,12 @@
 
 from importlib.metadata import EntryPoint, entry_points  # type: ignore
 from typing import Dict
-from warnings import catch_warnings
 
-import pytest
-
-from hypothesis.errors import HypothesisWarning
-from hypothesis.extra.array_api import make_strategies_namespace, mock_xp
 from hypothesis.internal.floats import next_up
 
 __all__ = [
-    "xp",
-    "xps",
-    "COMPLIANT_XP",
-    "WIDTHS_FTZ",
+    "installed_array_modules",
+    "flushes_to_zero",
 ]
 
 
@@ -44,25 +37,14 @@ def installed_array_modules() -> Dict[str, EntryPoint]:
     return {ep.name: ep for ep in eps}
 
 
-# We try importing the Array API namespace from NumPy first, which modern
-# versions should include. If not available we default to our own mocked module,
-# which should allow our test suite to still work. A constant is set accordingly
-# to inform our test suite of whether the array module here is a mock or not.
-modules = installed_array_modules()
-try:
-    with catch_warnings():  # NumPy currently warns on import
-        xp = modules["numpy"].load()
-except KeyError:
-    xp = mock_xp
-    with pytest.warns(HypothesisWarning):
-        xps = make_strategies_namespace(xp)
-    COMPLIANT_XP = False
-else:
-    xps = make_strategies_namespace(xp)
-    COMPLIANT_XP = True
+def flushes_to_zero(xp, width: int) -> bool:
+    """Infer whether build of array module has its float dtype of the specified
+    width flush subnormals to zero
 
-# Infer whether build of array module has its float flush subnormals to zero
-WIDTHS_FTZ = {
-    32: bool(xp.asarray(next_up(0.0, width=32), dtype=xp.float32) == 0),
-    64: bool(xp.asarray(next_up(0.0, width=64), dtype=xp.float64) == 0),
-}
+    We do this per-width because compilers might FTZ for one dtype but allow
+    subnormals in the other.
+    """
+    if width not in [32, 64]:
+        raise ValueError(f"{width=}, but should be either 32 or 64")
+    dtype = getattr(xp, f"float{width}")
+    return bool(xp.asarray(next_up(0.0, width=width), dtype=dtype) == 0)

hypothesis-python/tests/array_api/conftest.py

@@ -0,0 +1,72 @@
+# This file is part of Hypothesis, which may be found at
+# https://github.com/HypothesisWorks/hypothesis/
+#
+# Copyright the Hypothesis Authors.
+# Individual contributors are listed in AUTHORS.rst and the git log.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License,
+# v. 2.0. If a copy of the MPL was not distributed with this file, You can
+# obtain one at https://mozilla.org/MPL/2.0/.
+
+import warnings
+from importlib import import_module
+from os import getenv
+
+import pytest
+
+from hypothesis.errors import HypothesisWarning
+from hypothesis.extra.array_api import make_strategies_namespace, mock_xp
+
+from tests.array_api.common import installed_array_modules
+
+with pytest.warns(HypothesisWarning):
+    mock_xps = make_strategies_namespace(mock_xp)
+
+# See README.md in regards to the HYPOTHESIS_TEST_ARRAY_API env variable
+test_xp_option = getenv("HYPOTHESIS_TEST_ARRAY_API", "default")
+name_to_entry_point = installed_array_modules()
+with warnings.catch_warnings():
+    # We ignore all warnings here as many array modules warn on import
+    warnings.simplefilter("ignore")
+    # We go through the steps described in README.md to define `params`, which
+    # contains the array module(s) to be ran against the test suite.
+    # Specifically `params` is a list of pytest parameters, with each parameter
+    # containing the array module and its respective strategies namespace.
+    if test_xp_option == "default":
+        try:
+            xp = name_to_entry_point["numpy"].load()
+            xps = make_strategies_namespace(xp)
+            params = [pytest.param(xp, xps, id="numpy")]
+        except KeyError:
+            params = [pytest.param(mock_xp, mock_xps, id="mock")]
+    elif test_xp_option == "all":
+        if len(name_to_entry_point) == 0:
+            raise ValueError(
+                "HYPOTHESIS_TEST_ARRAY_API='all', but no entry points where found"
+            )
+        params = [pytest.param(mock_xp, mock_xps, id="mock")]
+        for name, ep in name_to_entry_point.items():
+            xp = ep.load()
+            xps = make_strategies_namespace(xp)
+            params.append(pytest.param(xp, xps, id=name))
+    elif test_xp_option in name_to_entry_point.keys():
+        ep = name_to_entry_point[test_xp_option]
+        xp = ep.load()
+        xps = make_strategies_namespace(xp)
+        params = [pytest.param(xp, xps, id=test_xp_option)]
+    else:
+        try:
+            xp = import_module(test_xp_option)
+            xps = make_strategies_namespace(xp)
+            params = [pytest.param(xp, xps, id=test_xp_option)]
+        except ImportError as e:
+            raise ValueError(
+                f"HYPOTHESIS_TEST_ARRAY_API='{test_xp_option}' is not a valid "
+                "option ('default' or 'all'), name of an available entry point, "
+                "or a valid import path."
+            ) from e
+
+
+def pytest_generate_tests(metafunc):
+    if "xp" in metafunc.fixturenames and "xps" in metafunc.fixturenames:
+        metafunc.parametrize("xp, xps", params)