Improve pprint/to_jsonable symbolics

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,4 @@
+RELEASE_TYPE: patch
+
+This patch improves the interaction between the :pypi:`hypothesis-crosshair`
+:ref:`backend <alternative-backends>` and :ref:`our observability tools <observability>`.

hypothesis-python/src/hypothesis/core.py

@@ -955,27 +955,20 @@ def run(data):
                     printer.text("Trying example:")
 
                 if self.print_given_args:
-                    if data.provider.avoid_realization and not print_example:
-                        # we can do better here by adding
-                        # avoid_realization: bool = False to repr_call, which
-                        # maintains args/kwargs structure (and comments) but shows
-                        # <symbolic> in place of values. For now, this at least
-                        # avoids realization with verbosity <= verbose.
-                        printer.text(" <symbolics>")
-                    else:
-                        printer.text(" ")
-                        printer.repr_call(
-                            test.__name__,
-                            args,
-                            kwargs,
-                            force_split=True,
-                            arg_slices=argslices,
-                            leading_comment=(
-                                "# " + context.data.slice_comments[(0, 0)]
-                                if (0, 0) in context.data.slice_comments
-                                else None
-                            ),
-                        )
+                    printer.text(" ")
+                    printer.repr_call(
+                        test.__name__,
+                        args,
+                        kwargs,
+                        force_split=True,
+                        arg_slices=argslices,
+                        leading_comment=(
+                            "# " + context.data.slice_comments[(0, 0)]
+                            if (0, 0) in context.data.slice_comments
+                            else None
+                        ),
+                        avoid_realization=data.provider.avoid_realization,
+                    )
                 report(printer.getvalue())
 
             if TESTCASE_CALLBACKS:
@@ -991,11 +984,12 @@ def run(data):
                         if (0, 0) in context.data.slice_comments
                         else None
                     ),
+                    avoid_realization=data.provider.avoid_realization,
                 )
                 self._string_repr = printer.getvalue()
                 data._observability_arguments = {
-                    **dict(enumerate(map(to_jsonable, args))),
-                    **{k: to_jsonable(v) for k, v in kwargs.items()},
+                    k: to_jsonable(v, avoid_realization=data.provider.avoid_realization)
+                    for k, v in [*enumerate(args), *kwargs.items()]
                 }
 
             try:

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

@@ -1136,7 +1136,8 @@ def draw(
                 )
                 raise
             if TESTCASE_CALLBACKS:
-                self._observability_args[key] = to_jsonable(v)
+                avoid = self.provider.avoid_realization
+                self._observability_args[key] = to_jsonable(v, avoid_realization=avoid)
             return v
         finally:
             self.stop_span()

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

@@ -10,6 +10,7 @@
 
 import sys
 import threading
+from functools import partial
 from inspect import signature
 from typing import TYPE_CHECKING, Callable
 
@@ -156,7 +157,7 @@ def accept(*args, **kwargs):
     return decorator
 
 
-def to_jsonable(obj: object) -> object:
+def to_jsonable(obj: object, *, avoid_realization: bool) -> object:
     """Recursively convert an object to json-encodable form.
 
     This is not intended to round-trip, but rather provide an analysis-ready
@@ -165,26 +166,30 @@ def to_jsonable(obj: object) -> object:
     """
     if isinstance(obj, (str, int, float, bool, type(None))):
         if isinstance(obj, int) and abs(obj) >= 2**63:
-            # Silently clamp very large ints to max_float, to avoid
-            # OverflowError when casting to float.
+            # Silently clamp very large ints to max_float, to avoid OverflowError when
+            # casting to float.  (but avoid adding more constraints to symbolic values)
+            if avoid_realization:
+                return "<symbolic>"
             obj = clamp(-sys.float_info.max, obj, sys.float_info.max)
             return float(obj)
         return obj
+    if avoid_realization:
+        return "<symbolic>"
+    recur = partial(to_jsonable, avoid_realization=avoid_realization)
     if isinstance(obj, (list, tuple, set, frozenset)):
         if isinstance(obj, tuple) and hasattr(obj, "_asdict"):
-            return to_jsonable(obj._asdict())  # treat namedtuples as dicts
-        return [to_jsonable(x) for x in obj]
+            return recur(obj._asdict())  # treat namedtuples as dicts
+        return [recur(x) for x in obj]
     if isinstance(obj, dict):
         return {
-            k if isinstance(k, str) else pretty(k): to_jsonable(v)
-            for k, v in obj.items()
+            k if isinstance(k, str) else pretty(k): recur(v) for k, v in obj.items()
         }
 
     # Hey, might as well try calling a .to_json() method - it works for Pandas!
     # We try this before the below general-purpose handlers to give folks a
     # chance to control this behavior on their custom classes.
     try:
