Merge pull request #4353 from tybug/refactor

Improve ast performance and refactor some code

Author: Zac-HD

.github/workflows/main.yml

@@ -252,7 +252,7 @@ jobs:
           pyodide xbuildenv install $PYODIDE_VERSION
       - name: Set up Pyodide venv and install dependencies
         run: |
-          pip install --upgrade setuptools pip wheel==0.45.1 build
+          pip install --upgrade setuptools pip wheel build
           python -m build --wheel hypothesis-python --outdir dist/
           pip download --dest=dist/ hypothesis-python/ pytest tzdata  # fetch all the wheels
 

hypothesis-python/RELEASE.rst

@@ -0,0 +1,3 @@
+RELEASE_TYPE: patch
+
+Refactor some internals.

hypothesis-python/src/hypothesis/control.py

@@ -132,13 +132,11 @@ def __init__(
         data: ConjectureData,
         *,
         is_final: bool = False,
-        close_on_capture: bool = True,
     ) -> None:
         self.data = data
         self.tasks: list[Callable[[], Any]] = []
         self.is_final = is_final
-        self.close_on_capture = close_on_capture
-        self.close_on_del = False
+
         # Use defaultdict(list) here to handle the possibility of having multiple
         # functions registered for the same object (due to caching, small ints, etc).
         # The printer will discard duplicates which return different representations.

hypothesis-python/src/hypothesis/core.py

@@ -1010,16 +1010,18 @@ def run(data):
 
         # self.test_runner can include the execute_example method, or setup/teardown
         # _example, so it's important to get the PRNG and build context in place first.
-        with local_settings(self.settings):
-            with deterministic_PRNG():
-                with BuildContext(data, is_final=is_final) as context:
-                    # providers may throw in per_case_context_fn, and we'd like
-                    # `result` to still be set in these cases.
-                    result = None
-                    with data.provider.per_test_case_context_manager():
-                        # Run the test function once, via the executor hook.
-                        # In most cases this will delegate straight to `run(data)`.
-                        result = self.test_runner(data, run)
+        with (
+            local_settings(self.settings),
+            deterministic_PRNG(),
+            BuildContext(data, is_final=is_final) as context,
+        ):
+            # providers may throw in per_case_context_fn, and we'd like
+            # `result` to still be set in these cases.
+            result = None
+            with data.provider.per_test_case_context_manager():
+                # Run the test function once, via the executor hook.
+                # In most cases this will delegate straight to `run(data)`.
+                result = self.test_runner(data, run)
 
         # If a failure was expected, it should have been raised already, so
         # instead raise an appropriate diagnostic error.

hypothesis-python/src/hypothesis/internal/conjecture/choice.py

@@ -540,10 +540,11 @@ def choice_permitted(choice: ChoiceT, constraints: ChoiceConstraintsT) -> bool:
         constraints = cast(FloatConstraints, constraints)
         if math.isnan(choice):
             return constraints["allow_nan"]
-        return (
-            sign_aware_lte(constraints["min_value"], choice)
-            and sign_aware_lte(choice, constraints["max_value"])
-        ) and not (0 < abs(choice) < constraints["smallest_nonzero_magnitude"])
+        if 0 < abs(choice) < constraints["smallest_nonzero_magnitude"]:
+            return False
+        return sign_aware_lte(constraints["min_value"], choice) and sign_aware_lte(
+            choice, constraints["max_value"]
+        )
     elif isinstance(choice, str):
         constraints = cast(StringConstraints, constraints)
         if len(choice) < constraints["min_size"]:

hypothesis-python/src/hypothesis/internal/constants_ast.py

@@ -23,7 +23,7 @@
 if TYPE_CHECKING:
     from typing import TypeAlias
 
-ConstantT: "TypeAlias" = Union[int, float, bool, bytes, str]
+ConstantT: "TypeAlias" = Union[int, float, bytes, str]
 
 
 class ConstantVisitor(NodeVisitor):
@@ -103,12 +103,20 @@ def _module_ast(module: ModuleType) -> Optional[AST]:
 def local_modules() -> tuple[ModuleType, ...]:
     modules = []
     for module in sys.modules.values():
