Merge pull request #4550 from Liam-DeVoe/mypyc

Add a `st.characters` validation, and mypyc typing changes

Author: Liam-DeVoe

.gitignore

@@ -1,3 +1,7 @@
+# mypyc
+
+*.so
+
 # misc (editors, file systems, etc)
 
 *.swo

hypothesis-python/RELEASE.rst

@@ -0,0 +1,3 @@
+RELEASE_TYPE: minor
+
+|st.characters| now validates that the elements of the ``exclude_characters`` and ``include_characters`` arguments are single characters, which was always assumed internally. For example, ``exclude_characters=["a", "b"]`` is valid while ``exclude_characters=["ab"]`` will now raise an error up-front.

hypothesis-python/src/hypothesis/core.py

@@ -942,7 +942,7 @@ def __init__(
         self._timing_features = {}
 
     @property
-    def test_identifier(self):
+    def test_identifier(self) -> str:
         return getattr(
             current_pytest_item.value, "nodeid", None
         ) or get_pretty_function_description(self.wrapped_test)

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

@@ -15,7 +15,7 @@
 import sys
 import tempfile
 import unicodedata
-from collections.abc import Iterable
+from collections.abc import Collection, Iterable
 from functools import cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal, Optional
@@ -78,7 +78,7 @@ def charmap_file(fname: str = "charmap") -> Path:
     )
 
 
-_charmap = None
+_charmap: Optional[dict[CategoryName, IntervalsT]] = None
 
 
 def charmap() -> dict[CategoryName, IntervalsT]:
