redroot 0.2.0__tar.gz → 0.3.0__tar.gz

{redroot-0.2.0 → redroot-0.3.0}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-05
+
+### Added
+- Boolean tracing, opt-in with `Trace(bools=True)` (or `run(..., bools=True)`):
+  comparisons return `TracedBool` values that are data rather than guards, so
+  flags that are stored or computed with propagate exactly; a guard is
+  recorded only where a flag's truth value is used. Boolean inputs become
+  editable inputs. Instrumented code also routes `not`, `x is True/False`,
+  `isinstance(x, bool)` and `x in traced_str`, and passes real `bool`s to
+  external code.
+- `validation.check_fidelity()`: run a workflow plainly and traced and
+  compare their outputs, catching differences tracing itself introduces.
+- `redroot.unwrap_deep()` is public.
+
+### Fixed
+- `explain()` no longer doubles parentheses around operator expressions
+  passed to calls, e.g. `round(x * 1.1, 2)` instead of `round((x * 1.1), 2)`.
+
 ## [0.2.0] - 2026-10-02
 
 Re-evaluable traces: RedRoot now answers "what does every output become if

{redroot-0.2.0 → redroot-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redroot
-Version: 0.2.0
+Version: 0.3.0
 Summary: Value-level lineage for Python: trace where every output came from, and propagate input edits to every output without re-running
 Project-URL: Homepage, https://github.com/gagan-gaurav/redthread
 Project-URL: Documentation, https://github.com/gagan-gaurav/redthread#readme
@@ -283,6 +283,27 @@ report = check_perturbation(guarded, {"A": 1200, "B": 300}, {"ext:A": 1100}, inp
 assert report.consistent  # graph agrees with re-execution wherever it claimed to know
 ```
 
+### Booleans
+
+Python does not allow subclassing `bool`, so by default comparisons return plain `bool`s (recorded as guards) and boolean inputs are untracked. Pass `bools=True` to trace them too:
+
+```python
+def form(ext):
+    eligible = ext["income"] > 30000
+    return {"eligible": eligible, "credit": 500 * eligible + 100 * ext["married"]}
+
+
+trace, _ = rr.run(form, {"income": 25000, "married": True}, input_root="ext", bools=True)
+print(trace.explain("out:eligible"))  # ext:income > 30000
+
+result = trace.propagate({"ext:income": 40000})  # the comparison flips...
+print(result.exact, result.outputs["out:credit"].new)  # True 600
+```
+
+A comparison then returns a `TracedBool`, which is data: a flag that is stored, counted or multiplied propagates exactly when it changes. A guard is recorded only where its truth value is used (`if`, `while`, `and`/`or`), and boolean inputs such as checkboxes become editable inputs.
+
+A `TracedBool` is an `int` subclass that prints, formats, hashes and compares like `True`/`False`. In code you do not instrument, `isinstance(x, bool)` and `x is True` are false and `json.dumps` writes `1`/`0`. Instrumented code gets all three right: external calls receive real `bool`s. Use `redroot.validation.check_fidelity(workflow, inputs, bools=True)` to confirm that tracing leaves a workflow's outputs unchanged.
+
 ### Pydantic
 
 With `redroot[pydantic]`, traced types work as model fields. Traced values pass through validation with their lineage, plain values become inputs, and models serialize to plain values.
@@ -295,7 +316,7 @@ Overhead is about 0.7 µs per traced operation (0.9 µs for `Decimal`) and about
 
 ## Limitations
 
-- Only `int`, `float`, `Decimal` and `str` are traced. `bool` and `None` inputs are recorded as untracked: editing them requires re-execution.
+- `int`, `float`, `Decimal` and `str` are traced, and `bool` with `bools=True`. `None` inputs (and `bool` inputs otherwise) are recorded as untracked: editing them requires re-execution.
 - Without instrumentation, a few C-level operations lose lineage (see above). `redroot.validation` finds them. [docs/design.md](docs/design.md#what-remains-invisible) lists what remains invisible even with it.
 - Lineage does not cross threads unless the context is propagated (`contextvars.copy_context()`), nor processes, nor `pickle`.
 - `type(x) is float` is `False` for traced values (instrumented code is unaffected).

{redroot-0.2.0 → redroot-0.3.0}/README.md

@@ -236,6 +236,27 @@ report = check_perturbation(guarded, {"A": 1200, "B": 300}, {"ext:A": 1100}, inp
 assert report.consistent  # graph agrees with re-execution wherever it claimed to know
 ```
 
+### Booleans
+
+Python does not allow subclassing `bool`, so by default comparisons return plain `bool`s (recorded as guards) and boolean inputs are untracked. Pass `bools=True` to trace them too:
+
+```python
+def form(ext):
+    eligible = ext["income"] > 30000
+    return {"eligible": eligible, "credit": 500 * eligible + 100 * ext["married"]}
+
+
+trace, _ = rr.run(form, {"income": 25000, "married": True}, input_root="ext", bools=True)
+print(trace.explain("out:eligible"))  # ext:income > 30000
+
+result = trace.propagate({"ext:income": 40000})  # the comparison flips...
+print(result.exact, result.outputs["out:credit"].new)  # True 600
+```
+
+A comparison then returns a `TracedBool`, which is data: a flag that is stored, counted or multiplied propagates exactly when it changes. A guard is recorded only where its truth value is used (`if`, `while`, `and`/`or`), and boolean inputs such as checkboxes become editable inputs.
+
+A `TracedBool` is an `int` subclass that prints, formats, hashes and compares like `True`/`False`. In code you do not instrument, `isinstance(x, bool)` and `x is True` are false and `json.dumps` writes `1`/`0`. Instrumented code gets all three right: external calls receive real `bool`s. Use `redroot.validation.check_fidelity(workflow, inputs, bools=True)` to confirm that tracing leaves a workflow's outputs unchanged.
+
 ### Pydantic
 
 With `redroot[pydantic]`, traced types work as model fields. Traced values pass through validation with their lineage, plain values become inputs, and models serialize to plain values.
@@ -248,7 +269,7 @@ Overhead is about 0.7 µs per traced operation (0.9 µs for `Decimal`) and about
 
 ## Limitations
 
-- Only `int`, `float`, `Decimal` and `str` are traced. `bool` and `None` inputs are recorded as untracked: editing them requires re-execution.
+- `int`, `float`, `Decimal` and `str` are traced, and `bool` with `bools=True`. `None` inputs (and `bool` inputs otherwise) are recorded as untracked: editing them requires re-execution.
 - Without instrumentation, a few C-level operations lose lineage (see above). `redroot.validation` finds them. [docs/design.md](docs/design.md#what-remains-invisible) lists what remains invisible even with it.
 - Lineage does not cross threads unless the context is propagated (`contextvars.copy_context()`), nor processes, nor `pickle`.
 - `type(x) is float` is `False` for traced values (instrumented code is unaffected).

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/__init__.py

@@ -15,7 +15,7 @@ every output becomes when an input changes, without running it again::
 See the README for the full guide.
 """
 
-from redroot._core import Node, Traced, active_trace, node_of, unwrap
+from redroot._core import Node, Traced, active_trace, node_of, unwrap, unwrap_deep
 from redroot.functions import annotate, derive, traced, traced_llm
 from redroot.paths import apply_edits, format_key, parse_key
 from redroot.propagation import (
@@ -28,9 +28,9 @@ from redroot.propagation import (
     Verification,
 )
 from redroot.trace import Output, Trace, run, track
-from redroot.types import TracedDecimal, TracedFloat, TracedInt, TracedStr
+from redroot.types import TracedBool, TracedDecimal, TracedFloat, TracedInt, TracedStr
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 
 def is_traced(value: object) -> bool:
@@ -49,6 +49,7 @@ __all__ = [
     "Status",
     "Trace",
     "Traced",
+    "TracedBool",
     "TracedDecimal",
     "TracedFloat",
     "TracedInt",
@@ -68,4 +69,5 @@ __all__ = [
     "traced_llm",
     "track",
     "unwrap",
+    "unwrap_deep",
 ]

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/_core.py

@@ -349,7 +349,7 @@ def record_result(
     if isinstance(value, Traced) or kind is list or kind is dict or isinstance(value, tuple):
         value = unwrap_deep(value)  # e.g. a function returned one of its traced arguments
     factory = _WRAPPERS.get(type(value))
-    if factory is not None:
+    if factory is not None and (type(value) is not bool or trace._bools):
         return factory(
             value, add_node(trace, op, args, kwargs, value, OP, meta=meta, ctx=ctx, fn=fn)
         )
@@ -554,3 +554,16 @@ def observe_value(op: str, fn: Callable[..., Any], *operands: Any) -> Any:
         raise
     add_node(trace, op, tuple(refs), None, result, GUARD)
     return result
+
+
+def compare(op: str, fn: Callable[[Any, Any], Any], left: Any, right: Any) -> Any:
+    """Record a comparison of traced values.
+
+    In a trace that traces booleans the outcome is a traced boolean (data),
+    and a guard is recorded only where its truth value is used. Otherwise the
+    plain ``bool`` is returned and recorded as a guard right away.
+    """
+    trace = _active.get()
+    if trace is not None and not isinstance(trace, Observer) and trace._bools:
+        return binary(op, fn, left, right)
+    return observe_value(op, fn, left, right)

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/instrument.py

@@ -52,6 +52,7 @@ from redroot.ops import (
     STR_METHODS,
     fstring,
 )
+from redroot.types import TracedBool
 
 __all__ = ["RUNTIME_NAME", "compile_source", "exec_source", "instrument"]
 
@@ -253,18 +254,22 @@ def _opaque_call(func: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> An
     The guard cannot be re-evaluated, so any change to those inputs means
     re-execution: sound, if conservative.
     """
-    trace = _core.active_trace()
-    if trace is None or _is_transparent(func):
+    if _is_transparent(func):
         return func(*args, **kwargs)
+    # A traced boolean is an int: external code (json, pydantic...) gets the bool.
+    plain_args, plain_kwargs = _plain_bools(args), _plain_bools(kwargs)
+    trace = _core.active_trace()
+    if trace is None:
+        return func(*plain_args, **plain_kwargs)
     refs, _, linked = _core.encode(args, trace)
     kw_refs, _, kw_linked = _core.encode(kwargs, trace)
     if not (linked or kw_linked):
-        return func(*args, **kwargs)
+        return func(*plain_args, **plain_kwargs)
     name = getattr(func, "__qualname__", None) or type(func).__qualname__
     op = f"call:{getattr(func, '__module__', None) or ''}.{name}".replace(":.", ":")
     first_new_node = len(trace.nodes)
     try:
-        result = func(*args, **kwargs)
+        result = func(*plain_args, **plain_kwargs)
     except Exception as exc:
         _core.record_raise(trace, op, tuple(refs), kw_refs or None, exc, _core.NOT_REPLAYABLE)
         raise
@@ -305,6 +310,8 @@ def call(func: Any, /, *args: Any, **kwargs: Any) -> Any:
         return func(*args, **kwargs)
     if func is type and len(args) == 1 and not kwargs and isinstance(args[0], Traced):
         return args[0]._base  # what type() returns for the plain value
+    if func is isinstance and len(args) == 2 and isinstance(args[0], TracedBool):
+        return isinstance(args[0], args[1]) or isinstance(args[0]._rt_node.value, args[1])
     receiver = getattr(func, "__self__", None)
     method = _METHODS.get(type(receiver))
     if method is not None and func.__name__ in method[1]:
@@ -360,16 +367,49 @@ def ibinop(op: str, left: Any, right: Any) -> Any:
     return _INPLACE[op](left, right)
 
 
+_IDENTITY_OPS: dict[str, Callable[[Any, Any], Any]] = {
+    "is": operator.is_,
+    "is not": operator.is_not,
+}
+
+
 def compare(op: str, left: Any, right: Any) -> Any:
-    """``left <op> right`` for a single comparison, recorded as a guard."""
+    """``left <op> right`` for a single comparison of traced values."""
     if op in ("in", "not in"):
-        if isinstance(left, Traced) and not isinstance(right, Traced):
+        if isinstance(right, Traced):
+            # `in` forces its result to a plain bool; ask the container directly.
+            found = _core.compare("contains", operator.contains, right, left)
+            return not_(found) if op == "not in" else found
+        if isinstance(left, Traced):
             left = observe_value("observe", _identity, left)  # membership in a plain container
         result = left in right
         return not result if op == "not in" else result
+    fn = _IDENTITY_OPS.get(op) or COMPARISON_OPS[op][0]
     if isinstance(left, Traced) or isinstance(right, Traced):
-        return observe_value(op, COMPARISON_OPS[op][0], left, right)
-    return COMPARISON_OPS[op][0](left, right)
+        # Identity is checked on plain values: a traced True "is" True.
+        return _core.compare(op, fn, left, right)
+    return fn(left, right)
+
+
+def not_(value: Any) -> Any:
+    """``not value``: recorded for traced values (a traced boolean if traced)."""
+    if isinstance(value, Traced):
+        return _core.call("not", operator.not_, (value,))
+    return not value
+
+
+def _plain_bools(obj: Any) -> Any:
+    """Replace traced booleans by real ``bool`` values (deeply), for external code."""
+    if isinstance(obj, TracedBool):
+        return obj._rt_node.value
+    kind = type(obj)
+    if kind is list:
+        return [_plain_bools(item) for item in obj]
+    if kind is tuple:
+        return tuple(_plain_bools(item) for item in obj)
+    if kind is dict:
+        return {k: _plain_bools(v) for k, v in obj.items()}
+    return obj
 
 
 def _identity(value: Any) -> Any:
@@ -415,6 +455,7 @@ class _Runtime:
     getitem = staticmethod(getitem)
     key = staticmethod(key)
     fstring = staticmethod(fstring_)
+    not_ = staticmethod(not_)
     slice = slice
 
 
@@ -447,6 +488,8 @@ _COMPARE_NAMES: dict[type[ast.cmpop], str] = {
     ast.NotEq: "ne",
     ast.In: "in",
     ast.NotIn: "not in",
+    ast.Is: "is",
+    ast.IsNot: "is not",
 }
 # Calls that depend on the calling frame must not be wrapped.
 _FRAME_SENSITIVE = frozenset(
@@ -467,6 +510,10 @@ def _is_constant(node: ast.expr) -> bool:
     return isinstance(node, ast.Constant)
 
 
+def _is_bool_constant(node: ast.expr) -> bool:
+    return isinstance(node, ast.Constant) and type(node.value) is bool
+
+
 class _Instrumenter(ast.NodeTransformer):
     def __init__(self) -> None:
         self._temps = itertools.count()
@@ -500,6 +547,12 @@ class _Instrumenter(ast.NodeTransformer):
             return node
         return ast.copy_location(_rt_call("binop", ast.Constant(name), node.left, node.right), node)
 
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.expr:
+        self.generic_visit(node)
+        if isinstance(node.op, ast.Not) and not _is_constant(node.operand):
+            return ast.copy_location(_rt_call("not_", node.operand), node)
+        return node
+
     def visit_Compare(self, node: ast.Compare) -> ast.expr:
         self.generic_visit(node)
         if len(node.ops) != 1:
@@ -507,6 +560,10 @@ class _Instrumenter(ast.NodeTransformer):
         name = _COMPARE_NAMES.get(type(node.ops[0]))
         if name is None or (_is_constant(node.left) and _is_constant(node.comparators[0])):
             return node
+        if name in ("is", "is not") and not (
+            _is_bool_constant(node.left) or _is_bool_constant(node.comparators[0])
+        ):
+            return node  # only `x is True/False` can differ for traced values
         call = _rt_call("compare", ast.Constant(name), node.left, node.comparators[0])
         return ast.copy_location(call, node)
 

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/ops.py

@@ -317,6 +317,9 @@ def _register_builtins() -> None:
     for name, fn in FUNCTION_OPS.items():
         register_op(name, fn)
     register_op("decimal", Decimal, symbol="Decimal")
+    register_op("is", operator.is_, symbol="is", style="infix")
+    register_op("is not", operator.is_not, symbol="is not", style="infix")
+    register_op("not", operator.not_, symbol="not ", style="prefix")
     register_op("getitem", operator.getitem, style="getitem")
     register_op("contains", operator.contains, symbol="in", style="contains")
     for prefix, owner, methods in (

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/serialization.py

@@ -186,6 +186,7 @@ def trace_to_dict(trace: Trace) -> dict[str, Any]:
         "version": VERSION,
         "id": trace.id,
         "name": trace.name,
+        "bools": trace.bools,
         "decimal_context": _context_to_dict(trace.decimal_context),
         "decimal_contexts": [_context_to_dict(ctx) for ctx in trace.decimal_contexts],
         "nodes": nodes,
@@ -208,7 +209,7 @@ def trace_from_dict(data: Mapping[str, Any]) -> Trace:
     if data.get("version") != VERSION:
         raise ValueError(f"unsupported trace version {data.get('version')!r}; expected {VERSION}")
 
-    trace = Trace(data.get("name"), id=data["id"])
+    trace = Trace(data.get("name"), id=data["id"], bools=data.get("bools", False))
     trace.decimal_context = _context_from_dict(data["decimal_context"])
     trace._contexts = [_context_from_dict(ctx) for ctx in data.get("decimal_contexts", [])]
     nodes: list[Node] = trace._nodes

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/trace.py

@@ -71,11 +71,25 @@ class Trace:
         trace.propagate({"ext:a": 900})         # what changes if an input does
 
     A trace is not thread-safe: record into it from one thread at a time.
+
+    Args:
+        name: A label for the trace.
+        id: Unique id; a random one by default.
+        bools: Trace booleans too. Boolean inputs become editable inputs, and
+            comparisons return traced booleans (:class:`~redroot.TracedBool`)
+            that are only guarded where their truth value is used, so flags
+            that are stored or computed with propagate exactly. Traced
+            booleans are ``int`` subclasses (Python forbids subclassing
+            ``bool``): best used with :mod:`redroot.instrument`, and checked
+            with :func:`redroot.validation.check_fidelity`.
     """
 
-    def __init__(self, name: str | None = None, *, id: str | None = None) -> None:
+    def __init__(
+        self, name: str | None = None, *, id: str | None = None, bools: bool = False
+    ) -> None:
         self.id = id or uuid.uuid4().hex
         self.name = name
+        self._bools = bools
         self.decimal_context: decimal.Context = decimal.getcontext().copy()
         """Decimal context used for re-evaluation; captured when recording ends."""
         self._nodes: list[Node] = []
@@ -125,6 +139,11 @@ class Trace:
         """Every node, in recording (topological) order. Do not mutate."""
         return self._nodes
 
+    @property
+    def bools(self) -> bool:
+        """Whether this trace traces booleans (see the ``bools`` argument)."""
+        return self._bools
+
     @property
     def decimal_contexts(self) -> Sequence[decimal.Context]:
         """The ``decimal`` contexts that ``Decimal`` nodes were computed under."""
@@ -176,23 +195,30 @@ class Trace:
         """Record ``value`` as an input and return its traced form.
 
         Args:
-            value: An ``int``, ``float``, ``Decimal`` or ``str``.
+            value: An ``int``, ``float``, ``Decimal`` or ``str`` (or a
+                ``bool`` if the trace traces booleans).
             key: Semantic id used to refer to the input, e.g. for edits.
             meta: Free-form metadata stored on the node.
         """
         plain = unwrap(value)
-        factory = _WRAPPERS.get(type(plain))
+        factory = self._factory(plain)
         if factory is None:
             raise TypeError(f"cannot trace a value of type {type(plain).__name__}")
         return factory(plain, self._add_leaf(plain, key, meta))
 
+    def _factory(self, plain: Any) -> Callable[[Any, Node], Any] | None:
+        if type(plain) is bool and not self._bools:
+            return None
+        return _WRAPPERS.get(type(plain))
+
     def track(self, data: T, root: str = "in") -> T:
         """Return a copy of ``data`` whose scalar values are traced inputs.
 
         Dicts, lists and tuples are copied; every ``int``, ``float``,
         ``Decimal`` and ``str`` inside becomes an input keyed by its path,
-        e.g. ``"ext:bank.line_items[3].amount"``. Other values (``None``,
-        ``bool``, objects) are kept as-is and listed in
+        e.g. ``"ext:bank.line_items[3].amount"``, as does every ``bool`` if
+        the trace traces booleans. Other values (``None``, objects, and
+        ``bool`` otherwise) are kept as-is and listed in
         :attr:`untracked_inputs`: editing them requires re-execution.
         """
         return self._track(data, format_key(root))  # type: ignore[no-any-return]
@@ -206,7 +232,7 @@ class Trace:
         if kind is tuple:
             return tuple(self._track(v, child_key(key, i)) for i, v in enumerate(value))
         plain = unwrap(value)
-        factory = _WRAPPERS.get(type(plain))
+        factory = self._factory(plain)
         if factory is not None:
             return factory(plain, self._add_leaf(plain, key, None))
         self._check_new_key(key)
@@ -380,36 +406,42 @@ def _is_pydantic_model(value: Any) -> bool:
 
 
 def _render(node: Node, depth: int, top: bool = False) -> str:
+    """Render ``node`` as an expression; ``top`` omits the outer parentheses."""
     if node.kind == LEAF:
         return node.key if node.key is not None else repr(node.value)
     if depth <= 0:
         return f"#{node.id}"
-    args = [_render_arg(arg, depth - 1) for arg in node.args]
-    args += [f"{k}={_render_arg(v, depth - 1)}" for k, v in (node.kwargs or {}).items()]
     if node.op == "fstring":
         return _render_fstring(node.args, depth - 1)
-    if node.op == "getslice" and len(args) == 4:
-        start, stop, step = (
-            "" if a is None else t for a, t in zip(node.args[1:], args[1:], strict=True)
-        )
-        return f"{args[0]}[{start}:{stop}{':' + step if step else ''}]"
     spec = get_op(node.op)
     style = spec.style if spec is not None else "call"
     symbol = spec.symbol if spec is not None else None
-    text: str
-    if style == "infix" and len(args) == 2:
-        text = f"{args[0]} {symbol} {args[1]}"
-    elif style == "contains" and len(args) == 2:
-        text = f"{args[1]} in {args[0]}"
-    elif style == "prefix" and len(args) == 1:
-        return f"{symbol}{args[0]}"
-    elif style == "getitem" and len(args) == 2:
-        return f"{args[0]}[{args[1]}]"
-    elif style == "method" and args:
-        return f"{args[0]}.{symbol}({', '.join(args[1:])})"
-    else:
-        return f"{symbol or node.op}({', '.join(args)})"
-    return text if top else f"({text})"
+    sub = depth - 1
+
+    def operand(arg: Any) -> str:  # inside an operator expression: parenthesize
+        return _render_arg(arg, sub, top=False)
+
+    def argument(arg: Any) -> str:  # between commas or brackets: no parentheses needed
+        return _render_arg(arg, sub, top=True)
+
+    keywords = [f"{k}={argument(v)}" for k, v in (node.kwargs or {}).items()]
+    first, rest = (node.args[0], node.args[1:]) if node.args else (None, ())
+    if node.op == "getslice" and len(node.args) == 4:
+        start, stop, step = ("" if a is None else argument(a) for a in rest)
+        return f"{operand(first)}[{start}:{stop}{':' + step if step else ''}]"
+    if style == "infix" and len(node.args) == 2 and not keywords:
+        text = f"{operand(first)} {symbol} {operand(rest[0])}"
+        return text if top else f"({text})"
+    if style == "contains" and len(node.args) == 2:
+        text = f"{operand(rest[0])} in {operand(first)}"
+        return text if top else f"({text})"
+    if style == "prefix" and len(node.args) == 1:
+        return f"{symbol}{operand(first)}"
+    if style == "getitem" and len(node.args) == 2:
+        return f"{operand(first)}[{argument(rest[0])}]"
+    if style == "method" and node.args:
+        return f"{operand(first)}.{symbol}({', '.join([*map(argument, rest), *keywords])})"
+    return f"{symbol or node.op}({', '.join([*map(argument, node.args), *keywords])})"
 
 
 def _render_fstring(parts: tuple[Any, ...], depth: int) -> str:
@@ -420,22 +452,26 @@ def _render_fstring(parts: tuple[Any, ...], depth: int) -> str:
             continue
         value, conversion, spec = part
         conv = f"!{conversion}" if conversion else ""
-        spec_text = f":{_render_arg(spec, depth) if type(spec) is Node else spec}" if spec else ""
-        out.append(f"{{{_render_arg(value, depth)}{conv}{spec_text}}}")
+        spec_text = (
+            f":{_render_arg(spec, depth, True) if type(spec) is Node else spec}" if spec else ""
+        )
+        out.append(f"{{{_render_arg(value, depth, True)}{conv}{spec_text}}}")
     return 'f"' + "".join(out).replace('"', '\\"') + '"'
 
 
-def _render_arg(arg: Any, depth: int) -> str:
+def _render_arg(arg: Any, depth: int, top: bool = False) -> str:
     kind = type(arg)
     if kind is Node:
-        return _render(arg, depth)
+        return _render(arg, depth, top)
     if kind is list:
-        return "[" + ", ".join(_render_arg(a, depth) for a in arg) + "]"
+        return "[" + ", ".join(_render_arg(a, depth, True) for a in arg) + "]"
     if kind is tuple:
-        inner = ", ".join(_render_arg(a, depth) for a in arg)
+        inner = ", ".join(_render_arg(a, depth, True) for a in arg)
         return f"({inner},)" if len(arg) == 1 else f"({inner})"
     if kind is dict:
-        return "{" + ", ".join(f"{k!r}: {_render_arg(v, depth)}" for k, v in arg.items()) + "}"
+        return (
+            "{" + ", ".join(f"{k!r}: {_render_arg(v, depth, True)}" for k, v in arg.items()) + "}"
+        )
     return repr(arg)
 
 
@@ -459,16 +495,20 @@ def run(
     input_root: str = "in",
     output_root: str = "out",
     name: str | None = None,
+    bools: bool = False,
 ) -> tuple[Trace, Any]:
     """Run ``workflow(inputs)`` under a new trace.
 
     Inputs are traced under ``input_root`` and every value in the returned
-    result is collected as an output under ``output_root``.
+    result is collected as an output under ``output_root``. ``bools`` is
+    passed to :class:`Trace`.
 
     Returns:
-        The trace and the workflow's result.
+        The trace and the workflow's result (which holds traced values; use
+        :meth:`Trace.output_values` or :func:`redroot.unwrap_deep` for plain
+        ones).
     """
-    with Trace(name) as trace:
+    with Trace(name, bools=bools) as trace:
         result = workflow(trace.track(inputs, input_root))
         trace.collect(result, output_root)
     return trace, result

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/types.py

@@ -38,6 +38,7 @@ from redroot._core import (
     add_node,
     binary,
     call,
+    compare,
     decimal_context_id,
     observe_value,
     record_raise,
@@ -60,7 +61,7 @@ if TYPE_CHECKING:
     from pydantic import GetCoreSchemaHandler
     from pydantic_core import CoreSchema
 
-__all__ = ["TracedDecimal", "TracedFloat", "TracedInt", "TracedStr"]
+__all__ = ["TracedBool", "TracedDecimal", "TracedFloat", "TracedInt", "TracedStr"]
 
 
 def _construct(
@@ -70,6 +71,7 @@ def _construct(
     value: Any,
     key: str | None,
     meta: dict[str, Any] | None,
+    alloc: type[Any] | None = None,
 ) -> Any:
     """Shared constructor logic.
 
@@ -95,7 +97,7 @@ def _construct(
         node = add_node(trace, cast_op, (source,), None, plain, OP, meta=meta, ctx=ctx)
     else:
         node = trace._add_leaf(plain, key, meta)
-    obj: Any = base.__new__(cls, plain)
+    obj: Any = (alloc or base).__new__(cls, plain)
     obj._rt_node = node
     return obj
 
@@ -139,6 +141,7 @@ class _TracedScalar(Traced):
             float: core_schema.float_schema,
             Decimal: core_schema.decimal_schema,
             str: core_schema.str_schema,
+            bool: core_schema.bool_schema,
         }
         from_plain = core_schema.no_info_after_validator_function(cls, schemas[cls._base]())
         return core_schema.json_or_python_schema(
@@ -190,6 +193,27 @@ class TracedDecimal(_TracedScalar, Decimal):
         return _construct(cls, Decimal, "decimal", value, key, meta)  # type: ignore[no-any-return]
 
 
+class TracedBool(_TracedScalar, int):
+    """A boolean that records how it was computed.
+
+    Python does not allow subclassing ``bool``, so this is an ``int`` (as
+    ``bool`` itself is) that prints, formats, hashes and compares like
+    ``True``/``False``. Unlike a real ``bool``, ``isinstance(x, bool)`` and
+    ``x is True`` are false, and ``json`` writes it as ``1``/``0``; code run
+    through :mod:`redroot.instrument` gets those right. Traced booleans are
+    only produced by traces created with ``bools=True``.
+    """
+
+    # int is variable-size: instances keep the node in __dict__.
+    _base = bool
+
+    def __new__(
+        cls, value: Any = False, *, key: str | None = None, meta: dict[str, Any] | None = None
+    ) -> TracedBool:
+        """Convert ``value`` like ``bool(value)`` (see the module docstring)."""
+        return _construct(cls, bool, "bool", value, key, meta, alloc=int)  # type: ignore[no-any-return]
+
+
 class TracedStr(_TracedScalar, str):
     """A ``str`` that records how it was computed."""
 
@@ -237,10 +261,10 @@ def _rpow(self: Any, other: Any, modulo: Any = None) -> Any:
 def _comparison(op: str) -> Callable[..., Any]:
     fn = COMPARISON_OPS[op][0]
 
-    def compare(self: Any, other: Any) -> Any:
-        return observe_value(op, fn, self, other)
+    def method(self: Any, other: Any) -> Any:
+        return compare(op, fn, self, other)
 
-    return compare
+    return method
 
 
 def _guard(op: str, fn: Callable[[Any], Any]) -> Callable[..., Any]:
@@ -318,15 +342,16 @@ def _install_number(
 
 _ARITHMETIC = ("add", "sub", "mul", "truediv", "floordiv", "mod")
 
-_install_number(
-    TracedInt, (*_ARITHMETIC, "lshift", "rshift", "and", "or", "xor"), ("neg", "pos", "invert")
-)
-_install(TracedInt, "__index__", _guard("index", operator.index))
+_INTEGER = (*_ARITHMETIC, "lshift", "rshift", "and", "or", "xor")
+for _integer_cls in (TracedInt, TracedBool):
+    _install_number(_integer_cls, _INTEGER, ("neg", "pos", "invert"))
+    _install(_integer_cls, "__index__", _guard("index", operator.index))
 _install_number(TracedFloat, _ARITHMETIC, ("neg", "pos"))
 _install_number(TracedDecimal, _ARITHMETIC, ("neg", "pos"))
 
 for _prefix, _cls, _owner, _names in (
     ("int", TracedInt, int, INT_METHODS),
+    ("int", TracedBool, int, INT_METHODS),
     ("float", TracedFloat, float, FLOAT_METHODS),
     ("decimal", TracedDecimal, Decimal, DECIMAL_METHODS),
     ("str", TracedStr, str, STR_METHODS),
@@ -369,7 +394,7 @@ _install(TracedStr, "__getitem__", _str_getitem)
 _install(
     TracedStr,
     "__contains__",
-    lambda self, item: observe_value("contains", operator.contains, self, item),
+    lambda self, item: compare("contains", operator.contains, self, item),
 )
 _install(TracedStr, "__len__", _guard("len", len))
 _install(TracedStr, "__bool__", _guard("bool", bool))
@@ -383,3 +408,5 @@ register_wrapper(int, _factory(TracedInt, int))
 register_wrapper(float, _factory(TracedFloat, float))
 register_wrapper(Decimal, _factory(TracedDecimal, Decimal))
 register_wrapper(str, _factory(TracedStr, str))
+# Used only by traces created with bools=True (see record_result).
+register_wrapper(bool, _factory(TracedBool, int))

{redroot-0.2.0 → redroot-0.3.0}/src/redroot/validation.py

@@ -8,10 +8,14 @@ Run these on real recorded workflows before relying on propagation:
   operands reproduces the recorded value exactly.
 * :func:`check_perturbation` - after an edit, propagated outputs agree with a
   real re-execution wherever propagation claimed to know the answer.
+* :func:`check_fidelity` - running under tracing produces exactly the
+  outputs the plain code produces. (Perturbation checks compare traced runs
+  with traced runs, so they cannot see a difference tracing itself makes.)
 """
 
 from __future__ import annotations
 
+import copy
 import decimal
 from collections import deque
 from collections.abc import Callable, Mapping
@@ -25,9 +29,12 @@ from redroot.trace import Trace, run
 
 __all__ = [
     "Coverage",
+    "FidelityMismatch",
+    "FidelityReport",
     "IdentityMismatch",
     "IdentityReport",
     "PerturbationReport",
+    "check_fidelity",
     "check_identity",
     "check_perturbation",
     "coverage",
@@ -205,6 +212,7 @@ def check_perturbation(
     *,
     input_root: str = "in",
     output_root: str = "out",
+    bools: bool = False,
 ) -> PerturbationReport:
     """Edit inputs, then compare graph propagation with a real re-execution.
 
@@ -213,9 +221,66 @@ def check_perturbation(
     ``UNCHANGED`` or ``UNLINKED`` must match the re-execution; ``STALE``
     outputs are expected to need it.
     """
-    trace, _ = run(workflow, inputs, input_root=input_root, output_root=output_root)
+    trace, _ = run(workflow, inputs, input_root=input_root, output_root=output_root, bools=bools)
     propagation = trace.propagate(edits)
     edited = apply_edits(inputs, edits, root=input_root)
-    retrace, _ = run(workflow, edited, input_root=input_root, output_root=output_root)
+    retrace, _ = run(workflow, edited, input_root=input_root, output_root=output_root, bools=bools)
     verification = propagation.verify(retrace.output_values())
     return PerturbationReport(trace, propagation, retrace, verification)
+
+
+@dataclass(frozen=True, slots=True)
+class FidelityMismatch:
+    """An output whose value differs between plain and traced execution."""
+
+    key: str
+    plain: Any
+    traced: Any
+
+
+@dataclass(frozen=True, slots=True)
+class FidelityReport:
+    """Result of :func:`check_fidelity`."""
+
+    mismatches: tuple[FidelityMismatch, ...]
+    missing: tuple[str, ...] = ()
+    """Outputs the plain run produced but the traced run did not."""
+    unexpected: tuple[str, ...] = ()
+    """Outputs the traced run produced but the plain run did not."""
+
+    @property
+    def ok(self) -> bool:
+        """Whether tracing left every output exactly as the plain code computes it."""
+        return not (self.mismatches or self.missing or self.unexpected)
+
+
+def check_fidelity(
+    workflow: Callable[[Any], Any],
+    inputs: Any,
+    *,
+    input_root: str = "in",
+    output_root: str = "out",
+    bools: bool = False,
+) -> FidelityReport:
+    """Run ``workflow`` plainly and under tracing, and compare their outputs.
+
+    Tracing must not change what code computes. This catches the places where
+    it does, e.g. ``json.dumps`` writing a traced boolean as ``1`` in code that
+    is not instrumented, or ``sum()`` adding floats without CPython's
+    compensated summation.
+    """
+    plain_result = workflow(copy.deepcopy(inputs))
+    plain = Trace()
+    plain.collect(plain_result, output_root)
+    expected = plain.output_values()
+    trace, _ = run(workflow, inputs, input_root=input_root, output_root=output_root, bools=bools)
+    actual = trace.output_values()
+    return FidelityReport(
+        mismatches=tuple(
+            FidelityMismatch(key, expected[key], actual[key])
+            for key in expected
+            if key in actual and not same_value(expected[key], actual[key])
+        ),
+        missing=tuple(key for key in expected if key not in actual),
+        unexpected=tuple(key for key in actual if key not in expected),
+    )

redroot-0.3.0/tests/test_bools.py

@@ -0,0 +1,271 @@
+"""Boolean tracing (``Trace(bools=True)``)."""
+
+from __future__ import annotations
+
+import json
+import operator
+import sys
+from typing import Any
+
+import pytest
+
+import redroot as rr
+from redroot import ReasonKind, Status, Trace, TracedBool, TracedInt, node_of, unwrap
+from redroot._core import same_value
+from redroot.instrument import exec_source
+from redroot.validation import check_fidelity, check_perturbation
+
+from .helpers import assert_replays
+
+
+def test_off_by_default() -> None:
+    with Trace() as trace:
+        a = trace.leaf(5, "in:a")
+        result = a > 3
+        tracked = trace.track({"flag": True}, root="ext")
+    assert type(result) is bool
+    assert tracked["flag"] is True
+    assert dict(trace.untracked_inputs) == {"ext:flag": True}
+    with pytest.raises(TypeError):
+        trace.leaf(True)
+
+
+# Traced booleans behave like bool wherever an int subclass can.
+@pytest.mark.parametrize(
+    "fn",
+    [
+        repr,
+        str,
+        lambda b: format(b, ""),
+        lambda b: f"{b}!",
+        lambda b: b + 1,
+        lambda b: b * 10,
+        lambda b: b & True,
+        lambda b: b | False,
+        lambda b: b ^ True,
+        lambda b: -b,
+        lambda b: b == 1,
+        lambda b: b == True,  # noqa: E712 - comparing with True is the point
+        lambda b: hash(b) == hash(True),
+        lambda b: {True: "yes"}.get(b),
+        lambda b: sum([b, b, True]),
+        lambda b: int(b),
+        lambda b: bool(b),
+        lambda b: "%d/%s" % (b, b),  # noqa: UP031 - testing % itself
+    ],
+)
+def test_traced_bool_matches_bool(fn: Any) -> None:
+    expected = fn(True)
+    with Trace(bools=True) as trace:
+        result = fn(trace.leaf(True, "in:b"))
+    assert same_value(unwrap(result), expected), (result, expected)
+    assert_replays(trace)
+
+
+def test_known_differences_from_bool() -> None:
+    with Trace(bools=True) as trace:
+        b = trace.leaf(True, "in:b")
+    assert isinstance(b, int)
+    assert not isinstance(b, bool)
+    assert b is not True
+    assert json.dumps(b) == "1"
+
+
+def test_comparisons_return_traced_booleans_guarded_only_when_used() -> None:
+    with Trace(bools=True) as trace:
+        income = trace.leaf(25000, "ext:income")
+        eligible = income > 30000
+        assert type(eligible) is TracedBool
+        assert trace.guards == []  # stored, not branched on
+        if eligible:
+            pass
+    (guard,) = trace.guards
+    assert trace.explain(guard) == "bool(ext:income > 30000)"  # no doubled parentheses
+
+
+def test_flag_outputs_propagate_exactly() -> None:
+    def form(ext: dict[str, Any]) -> dict[str, Any]:
+        eligible = ext["income"] > 30000
+        return {"eligible": eligible, "credit": 500 * eligible + 100 * ext["married"]}
+
+    trace, _ = rr.run(form, {"income": 25000, "married": True}, input_root="ext", bools=True)
+    assert trace.explain("out:credit") == "(500 * (ext:income > 30000)) + (100 * ext:married)"
+    result = trace.propagate({"ext:income": 40000})
+    assert result.exact
+    assert {k: (c.status, c.new) for k, c in result.outputs.items()} == {
+        "out:eligible": (Status.UPDATED, True),
+        "out:credit": (Status.UPDATED, 600),
+    }
+    married = trace.propagate({"ext:married": False})
+    assert married.exact
+    assert married.outputs["out:credit"].new == 0
+
+
+def test_branching_on_a_boolean_input_is_guarded() -> None:
+    trace, _ = rr.run(
+        lambda e: {"credit": 500 if e["married"] else 0},
+        {"married": True},
+        input_root="ext",
+        bools=True,
+    )
+    result = trace.propagate({"ext:married": False})
+    assert [r.kind for r in result.reasons] == [ReasonKind.GUARD_FLIPPED]
+    assert result.reasons[0].message == "bool(ext:married) was True, now False"
+
+
+def test_string_predicates_and_membership_are_traced_booleans() -> None:
+    with Trace(bools=True) as trace:
+        s = trace.leaf("INV-2024", "in:s")
+        is_invoice = s.startswith("INV")
+        has_year = "2024" in s
+    assert type(is_invoice) is TracedBool
+    assert trace.propagate({"in:s": "REC-2024"}).value(is_invoice) is False
+    # Python's `in` always converts the result to a plain bool, so it is a
+    # guard: changing the outcome requires re-execution...
+    assert type(has_year) is bool
+    assert not trace.propagate({"in:s": "INV-2023"}).exact
+    # ...but instrumented code asks the container directly.
+    contains = exec_source("def f(s): return '2024' in s, '2024' not in s")["f"]
+    with Trace(bools=True) as trace:
+        found, missing = contains(trace.leaf("INV-2024", "in:s"))
+    assert (type(found), type(missing)) == (TracedBool, TracedBool)
+    assert trace.explain(missing) == "not ('2024' in in:s)"
+    assert trace.propagate({"in:s": "REC-2023"}).value(found) is False
+
+
+def test_traced_bool_constructor_and_cast() -> None:
+    with Trace(bools=True) as trace:
+        n = trace.leaf(0, "in:n")
+        flag = TracedBool(n)
+        named = TracedBool(True, key="in:named")
+    assert unwrap(flag) is False
+    assert trace.explain(flag) == "bool(in:n)"
+    assert trace.inputs["in:named"] is node_of(named)
+    assert trace.propagate({"in:n": 3}).value(flag) is True
+
+
+def test_outputs_are_plain_bools() -> None:
+    trace, result = rr.run(lambda e: {"ok": e["x"] > 1}, {"x": 5}, bools=True)
+    assert type(result["ok"]) is TracedBool
+    assert trace.output_values() == {"out:ok": True}
+    assert rr.unwrap_deep(result) == {"ok": True}
+    assert type(rr.unwrap_deep(result)["ok"]) is bool
+
+
+def test_serialization_keeps_the_option_and_boolean_inputs() -> None:
+    trace, _ = rr.run(
+        lambda e: {"x": e["a"] * e["flag"]}, {"a": 3, "flag": True}, input_root="ext", bools=True
+    )
+    restored = Trace.from_json(trace.to_json())
+    assert restored.bools
+    assert restored.propagate({"ext:flag": False}).outputs["out:x"].new == 0
+
+
+def test_pydantic_field() -> None:
+    pydantic = pytest.importorskip("pydantic")
+
+    class Form(pydantic.BaseModel):  # type: ignore[name-defined, misc]
+        married: TracedBool
+
+    with Trace(bools=True) as trace:
+        flag = trace.leaf(True, "in:married")
+        form = Form(married=flag)
+        plain = Form(married=False)
+    assert form.married is flag
+    assert type(plain.married) is TracedBool
+    assert form.model_dump() == {"married": True}
+    assert form.model_dump_json() == '{"married":true}'
+
+
+def test_bools_do_not_leak_into_other_types() -> None:
+    with Trace(bools=True) as trace:
+        a = trace.leaf(5, "in:a")
+        total = a + (a > 3)
+    assert type(total) is TracedInt
+    assert unwrap(total) == 6
+
+
+# --- instrumentation repairs the differences ---------------------------
+
+SOURCE = """
+import json
+def main(ext):
+    ok = ext["income"] > 30000
+    return {
+        "json": json.dumps({"ok": ok, "married": ext["married"]}),
+        "is_false": ok is False,
+        "is_true": ext["married"] is True,
+        "isinstance": isinstance(ok, bool),
+        "type": type(ok) is bool,
+        "not": not ok,
+    }
+"""
+INPUTS = {"income": 25000, "married": True}
+
+
+def test_instrumented_code_sees_real_booleans() -> None:
+    main = exec_source(SOURCE)["main"]
+    trace, _ = rr.run(main, INPUTS, input_root="ext", bools=True)
+    assert trace.output_values() == {
+        "out:json": '{"ok": false, "married": true}',
+        "out:is_false": True,
+        "out:is_true": True,
+        "out:isinstance": True,
+        "out:type": True,
+        "out:not": True,
+    }
+    assert trace.explain("out:not") == "not (ext:income > 30000)"
+    assert trace.explain("out:is_false") == "(ext:income > 30000) is False"
+
+
+def test_check_fidelity_finds_differences_only_without_instrumentation() -> None:
+    namespace: dict[str, Any] = {}
+    exec(SOURCE, namespace)  # noqa: S102
+    report = check_fidelity(namespace["main"], INPUTS, input_root="ext", bools=True)
+    assert {m.key for m in report.mismatches} == {
+        "out:json",
+        "out:is_false",
+        "out:is_true",
+        "out:isinstance",
+        "out:type",
+    }
+    assert check_fidelity(namespace["main"], INPUTS, input_root="ext").ok  # bools off
+    assert check_fidelity(exec_source(SOURCE)["main"], INPUTS, input_root="ext", bools=True).ok
+
+
+@pytest.mark.skipif(sys.version_info < (3, 12), reason="compensated float sum() is new in 3.12")
+def test_check_fidelity_finds_float_summation_differences() -> None:
+    def workflow(d: dict[str, Any]) -> dict[str, Any]:
+        return {"total": sum(d["xs"])}
+
+    report = check_fidelity(workflow, {"xs": [0.1] * 10})
+    assert [(m.key, m.plain) for m in report.mismatches] == [("out:total", 1.0)]
+    assert check_fidelity(
+        exec_source("def f(d): return {'total': sum(d['xs'])}")["f"], {"xs": [0.1] * 10}
+    ).ok
+
+
+@pytest.mark.parametrize(
+    "edit", [{"ext:income": 40000}, {"ext:income": 26000}, {"ext:married": False}]
+)
+def test_instrumented_boolean_workflow_is_consistent(edit: dict[str, Any]) -> None:
+    source = """
+def main(ext):
+    eligible = ext["income"] > 30000 and not ext["married"]
+    credit = 500 * eligible
+    if ext["income"] < 1000:
+        credit = 0
+    return {"eligible": eligible, "credit": credit}
+"""
+    report = check_perturbation(
+        exec_source(source)["main"], INPUTS, edit, input_root="ext", bools=True
+    )
+    assert report.consistent, report.verification
+
+
+def test_comparison_ops_are_registered_for_identity() -> None:
+    from redroot.ops import get_op
+
+    assert get_op("is") is not None
+    assert get_op("is").fn is operator.is_  # type: ignore[union-attr]
+    assert get_op("not").fn is operator.not_  # type: ignore[union-attr]

{redroot-0.2.0 → redroot-0.3.0}/tests/test_instrument.py

@@ -253,6 +253,7 @@ def test_exec_source_uses_the_given_namespace() -> None:
 
 PROGRAM_OPS = ["+", "-", "*", "/", "%"]
 values = st.one_of(
+    st.booleans(),
     st.integers(-20, 20),
     st.floats(-100, 100, allow_nan=False).filter(lambda f: f == 0 or abs(f) > 1e-3),
     st.decimals(-100, 100, places=2, allow_nan=False, allow_infinity=False),
@@ -275,10 +276,15 @@ def programs(draw: st.DrawFn) -> tuple[str, list[Any]]:
                 st.builds(lambda i: f"v[{i}]", st.integers(0, len(inputs) - 1)), values.map(repr)
             )
         )
-        guard = draw(st.booleans())
+        shape = draw(st.sampled_from(["plain", "guard", "flag", "not"]))
         expr = f"({left} {op} {right})"
-        if guard:
+        if shape == "guard":
             expr = f"({expr} if {left} < {right} else {right})"
+        elif shape == "flag":
+            expr = f"({expr} * ({left} > {right}))"  # a comparison used as data
+        elif shape == "not":
+            ref = f"v[{draw(st.integers(0, len(inputs) - 1))}]"
+            expr = f"({expr} + (not ({ref} is True)))"
         lines.append(f"    v.append({expr})")
     lines.append("    return v[len(xs):]")
     return "from decimal import Decimal\n" + "\n".join(lines), inputs
@@ -295,8 +301,9 @@ def test_instrumented_propagation_agrees_with_reexecution(
     def workflow(d: dict[str, Any]) -> dict[str, Any]:
         return {"v": f(d["xs"])}
 
+    bools = data.draw(st.booleans())
     try:
-        trace, _ = run(workflow, {"xs": inputs})
+        trace, _ = run(workflow, {"xs": inputs}, bools=bools)
     except (ArithmeticError, TypeError):
         return
     index = data.draw(st.integers(0, len(inputs) - 1))
@@ -305,7 +312,7 @@ def test_instrumented_propagation_agrees_with_reexecution(
     edited = list(inputs)
     edited[index] = new_value
     try:
-        retrace, _ = run(workflow, {"xs": edited})
+        retrace, _ = run(workflow, {"xs": edited}, bools=bools)
     except (ArithmeticError, TypeError):
         assert not result.exact
         return

{redroot-0.2.0 → redroot-0.3.0}/tests/test_properties.py

@@ -28,7 +28,12 @@ decimals = st.decimals(
     min_value=-1000, max_value=1000, places=2, allow_nan=False, allow_infinity=False
 )
 numbers = st.one_of(ints, floats, decimals)
-STRATEGY_FOR: dict[type, st.SearchStrategy[Any]] = {int: ints, float: floats, Decimal: decimals}
+STRATEGY_FOR: dict[type, st.SearchStrategy[Any]] = {
+    int: ints,
+    float: floats,
+    Decimal: decimals,
+    bool: st.booleans(),
+}
 
 BINARY: dict[str, Callable[[Any, Any], Any]] = {
     "+": operator.add,
@@ -89,25 +94,31 @@ STEP_OPS: dict[str, Callable[[Any, Any], Any]] = {
     "max": lambda x, y: x if x > y else y,  # data-dependent branch
     "clamp": lambda x, c: x if x < c else c,  # comparison with a constant
     "sum": lambda x, y: sum([x, y, 1]),
+    "flag": lambda x, y: x * (x > y),  # a comparison used as data
+    "either": lambda x, y: (x > y) or (y > x),  # truth-tested operands
 }
 
 
 @st.composite
-def programs(draw: st.DrawFn) -> tuple[list[Any], list[Step]]:
-    kind = draw(st.sampled_from([ints, floats, decimals]))
+def programs(draw: st.DrawFn) -> tuple[list[Any], list[Step], bool]:
+    bools = draw(st.booleans())
+    kind = draw(st.sampled_from([ints, floats, decimals, st.booleans()]))
     inputs = draw(st.lists(kind, min_size=1, max_size=4))
+    # Without boolean tracing, "either" yields plain bools, and a plain bool on
+    # the left of a traced int is a documented gap of uninstrumented code.
+    ops = sorted(STEP_OPS) if bools else sorted(set(STEP_OPS) - {"either"})
     steps: list[Step] = []
     for n in range(draw(st.integers(min_value=1, max_value=8))):
         available = len(inputs) + n
         steps.append(
             (
-                draw(st.sampled_from(sorted(STEP_OPS))),
+                draw(st.sampled_from(ops)),
                 draw(st.integers(0, available - 1)),
                 draw(st.integers(0, available - 1)),
                 draw(ints),
             )
         )
-    return inputs, steps
+    return inputs, steps, bools
 
 
 def execute(steps: list[Step]) -> Callable[[dict[str, Any]], dict[str, Any]]:
@@ -124,12 +135,12 @@ def execute(steps: list[Step]) -> Callable[[dict[str, Any]], dict[str, Any]]:
 @settings(max_examples=300, deadline=None)
 @given(program=programs(), data=st.data())
 def test_propagation_agrees_with_reexecution(
-    program: tuple[list[Any], list[Step]], data: st.DataObject
+    program: tuple[list[Any], list[Step], bool], data: st.DataObject
 ) -> None:
-    inputs, steps = program
+    inputs, steps, bools = program
     workflow = execute(steps)
     try:
-        trace, _ = run(workflow, {"x": inputs})
+        trace, _ = run(workflow, {"x": inputs}, bools=bools)
     except (ArithmeticError, TypeError):
         assume(False)
 
@@ -141,7 +152,7 @@ def test_propagation_agrees_with_reexecution(
     edited = list(inputs)
     edited[index] = new_value
     try:
-        retrace, _ = run(workflow, {"x": edited})
+        retrace, _ = run(workflow, {"x": edited}, bools=bools)
     except (ArithmeticError, TypeError):
         # Re-execution fails: propagation must not have claimed exact results.
         assert not result.exact