-        if not hasattr(module, "__file__"):
-            continue
-        if module.__file__ is None:  # pragma: no cover
-            continue
-
-        if ModuleLocation.from_path(module.__file__) is not ModuleLocation.LOCAL:
+        if (
+            not hasattr(module, "__file__")
+            or module.__file__ is None
+            # Skip expensive path lookup for stdlib modules.
+            # This will cause false negatives if a user names their module the
+            # same as a stdlib module.
+            #
+            # sys.stdlib_module_names is new in 3.10
+            or (
+                sys.version_info >= (3, 10)
+                and module.__name__ in sys.stdlib_module_names
+            )
+            or ModuleLocation.from_path(module.__file__) is not ModuleLocation.LOCAL
+        ):
             continue
 
         modules.append(module)

hypothesis-python/src/hypothesis/internal/floats.py

@@ -139,41 +139,30 @@ def next_up_normal(value: float, width: int, *, allow_subnormal: bool) -> float:
 mantissa_mask = (1 << 52) - 1
 
 
-def float_permitted(
-    f: float,
-    *,
-    min_value: float,
-    max_value: float,
-    allow_nan: bool,
-    smallest_nonzero_magnitude: float,
-) -> bool:
-    if math.isnan(f):
-        return allow_nan
-    if 0 < abs(f) < smallest_nonzero_magnitude:
-        return False
-    return sign_aware_lte(min_value, f) and sign_aware_lte(f, max_value)
-
-
 def make_float_clamper(
     min_value: float,
     max_value: float,
     *,
-    smallest_nonzero_magnitude: float,
     allow_nan: bool,
+    smallest_nonzero_magnitude: float,
 ) -> Callable[[float], float]:
     """
     Return a function that clamps positive floats into the given bounds.
     """
+    from hypothesis.internal.conjecture.choice import choice_permitted
+
     assert sign_aware_lte(min_value, max_value)
     range_size = min(max_value - min_value, float_info.max)
 
     def float_clamper(f: float) -> float:
-        if float_permitted(
+        if choice_permitted(
             f,
-            min_value=min_value,
-            max_value=max_value,
-            allow_nan=allow_nan,
-            smallest_nonzero_magnitude=smallest_nonzero_magnitude,
+            {
+                "min_value": min_value,
+                "max_value": max_value,
+                "allow_nan": allow_nan,
+                "smallest_nonzero_magnitude": smallest_nonzero_magnitude,
+            },
         ):
             return f
         # Outside bounds; pick a new value, sampled from the allowed range,

hypothesis-python/src/hypothesis/internal/scrutineer.py

@@ -217,14 +217,14 @@ def get_explaining_locations(traces):
 
 # see e.g. https://docs.python.org/3/library/sysconfig.html#posix-user
 # for examples of these path schemes
-STDLIB_DIRS = [
+STDLIB_DIRS = {
     Path(sysconfig.get_path("platstdlib")).resolve(),
     Path(sysconfig.get_path("stdlib")).resolve(),
-]
-SITE_PACKAGES_DIRS = [
+}
+SITE_PACKAGES_DIRS = {
     Path(sysconfig.get_path("purelib")).resolve(),
     Path(sysconfig.get_path("platlib")).resolve(),
-]
+}
 
 EXPLANATION_STUB = (
     "Explanation:",

hypothesis-python/tests/cover/test_float_utils.py

@@ -14,10 +14,9 @@
 import pytest
 
 from hypothesis import example, given, strategies as st
-from hypothesis.internal.conjecture.choice import choice_equal
+from hypothesis.internal.conjecture.choice import choice_equal, choice_permitted
 from hypothesis.internal.floats import (
     count_between_floats,
-    float_permitted,
     make_float_clamper,
     next_down,
     next_up,
@@ -96,11 +95,13 @@ def test_float_clamper(constraints, input_value):
 
     # if input_value was permitted in the first place, then the clamped value should
     # be the same as the input value.
-    if float_permitted(
+    if choice_permitted(
         input_value,
-        min_value=min_value,
-        max_value=max_value,
-        allow_nan=allow_nan,
-        smallest_nonzero_magnitude=smallest_nonzero_magnitude,
+        {
+            "min_value": min_value,
+            "max_value": max_value,
+            "allow_nan": allow_nan,
+            "smallest_nonzero_magnitude": smallest_nonzero_magnitude,
+        },
     ):
         assert choice_equal(input_value, clamped)