@@ -293,8 +293,8 @@ def query(
     categories: Optional[Categories] = None,
     min_codepoint: Optional[int] = None,
     max_codepoint: Optional[int] = None,
-    include_characters: str = "",
-    exclude_characters: str = "",
+    include_characters: Collection[str] = "",
+    exclude_characters: Collection[str] = "",
 ) -> IntervalSet:
     """Return a tuple of intervals covering the codepoints for all characters
     that meet the criteria.
@@ -314,8 +314,8 @@ def query(
     if max_codepoint is None:
         max_codepoint = sys.maxunicode
     catkey = _category_key(categories)
-    character_intervals = IntervalSet.from_string(include_characters or "")
-    exclude_intervals = IntervalSet.from_string(exclude_characters or "")
+    character_intervals = IntervalSet.from_string("".join(include_characters))
+    exclude_intervals = IntervalSet.from_string("".join(exclude_characters))
     qkey = (
         catkey,
         min_codepoint,

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

@@ -115,19 +115,6 @@ def __getattr__(name: str) -> Any:
 threadlocal = ThreadLocal(global_test_counter=int)
 
 
-class ExtraInformation:
-    """A class for holding shared state on a ``ConjectureData`` that should
-    be added to the final ``ConjectureResult``."""
-
-    def __repr__(self) -> str:
-        return "ExtraInformation({})".format(
-            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
-        )
-
-    def has_information(self) -> bool:
-        return bool(self.__dict__)
-
-
 class Status(IntEnum):
     OVERRUN = 0
     INVALID = 1
@@ -597,7 +584,6 @@ class ConjectureResult:
     nodes: tuple[ChoiceNode, ...] = attr.ib(eq=False, repr=False)
     length: int = attr.ib()
     output: str = attr.ib()
-    extra_information: Optional[ExtraInformation] = attr.ib()
     expected_exception: Optional[BaseException] = attr.ib()
     expected_traceback: Optional[str] = attr.ib()
     has_discards: bool = attr.ib()
@@ -725,11 +711,10 @@ def __init__(
         self._stateful_repr_parts: Optional[list[Any]] = None
         self.states_for_ids: Optional[dict[int, RandomState]] = None
         self.seeds_to_states: Optional[dict[Any, RandomState]] = None
-        self.hypothesis_runner = not_set
+        self.hypothesis_runner: Any = not_set
 
         self.expected_exception: Optional[BaseException] = None
         self.expected_traceback: Optional[str] = None
-        self.extra_information = ExtraInformation()
 
         self.prefix = prefix
         self.nodes: tuple[ChoiceNode, ...] = ()
@@ -1165,11 +1150,6 @@ def as_result(self) -> Union[ConjectureResult, _Overrun]:
                 output=self.output,
                 expected_traceback=self.expected_traceback,
                 expected_exception=self.expected_exception,
-                extra_information=(
-                    self.extra_information
-                    if self.extra_information.has_information()
-                    else None
-                ),
                 has_discards=self.has_discards,
                 target_observations=self.target_observations,
                 tags=frozenset(self.tags),

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

@@ -220,7 +220,7 @@ def compute_max_children(
         # or downwards with our full 128 bit generation, but only half of these
         # (plus one for the case of generating zero) result in a probe in the
         # direction we want. ((2**128 - 1) // 2) + 1 == 2 ** 127
-        assert (min_value is None) ^ (max_value is None)
+        assert (min_value is None) != (max_value is None)
         return 2**127
     elif choice_type == "boolean":
         constraints = cast(BooleanConstraints, constraints)

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

@@ -20,7 +20,7 @@
 from datetime import timedelta
 from enum import Enum
 from random import Random, getrandbits
-from typing import Callable, Final, Literal, NoReturn, Optional, Union, cast
+from typing import Callable, Literal, NoReturn, Optional, Union, cast
 
 from hypothesis import HealthCheck, Phase, Verbosity, settings as Settings
 from hypothesis._settings import local_settings, note_deprecation
@@ -71,11 +71,15 @@
 from hypothesis.internal.observability import Observation, with_observability_callback
 from hypothesis.reporting import base_report, report
 
+# In most cases, the following constants are all Final. However, we do allow users
+# to monkeypatch all of these variables, which means we cannot annotate them as
+# Final or mypyc will inline them and render monkeypatching useless.
+
 #: The maximum number of times the shrinker will reduce the complexity of a failing
 #: input before giving up. This avoids falling down a trap of exponential (or worse)
 #: complexity, where the shrinker appears to be making progress but will take a
 #: substantially long time to finish completely.
-MAX_SHRINKS: Final[int] = 500
+MAX_SHRINKS: int = 500
 
 # If the shrinking phase takes more than five minutes, abort it early and print
 # a warning.   Many CI systems will kill a build after around ten minutes with
@@ -87,17 +91,17 @@
 #: for before giving up. This is across all shrinks for the same failure, so even
 #: if the shrinker successfully reduces the complexity of a single failure several
 #: times, it will stop when it hits |MAX_SHRINKING_SECONDS| of total time taken.
-MAX_SHRINKING_SECONDS: Final[int] = 300
+MAX_SHRINKING_SECONDS: int = 300
 
 #: The maximum amount of entropy a single test case can use before giving up
 #: while making random choices during input generation.
 #:
 #: The "unit" of one |BUFFER_SIZE| does not have any defined semantics, and you
 #: should not rely on it, except that a linear increase |BUFFER_SIZE| will linearly
 #: increase the amount of entropy a test case can use during generation.
-BUFFER_SIZE: Final[int] = 8 * 1024
-CACHE_SIZE: Final[int] = 10000
-MIN_TEST_CALLS: Final[int] = 10
+BUFFER_SIZE: int = 8 * 1024
+CACHE_SIZE: int = 10000
+MIN_TEST_CALLS: int = 10
 
 
 def shortlex(s):
@@ -166,8 +170,8 @@ class RunIsComplete(Exception):
 
 
 def _get_provider(backend: str) -> Union[type, PrimitiveProvider]:
-    mname, cname = AVAILABLE_PROVIDERS[backend].rsplit(".", 1)
-    provider_cls = getattr(importlib.import_module(mname), cname)
+    module_name, class_name = AVAILABLE_PROVIDERS[backend].rsplit(".", 1)
+    provider_cls = getattr(importlib.import_module(module_name), class_name)
     if provider_cls.lifetime == "test_function":
         return provider_cls(None)
     elif provider_cls.lifetime == "test_case":

hypothesis-python/src/hypothesis/internal/conjecture/shrinking/integer.py

@@ -61,7 +61,7 @@ def try_mask(k):
             return self.consider(mask & base)
 
     @property
-    def size(self):
+    def size(self) -> int:
         return self.current.bit_length()
 
     def shrink_by_multiples(self, k):

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

@@ -13,11 +13,12 @@
 import sys
 import textwrap
 import traceback
+from dataclasses import dataclass
 from functools import partial
 from inspect import getframeinfo
 from pathlib import Path
 from types import ModuleType, TracebackType
-from typing import Callable, NamedTuple, Optional
+from typing import Callable, Optional
 
 import hypothesis
 from hypothesis.errors import _Trimmable
@@ -90,7 +91,8 @@ def get_trimmed_traceback(
     return tb
 
 
-class InterestingOrigin(NamedTuple):
+@dataclass(frozen=True)
+class InterestingOrigin:
     # The `interesting_origin` is how Hypothesis distinguishes between multiple
     # failures, for reporting and also to replay from the example database (even
     # if report_multiple_bugs=False).  We traditionally use the exception type and

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

@@ -37,7 +37,7 @@
 }
 
 
-def reinterpret_bits(x: float, from_: str, to: str) -> float:
+def reinterpret_bits(x: Union[float, int], from_: str, to: str) -> Union[float, int]:
     x = struct.unpack(to, struct.pack(from_, x))[0]
     assert isinstance(x, (float, int))
     return x
@@ -185,15 +185,17 @@ def float_clamper(f: float) -> float:
     return float_clamper
 
 
-def sign_aware_lte(x: float, y: float) -> bool:
+def sign_aware_lte(x: Union[float, int], y: Union[float, int]) -> bool:
     """Less-than-or-equals, but strictly orders -0.0 and 0.0"""
     if x == 0.0 == y:
         return math.copysign(1.0, x) <= math.copysign(1.0, y)
     else:
         return x <= y
 
 
-def clamp(lower: float, value: float, upper: float) -> float:
+def clamp(
+    lower: Union[float, int], value: Union[float, int], upper: Union[float, int]
+) -> Union[float, int]:
     """Given a value and lower/upper bounds, 'clamp' the value so that
     it satisfies lower <= value <= upper.  NaN is mapped to lower."""
     # this seems pointless (and is for integers), but handles the -0.0/0.0 case.