Use label only, modify label to discriminate by args

Author: jobh

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,11 @@
 )
 from hypothesis.internal.conjecture.data import ConjectureData
 from hypothesis.internal.conjecture.utils import (
+    calc_label_from_callable,
     calc_label_from_cls,
+    calc_label_from_hash,
     check_sample,
+    combine_labels,
     identity,
 )
 from hypothesis.internal.entropy import get_seeder_and_restorer
@@ -1053,6 +1056,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_hash(k) for k in self.kwargs.keys()],
+            *[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 +1887,7 @@ 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 calc_label_from_callable(self.definition)
 
 
 class DrawFn(Protocol):

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

@@ -15,6 +15,7 @@
 
 from hypothesis.control import reject
 from hypothesis.errors import InvalidArgument
+from hypothesis.internal.conjecture.utils import calc_label_from_hash, combine_labels
 from hypothesis.internal.conjecture.data import ConjectureData
 from hypothesis.internal.filtering import (
     get_float_predicate_bounds,
@@ -66,6 +67,13 @@ def __repr__(self) -> str:
             return f"integers(max_value={self.end})"
         return f"integers({self.start}, {self.end})"
 
+    def calc_label(self) -> int:
+        return combine_labels(
+            self.class_label,
+            calc_label_from_hash(self.start),
+            calc_label_from_hash(self.end),
+        )
+
     def do_draw(self, data: ConjectureData) -> int:
         # For bounded integers, make the bounds and near-bounds more likely.
         weights = None
@@ -181,6 +189,15 @@ def __repr__(self) -> str:
             f"{self.allow_nan=}, {self.smallest_nonzero_magnitude=})"
         ).replace("self.", "")
 
+    def calc_label(self) -> int:
+        return combine_labels(
+            self.class_label,
+            calc_label_from_hash(self.min_value),
+            calc_label_from_hash(self.max_value),
+            calc_label_from_hash(self.allow_nan),
+            calc_label_from_hash(self.smallest_nonzero_magnitude),
+        )
+
     def do_draw(self, data: ConjectureData) -> float:
         return data.draw_float(
             min_value=self.min_value,

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

@@ -43,19 +43,14 @@ def do_draw(self, data: ConjectureData) -> Any:
         else:
             drawn, other = data._shared_strategy_draws[key]
 
-            if other.base is not self.base:
-                # Check that the strategies shared under this key are equivalent,
-                # approximated as having equal `repr`s. False positives are ok,
-                # false negatives (erroneous warnings) less so.
-                if not hasattr(self, "_is_compatible"):
-                    self._is_compatible = repr(self.base) == repr(other.base)
-                if not self._is_compatible:
-                    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.base!r}, {other.base!r}).",
-                        HypothesisWarning,
-                        stacklevel=1,
-                    )
+            # Check that the strategies shared under this key are equivalent
+            if self.base.label != other.base.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.base!r}, {other.base!r}).",
+                    HypothesisWarning,
+                    stacklevel=1,
+                )
         return drawn

hypothesis-python/tests/cover/test_direct_strategies.py

@@ -592,16 +592,11 @@ def test_builds_error_messages(data):
         (st.integers(), st.integers(0)),
         (st.builds(int), st.builds(float)),
         (st.none(), st.integers()),
-        pytest.param(
+        (
             st.composite(lambda draw: draw(st.none()))(),
             st.composite(lambda draw: draw(st.integers()))(),
-            marks=pytest.mark.xfail(
-                # https://github.com/pytest-dev/pytest/issues/8928
-                raises=pytest.fail.Exception,
-                strict=True,
-                reason="same-name incompatible @composite",
-            ),
         ),
+        (st.builds(int, st.integers()), st.builds(int, st.integers(0))),
     ],
 )
 def test_incompatible_shared_strategies_warns(strat_a, strat_b):
@@ -633,24 +628,11 @@ def _composite2(draw):
         (st.floats(allow_nan=False), st.floats(allow_nan=False)),
         (st.builds(float), st.builds(float)),
         (_composite1(), _composite1()),
-        pytest.param(
+        (
             st.floats(allow_nan=False, allow_infinity=False),
             st.floats(allow_nan=False, allow_infinity=0),
-            marks=pytest.mark.xfail(
-                raises=HypothesisWarning,
-                strict=True,
-                reason="un-normalized constraint value (issue #4417)",
-            ),
-        ),
-        pytest.param(
-            _composite1(),
-            _composite2(),
-            marks=pytest.mark.xfail(
-                raises=HypothesisWarning,
-                strict=True,
-                reason="differently named @composites",
-            ),
         ),
+        (_composite1(), _composite2()),
         pytest.param(
             st.integers().flatmap(st.just),
             st.integers(),