-        return to_jsonable(obj.to_json())  # type: ignore
+        return recur(obj.to_json())  # type: ignore
     except Exception:
         pass
 
@@ -194,11 +199,11 @@ def to_jsonable(obj: object) -> object:
         and dcs.is_dataclass(obj)
         and not isinstance(obj, type)
     ):
-        return to_jsonable(dataclass_asdict(obj))
+        return recur(dataclass_asdict(obj))
     if attr.has(type(obj)):
-        return to_jsonable(attr.asdict(obj, recurse=False))  # type: ignore
+        return recur(attr.asdict(obj, recurse=False))  # type: ignore
     if (pyd := sys.modules.get("pydantic")) and isinstance(obj, pyd.BaseModel):
-        return to_jsonable(obj.model_dump())
+        return recur(obj.model_dump())
 
     # If all else fails, we'll just pretty-print as a string.
     return pretty(obj)

hypothesis-python/src/hypothesis/vendor/pretty.py

@@ -447,6 +447,7 @@ def repr_call(
         force_split: Optional[bool] = None,
         arg_slices: Optional[dict[str, tuple[int, int]]] = None,
         leading_comment: Optional[str] = None,
+        avoid_realization: bool = False,
     ) -> None:
         """Helper function to represent a function call.
 
@@ -494,7 +495,10 @@ def repr_call(
                     self.breakable(" " if i else "")
                 if k:
                     self.text(f"{k}=")
-                self.pretty(v)
+                if avoid_realization:
+                    self.text("<symbolic>")
+                else:
+                    self.pretty(v)
                 if force_split or i + 1 < len(all_args):
                     self.text(",")
                 comment = None

hypothesis-python/tests/conjecture/test_alt_backend.py

@@ -444,7 +444,7 @@ def test_function(f):
 
         with capture_out() as out:
             test_function()
-        assert "Trying example: <symbolics>" in out.getvalue()
+        assert "Trying example: test_function(\n    f=<symbolic>,\n)" in out.getvalue()
 
 
 @pytest.mark.parametrize("verbosity", [Verbosity.verbose, Verbosity.debug])

hypothesis-python/tests/cover/test_searchstrategy.py

@@ -114,7 +114,8 @@ def inner(d):
 
 
 def test_jsonable():
-    assert isinstance(to_jsonable(object()), str)
+    assert to_jsonable(object(), avoid_realization=True) == "<symbolic>"
+    assert isinstance(to_jsonable(object(), avoid_realization=False), str)
 
 
 @dataclasses.dataclass()
@@ -130,36 +131,39 @@ class AttrsClass:
 def test_jsonable_defaultdict():
     obj = HasDefaultDict(defaultdict(list))
     obj.x["a"] = [42]
-    assert to_jsonable(obj) == {"x": {"a": [42]}}
+    assert to_jsonable(obj, avoid_realization=False) == {"x": {"a": [42]}}
 
 
 def test_jsonable_attrs():
     obj = AttrsClass(n=10)
-    assert to_jsonable(obj) == {"n": 10}
+    assert to_jsonable(obj, avoid_realization=False) == {"n": 10}
 
 
 def test_jsonable_namedtuple():
     Obj = namedtuple("Obj", ("x"))
     obj = Obj(10)
-    assert to_jsonable(obj) == {"x": 10}
+    assert to_jsonable(obj, avoid_realization=False) == {"x": 10}
 
 
 def test_jsonable_small_ints_are_ints():
     n = 2**62
-    assert isinstance(to_jsonable(n), int)
-    assert to_jsonable(n) == n
+    for avoid in (True, False):
+        assert isinstance(to_jsonable(n, avoid_realization=avoid), int)
+        assert to_jsonable(n, avoid_realization=avoid) == n
 
 
 def test_jsonable_large_ints_are_floats():
     n = 2**63
-    assert isinstance(to_jsonable(n), float)
-    assert to_jsonable(n) == float(n)
+    assert isinstance(to_jsonable(n, avoid_realization=False), float)
+    assert to_jsonable(n, avoid_realization=False) == float(n)
+    assert to_jsonable(n, avoid_realization=True) == "<symbolic>"
 
 
 def test_jsonable_very_large_ints():
     # previously caused OverflowError when casting to float.
     n = 2**1024
-    assert to_jsonable(n) == sys.float_info.max
+    assert to_jsonable(n, avoid_realization=False) == sys.float_info.max
+    assert to_jsonable(n, avoid_realization=True) == "<symbolic>"
 
 
 @dataclasses.dataclass()
@@ -172,4 +176,5 @@ def to_json(self):
 
 def test_jsonable_override():
     obj = HasCustomJsonFormat("expected")
-    assert to_jsonable(obj) == "surprise!"
+    assert to_jsonable(obj, avoid_realization=False) == "surprise!"
+    assert to_jsonable(obj, avoid_realization=True) == "<symbolic>"