Merge branch 'master' into provider-conformance-realization

Author: Liam-DeVoe

.gitignore

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

hypothesis-python/docs/changelog.rst

@@ -18,6 +18,31 @@ Hypothesis 6.x
 
     .. include:: ../RELEASE.rst
 
+.. _v6.140.1:
+
+--------------------
+6.140.1 - 2025-09-22
+--------------------
+
+This patch re-enables the warning for incompatible :func:`~hypothesis.strategies.shared`
+strategies that was first enabled in :v:`6.133.0` but disabled in :v:`6.135.15`.
+
+.. _v6.140.0:
+
+--------------------
+6.140.0 - 2025-09-22
+--------------------
+
+|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.
+
+.. _v6.139.3:
+
+--------------------
+6.139.3 - 2025-09-22
+--------------------
+
+Add ``phase`` to the :ref:`hypothesis-specific metadata <observability-hypothesis-metadata>` in :ref:`observability <observability>`.
+
 .. _v6.139.2:
 
 --------------------

hypothesis-python/docs/reference/schema_metadata.json

@@ -47,6 +47,10 @@
             "type": "number",
             "description": "The unix timestamp when Hypothesis was imported."
         },
+        "phase": {
+            "type": "string",
+            "description": "The Hypothesis |Phase| this test case was generated in."
+        },
         "data_status": {
             "type": "number",
             "enum": [0, 1, 2, 3],

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()
@@ -720,16 +706,15 @@ def __init__(
         self._sampled_from_all_strategies_elements_message: Optional[
             tuple[str, object]
         ] = None
-        self._shared_strategy_draws: dict[Hashable, tuple[int, Any]] = {}
+        self._shared_strategy_draws: dict[Hashable, tuple[Any, "SearchStrategy"]] = {}
         self._shared_data_strategy: Optional[DataObject] = None
         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):
@@ -168,8 +172,8 @@ class RunIsComplete(Exception):
 def _get_provider(backend: str) -> Union[type, PrimitiveProvider]:
     provider_cls = AVAILABLE_PROVIDERS[backend]
     if isinstance(provider_cls, str):
-        mname, cname = provider_cls.rsplit(".", 1)
-        provider_cls = getattr(importlib.import_module(mname), cname)
+        module_name, class_name = provider_cls.rsplit(".", 1)
+        provider_cls = getattr(importlib.import_module(module_name), class_name)
 
     if provider_cls.lifetime == "test_function":
         return provider_cls(None)
@@ -309,13 +313,9 @@ def __init__(
         self.first_bug_found_at: Optional[int] = None
         self.last_bug_found_at: Optional[int] = None
 
-        # At runtime, the keys are only ever type `InterestingOrigin`, but can be `None` during tests.
-        self.shrunk_examples: set[Optional[InterestingOrigin]] = set()
-
+        self.shrunk_examples: set[InterestingOrigin] = set()
         self.health_check_state: Optional[HealthCheckState] = None
-
         self.tree: DataTree = DataTree()
-
         self.provider: Union[type, PrimitiveProvider] = _get_provider(
             self.settings.backend
         )
@@ -386,8 +386,6 @@ def _log_phase_statistics(
             self._current_phase = phase
             yield
         finally:
-            # We ignore the mypy type error here. Because `phase` is a string literal and "-phase" is a string literal
-            # as well, the concatenation will always be valid key in the dictionary.
             self.statistics[phase + "-phase"] = {  # type: ignore
                 "duration-seconds": time.perf_counter() - start_time,
                 "test-cases": list(self.stats_per_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/conjecture/utils.py

@@ -16,11 +16,13 @@
 from collections import OrderedDict, abc
 from collections.abc import Sequence
 from functools import lru_cache
-from typing import TYPE_CHECKING, Optional, TypeVar, Union
+from types import FunctionType
+from typing import TYPE_CHECKING, Callable, Optional, TypeVar, Union
 
 from hypothesis.errors import InvalidArgument
 from hypothesis.internal.compat import int_from_bytes
 from hypothesis.internal.floats import next_up
+from hypothesis.internal.lambda_sources import _function_key
 
 if TYPE_CHECKING:
     from hypothesis.internal.conjecture.data import ConjectureData
@@ -34,6 +36,20 @@ def calc_label_from_name(name: str) -> int:
     return int_from_bytes(hashed[:8])
 
 
+def calc_label_from_callable(f: Callable) -> int:
+    if isinstance(f, FunctionType):
+        return calc_label_from_hash(_function_key(f, ignore_name=True))
+    elif isinstance(f, type):
+        return calc_label_from_cls(f)
+    else:
+        # probably an instance defining __call__
+        try:
+            return calc_label_from_hash(f)
+        except Exception:
+            # not hashable
+            return calc_label_from_cls(type(f))
+
+
 def calc_label_from_cls(cls: type) -> int:
     return calc_label_from_name(cls.__qualname__)