Merge pull request #4509 from jobh/fix_shared_strategy_warnings

Fix shared strategy warnings

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,4 @@
+RELEASE_TYPE: patch
+
+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`.

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

@@ -706,7 +706,7 @@ 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

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__)
 

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

@@ -65,7 +65,7 @@ def visit_Attribute(self, node):
     return attributes
 
 
-def _function_key(f, *, bounded_size=False):
+def _function_key(f, *, bounded_size=False, ignore_name=False):
     """Returns a digest that differentiates functions that have different sources.
 
     Either a function or a code object may be passed. If code object, default
@@ -96,7 +96,7 @@ def _function_key(f, *, bounded_size=False):
         code.co_names,
         code.co_varnames,
         code.co_freevars,
-        code.co_name,
+        ignore_name or code.co_name,
     )
 
 

hypothesis-python/src/hypothesis/strategies/_internal/core.py

@@ -82,8 +82,10 @@
 )
 from hypothesis.internal.conjecture.data import ConjectureData
 from hypothesis.internal.conjecture.utils import (
-    calc_label_from_cls,
+    calc_label_from_callable,
+    calc_label_from_name,
     check_sample,
+    combine_labels,
     identity,
 )
 from hypothesis.internal.entropy import get_seeder_and_restorer
@@ -1053,6 +1055,15 @@ def __init__(
         self.args = args
         self.kwargs = kwargs
 
+    def calc_label(self) -> int:
+        return combine_labels(
+            self.class_label,
+            calc_label_from_callable(self.target),
+            *[strat.label for strat in self.args],
+            *[calc_label_from_name(k) for k in self.kwargs],
+            *[strat.label for strat in self.kwargs.values()],
+        )
+
     def do_draw(self, data: ConjectureData) -> Ex:
         args = [data.draw(s) for s in self.args]
         kwargs = {k: data.draw(v) for k, v in self.kwargs.items()}
@@ -1875,7 +1886,10 @@ def do_draw(self, data):
         return self.definition(data.draw, *self.args, **self.kwargs)
 
     def calc_label(self) -> int:
-        return calc_label_from_cls(self.definition)
+        return combine_labels(
+            self.class_label,
+            calc_label_from_callable(self.definition),
+        )
 
 
 class DrawFn(Protocol):

hypothesis-python/src/hypothesis/strategies/_internal/flatmapped.py

@@ -11,6 +11,10 @@
 from typing import Callable, Generic, TypeVar
 
 from hypothesis.internal.conjecture.data import ConjectureData
+from hypothesis.internal.conjecture.utils import (
+    calc_label_from_callable,
+    combine_labels,
+)
 from hypothesis.internal.reflection import get_pretty_function_description
 from hypothesis.strategies._internal.strategies import (
     RecurT,
@@ -35,6 +39,13 @@ def __init__(
     def calc_is_empty(self, recur: RecurT) -> bool:
         return recur(self.base)
 
+    def calc_label(self) -> int:
+        return combine_labels(
+            self.class_label,
+            self.base.label,
+            calc_label_from_callable(self.expand),
+        )
+
     def __repr__(self) -> str:
         if not hasattr(self, "_cached_repr"):
             self._cached_repr = (

hypothesis-python/src/hypothesis/strategies/_internal/shared.py

@@ -8,9 +8,11 @@
 # 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 collections.abc import Hashable
 from typing import Any, Optional
 
+from hypothesis.errors import HypothesisWarning
 from hypothesis.internal.conjecture.data import ConjectureData
 from hypothesis.strategies._internal import SearchStrategy
 from hypothesis.strategies._internal.strategies import Ex
@@ -28,30 +30,27 @@ def __repr__(self) -> str:
         else:
             return f"shared({self.base!r})"
 
+    def calc_label(self) -> int:
+        return self.base.calc_label()
+
     # Ideally would be -> Ex, but key collisions with different-typed values are
     # possible. See https://github.com/HypothesisWorks/hypothesis/issues/4301.
     def do_draw(self, data: ConjectureData) -> Any:
-        if self.key is None or getattr(self.base, "_is_singleton", False):
-            strat_label = id(self.base)
-        else:
-            # Assume that uncached strategies are distinguishable by their
-            # label. False negatives (even collisions w/id above) are ok as
-            # long as they are infrequent.
-            strat_label = self.base.label
         key = self.key or self
         if key not in data._shared_strategy_draws:
             drawn = data.draw(self.base)
-            data._shared_strategy_draws[key] = (strat_label, drawn)
+            data._shared_strategy_draws[key] = (drawn, self)
         else:
-            drawn_strat_label, drawn = data._shared_strategy_draws[key]
-            # Check disabled pending resolution of #4301
-            if drawn_strat_label != strat_label:  # pragma: no cover
-                pass
-                # warnings.warn(
-                #     f"Different strategies are shared under {key=}. This"
-                #     " risks drawing values that are not valid examples for the strategy,"
-                #     " or that have a narrower range than expected.",
-                #     HypothesisWarning,
-                #     stacklevel=1,
-                # )
+            drawn, other = data._shared_strategy_draws[key]
+
+            # Check that the strategies shared under this key are equivalent
+            if self.label != other.label:
+                warnings.warn(
+                    f"Different strategies are shared under {key=}. This"
+                    " risks drawing values that are not valid examples for the strategy,"
+                    " or that have a narrower range than expected."
+                    f" Conflicting strategies: ({self!r}, {other!r}).",
+                    HypothesisWarning,
+                    stacklevel=1,
+                )
         return drawn

hypothesis-python/src/hypothesis/strategies/_internal/strategies.py

@@ -702,7 +702,7 @@ def do_draw(self, data: ConjectureData) -> Ex:
             isinstance(x, SearchStrategy) for x in self.elements
         ):
             data._sampled_from_all_strategies_elements_message = (
-                "sample_from was given a collection of strategies: "
+                "sampled_from was given a collection of strategies: "
                 "{!r}. Was one_of intended?",
                 self.elements,
             )

hypothesis-python/src/hypothesis/strategies/_internal/utils.py

@@ -69,7 +69,6 @@ def cached_strategy(*args, **kwargs):
         else:
             result = fn(*args, **kwargs)
             if not isinstance(result, SearchStrategy) or result.is_cacheable:
-                result._is_singleton = True
                 _STRATEGY_CACHE[cache_key] = result
             return result
 

hypothesis-python/tests/conjecture/test_utils.py

@@ -208,3 +208,20 @@ def test_samples_from_a_range_directly():
 
 def test_p_continue_to_average_saturates():
     assert cu._p_continue_to_avg(1.1, 100) == 100
+
+
+def test_unhashable_calc_label():
+
+    class Unhashable:
+        def __call__(self):
+            return None
+
+        def __hash__(self):
+            raise TypeError
+
+    c1 = Unhashable()
+    c2 = Unhashable()
+
+    with pytest.raises(TypeError):
+        assert cu.calc_label_from_hash(c1) == cu.calc_label_from_hash(c2)
+    assert cu.calc_label_from_callable(c1) == cu.calc_label_from_callable(c2)