crosshair-tool 0.0.87__cp38-cp38-musllinux_1_2_x86_64.whl → 0.0.92__cp38-cp38-musllinux_1_2_x86_64.whl

crosshair/__init__.py

@@ -15,7 +15,7 @@ from crosshair.statespace import StateSpace
 from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import IgnoreAttempt, debug
 
-__version__ = "0.0.87"  # Do not forget to update in setup.py!
+__version__ = "0.0.92"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

crosshair/_tracers.h

@@ -50,10 +50,11 @@ typedef struct HandlerTable {
 } HandlerTable;
 
 
-typedef struct FrameAndCallback {
-    PyObject* frame;
+typedef struct FrameNextIandCallback {
+    PyFrameObject* frame;
+    int expected_i;
     PyObject* callback;
-} FrameAndCallback;
+} FrameNextIandCallback;
 
 
 typedef struct CodeAndStacks {
@@ -62,7 +63,7 @@ typedef struct CodeAndStacks {
 } CodeAndStacks;
 
 
-DEFINE_VEC(FrameAndCallbackVec, FrameAndCallback, init_framecbvec, push_framecb);
+DEFINE_VEC(FrameNextIandCallbackVec, FrameNextIandCallback, init_framecbvec, push_framecb);
 DEFINE_VEC(ModuleVec, PyObject*, init_modulevec, push_module);
 DEFINE_VEC(TableVec, HandlerTable, init_tablevec, push_table_entry)
 
@@ -70,7 +71,7 @@ typedef struct CTracer {
     PyObject_HEAD
     ModuleVec modules;
     TableVec handlers;
-    FrameAndCallbackVec postop_callbacks;
+    FrameNextIandCallbackVec postop_callbacks;
     BOOL enabled;
     BOOL handling;
     BOOL trace_all_opcodes;

crosshair/libimpl/builtinslib.py

@@ -1425,6 +1425,10 @@ class PreciseIeeeSymbolicFloat(SymbolicFloat):
     # __hash__ has to be explicitly reassigned because we define __eq__
     __hash__ = SymbolicFloat.__hash__
 
+    def __bool__(self):
+        with NoTracing():
+            return not SymbolicBool(z3.fpIsZero(self.var))
+
     def __ne__(self, other):
         with NoTracing():
             coerced = type(self)._coerce_to_smt_sort(other)

crosshair/libimpl/builtinslib_test.py

@@ -85,7 +85,6 @@ from crosshair.util import (
     CrossHairValue,
     IgnoreAttempt,
     UnknownSatisfiability,
-    set_debug,
 )
 
 
@@ -3618,18 +3617,29 @@ def test_deep_realization(space, typ):
         assert concrete == symbolic
 
 
-def TODO_test_float_precision_issues(a, b):
-    # Does not yet work: floating point is modeled with infinite precision at the moment
-    def f(a: int, b: int):
-        """
-        pre: b !=0
-        post: a == b * _
+def test_float_round_to_zero(space):
+    space.extra(ModelingDirector).global_representations[
+        float
+    ] = PreciseIeeeSymbolicFloat
+    n = proxy_for_type(float, "n")
+    d = proxy_for_type(float, "d")
+    with ResumedTracing():
+        space.add(d != 0.0)
+        # This is possible for floats, but not reals:
+        assert space.is_possible(n / d != 0.0)
+        assert space.is_possible(n / d == 0.0)
 
-        Postcondition holds in a math-sense, but not when floating point precision
-        comes into play (e.g. it's false for 13 / 99)
-        """
 
-    return a / b
+def test_float_neg_zero_is_falsey(space):
+    space.extra(ModelingDirector).global_representations[
+        float
+    ] = PreciseIeeeSymbolicFloat
+    x = proxy_for_type(float, "x")
+    with ResumedTracing():
+        space.add(x == -10.0)
+        negzero = x / math.inf
+        assert not space.is_possible(negzero != 0.0)
+        assert bool(negzero) is False
 
 
 def TODO_test_int_mod_float():

crosshair/libimpl/copylib_test.py

@@ -0,0 +1,18 @@
+import copy
+import datetime
+
+from crosshair.core import proxy_for_type
+from crosshair.statespace import StateSpace
+from crosshair.tracers import ResumedTracing
+from crosshair.util import debug
+
+
+def test_date_copy(space: StateSpace) -> None:
+    concrete_date = datetime.date(2000, 2, 3)
+    symbolic_date = proxy_for_type(datetime.date, "d")
+    with ResumedTracing():
+        copied_symbolic = copy.deepcopy(symbolic_date)
+        copied_concrete = copy.deepcopy(concrete_date)
+        assert not space.is_possible(copied_concrete != concrete_date)
+        assert not space.is_possible(copied_concrete != datetime.date(2000, 2, 3))
+        assert not space.is_possible(copied_symbolic != symbolic_date)

crosshair/libimpl/datetimelib.py

@@ -855,7 +855,7 @@ class date:
 
     """
 
-    def __init__(self, year, month, day):
+    def __init__(self, year, month=None, day=None):
         """
         Constructor.
 
@@ -863,7 +863,13 @@ class date:
         :param month: month, starting at 1
         :param day: day, starting at 1
         """
-        year, month, day = _check_date_fields(year, month, day)
+        if month is None:
+            # We can receive a string/bytes single argument when unpickling a concrete date
+            with NoTracing():
+                dt = real_date(realize(year))  # type: ignore
+                year, month, day = dt.year, dt.month, dt.day
+        else:
+            year, month, day = _check_date_fields(year, month, day)
         self._year = year
         self._month = month
         self._day = day

crosshair/main_test.py

@@ -515,7 +515,7 @@ def test_mypycrosshair_command():
         capture_output=True,
         text=True,
     )
-    assert completion.stderr.strip() == ""
+    assert completion.stderr.strip() == "", f"stderr was '''{completion.stderr}'''"
     if completion.returncode != 1:
         print(completion.stdout)
         assert False, f"Return code was {completion.returncode}"

crosshair/opcode_intercept_test.py

@@ -286,3 +286,19 @@ def test_identity_operator_does_not_realize_on_differing_types():
         fourty_two = 42  # assignment just to avoid lint errors
         b1 is fourty_two
         assert len(space.choices_made) == choices_made_at_start
+
+
+class IExplodeOnRepr:
+    def __repr__(self):
+        raise ValueError("boom")
+
+
+def test_postop_callback_skipped_on_exception_handler_jump(space):
+    with ResumedTracing():
+        elements = IExplodeOnRepr()
+        try:
+            ret = f"these are them: {elements!r}"
+        except ValueError:  # pragma: no cover
+            ret = None
+        # need to do something(anything) with elements so that it's on the stack:
+        type(elements)

crosshair/pathing_oracle.py

@@ -6,7 +6,7 @@ from z3 import ExprRef  # type: ignore
 
 from crosshair.statespace import (
     AbstractPathingOracle,
-    DeatchedPathNode,
+    DetachedPathNode,
     ModelValueNode,
     NodeLike,
     RootNode,
@@ -117,14 +117,13 @@ class CoveragePathingOracle(AbstractPathingOracle):
         for step, node in enumerate(path[:-1]):
             if not isinstance(node, NodeLike):
                 continue
-            node = node.simplify()  # type: ignore
             if isinstance(node, WorstResultNode):
                 key = node.stacktail
                 if (key not in leading_locs) and (not isinstance(node, ModelValueNode)):
                     self.summarized_positions[key] += Counter(leading_conditions)
                 leading_locs.append(key)
-                next_node = path[step + 1].simplify()
-                if isinstance(next_node, DeatchedPathNode):
+                next_node = path[step + 1]
+                if isinstance(next_node, DetachedPathNode):
                     break
                 if step + 1 < len(path):
                     (is_positive, root_expr) = node.normalized_expr
@@ -133,9 +132,9 @@ class CoveragePathingOracle(AbstractPathingOracle):
                         if is_positive
                         else -self.internalize(root_expr)
                     )
-                    if next_node == node.positive.simplify():
+                    if next_node == node.positive:
                         leading_conditions.append(expr_signature)
-                    elif next_node == node.negative.simplify():
+                    elif next_node == node.negative:
                         leading_conditions.append(-expr_signature)
                     else:
                         raise CrossHairInternal(

crosshair/statespace.py

@@ -290,49 +290,10 @@ class NodeLike:
         """
         raise NotImplementedError
 
-    def is_stem(self) -> bool:
-        return False
-
-    def grow_into(self, node: _N) -> _N:
-        raise NotImplementedError
-
-    def simplify(self) -> "NodeLike":
-        return self
-
     def stats(self) -> StateSpaceCounter:
         raise NotImplementedError
 
 
-class NodeStem(NodeLike):
-    evolution: Optional["SearchTreeNode"] = None
-
-    def is_exhausted(self) -> bool:
-        return False if self.evolution is None else self.evolution.is_exhausted()
-
-    def get_result(self) -> CallAnalysis:
-        return (
-            CallAnalysis(VerificationStatus.UNKNOWN)
-            if self.evolution is None
-            else self.evolution.get_result()
-        )
-
-    def is_stem(self) -> bool:
-        return self.evolution is None or self.evolution.is_stem()
-
-    def grow_into(self, node: _N) -> _N:
-        self.evolution = node
-        return node
-
-    def simplify(self):
-        return self if self.evolution is None else self.evolution
-
-    def stats(self) -> StateSpaceCounter:
-        return StateSpaceCounter() if self.evolution is None else self.evolution.stats()
-
-    def __repr__(self) -> str:
-        return "NodeStem()"
-
-
 class SearchTreeNode(NodeLike):
     """A node in the execution path tree."""
 
@@ -364,6 +325,27 @@ class SearchTreeNode(NodeLike):
         raise NotImplementedError
 
 
+class NodeStem(NodeLike):
+    def __init__(self, parent: SearchTreeNode, parent_attr_name: str):
+        self.parent = parent
+        self.parent_attr_name = parent_attr_name
+
+    def grow(self, node: SearchTreeNode):
+        setattr(self.parent, self.parent_attr_name, node)
+
+    def is_exhausted(self) -> bool:
+        return False
+
+    def get_result(self) -> CallAnalysis:
+        return CallAnalysis(VerificationStatus.UNKNOWN)
+
+    def stats(self) -> StateSpaceCounter:
+        return StateSpaceCounter()
+
+    def __repr__(self) -> str:
+        return "NodeStem()"
+
+
 def solver_is_sat(solver, *exprs) -> bool:
     ret = solver.check(*exprs)
     if ret == z3.unknown:
@@ -411,7 +393,7 @@ class SinglePathNode(SearchTreeNode):
 
     def __init__(self, decision: bool):
         self.decision = decision
-        self.child = NodeStem()
+        self.child = NodeStem(self, "child")
         self._random = newrandom()
 
     def choose(
@@ -420,7 +402,7 @@ class SinglePathNode(SearchTreeNode):
         return (self.decision, 1.0, self.child)
 
     def compute_result(self, leaf_analysis: CallAnalysis) -> Tuple[CallAnalysis, bool]:
-        self.child = self.child.simplify()
+        assert isinstance(self.child, SearchTreeNode)
         return (self.child.get_result(), self.child.is_exhausted())
 
     def stats(self) -> StateSpaceCounter:
@@ -449,7 +431,7 @@ class RootNode(SinglePathNode):
         self.iteration = 0
 
 
-class DeatchedPathNode(SinglePathNode):
+class DetachedPathNode(SinglePathNode):
     def __init__(self):
         super().__init__(True)
         # Seems like `exhausted` should be True, but we set to False until we can
@@ -459,7 +441,6 @@ class DeatchedPathNode(SinglePathNode):
         self._stats = None
 
     def compute_result(self, leaf_analysis: CallAnalysis) -> Tuple[CallAnalysis, bool]:
-        self.child = self.child.simplify()
         return (leaf_analysis, True)
 
     def stats(self) -> StateSpaceCounter:
@@ -494,8 +475,8 @@ class RandomizedBinaryPathNode(BinaryPathNode):
     def __init__(self, rand: random.Random):
         super().__init__()
         self._random = rand
-        self.positive = NodeStem()
-        self.negative = NodeStem()
+        self.positive = NodeStem(self, "positive")
+        self.negative = NodeStem(self, "negative")
 
     def probability_true(
         self, space: "StateSpace", requested_probability: Optional[float] = None
@@ -520,10 +501,6 @@ class RandomizedBinaryPathNode(BinaryPathNode):
         else:
             return (positive_ok, 1.0, self.positive if positive_ok else self.negative)
 
-    def _simplify(self) -> None:
-        self.positive = self.positive.simplify()
-        self.negative = self.negative.simplify()
-
 
 class ParallelNode(RandomizedBinaryPathNode):
     """Choose either path; the first complete result will be used."""
@@ -537,7 +514,6 @@ class ParallelNode(RandomizedBinaryPathNode):
         return f"ParallelNode(false_pct={self._false_probability}, {self._desc})"
 
     def compute_result(self, leaf_analysis: CallAnalysis) -> Tuple[CallAnalysis, bool]:
-        self._simplify()
         positive, negative = self.positive, self.negative
         pos_exhausted = positive.is_exhausted()
         neg_exhausted = negative.is_exhausted()
@@ -655,7 +631,6 @@ class WorstResultNode(RandomizedBinaryPathNode):
         )
 
     def compute_result(self, leaf_analysis: CallAnalysis) -> Tuple[CallAnalysis, bool]:
-        self._simplify()
         positive, negative = self.positive, self.negative
         exhausted = self._is_exhausted()
         if node_status(positive) == VerificationStatus.REFUTED or (
@@ -697,7 +672,6 @@ class ModelValueNode(WorstResultNode):
 
 def debug_path_tree(node, highlights, prefix="") -> List[str]:
     highlighted = node in highlights
-    node = node.simplify()
     highlighted |= node in highlights
     if isinstance(node, BinaryPathNode):
         if isinstance(node, WorstResultNode) and node.forced_path is not None:
@@ -806,23 +780,27 @@ class StateSpace:
         return value  # type: ignore
 
     def stats_lookahead(self) -> Tuple[StateSpaceCounter, StateSpaceCounter]:
-        node = self._search_position.simplify()
-        if node.is_stem():
+        node = self._search_position
+        if isinstance(node, NodeStem):
             return (StateSpaceCounter(), StateSpaceCounter())
-        assert isinstance(
-            node, BinaryPathNode
-        ), f"node {node} {node.is_stem()} is not a binarypathnode"
+        assert isinstance(node, BinaryPathNode), f"node {node} is not a binarypathnode"
         return node.stats_lookahead()
 
+    def grow_into(self, node: _N) -> _N:
+        assert isinstance(self._search_position, NodeStem)
+        self._search_position.grow(node)
+        node.iteration = self._root.iteration
+        self._search_position = node
+        return node
+
     def fork_parallel(self, false_probability: float, desc: str = "") -> bool:
-        if self._search_position.is_stem():
-            node: NodeLike = self._search_position.grow_into(
-                ParallelNode(self._random, false_probability, desc)
-            )
+        node = self._search_position
+        if isinstance(node, NodeStem):
+            node = self.grow_into(ParallelNode(self._random, false_probability, desc))
+            node.stacktail = self.gen_stack_descriptions()
             assert isinstance(node, ParallelNode)
             self._search_position = node
         else:
-            node = self._search_position.simplify()
             if not isinstance(node, ParallelNode):
                 self.raise_not_deterministic(
                     node, "Wrong node type (expected ParallelNode)"
@@ -878,33 +856,34 @@ class StateSpace:
         # NOTE: format_stack() is more human readable, but it pulls source file contents,
         # so it is (1) slow, and (2) unstable when source code changes while we are checking.
         stacktail = self.gen_stack_descriptions()
-        if self._search_position.is_stem():
-            # We only allow time outs at stems - that's because we don't want
-            # to think about how mutating an existing path branch would work:
-            self.check_timeout()
-            node = self._search_position.grow_into(
-                WorstResultNode(self._random, expr, self.solver)
-            )
-            node.iteration = self._root.iteration
-            node.stacktail = stacktail
-        else:
-            node = self._search_position.simplify()  # type: ignore
+        if isinstance(self._search_position, SearchTreeNode):
+            node = self._search_position
             not_deterministic_reason = (
                 (
                     (not isinstance(node, WorstResultNode))
-                    and "Wrong node type (expected WorstResultNode)"
+                    and f"Wrong node type (is {name_of_type(type(node))}, expected WorstResultNode)"
                 )
                 # TODO: Not clear whether we want this stack trace check.
                 # A stack change usually indicates a serious problem, but not 100% of the time.
                 # Keeping it would mean that we fail earlier.
                 # But also see https://github.com/HypothesisWorks/hypothesis/pull/4034#issuecomment-2606415404
                 # or (node.stacktail != stacktail and "Stack trace changed")
-                or ((not z3.eq(node.expr, expr)) and "SMT expression changed")
+                or (
+                    (hasattr(node, "expr") and (not z3.eq(node.expr, expr)))
+                    and "SMT expression changed"
+                )
             )
             if not_deterministic_reason:
                 self.raise_not_deterministic(
                     node, not_deterministic_reason, expr=expr, stacktail=stacktail
                 )
+        else:
+            # We only allow time outs at stems - that's because we don't want
+            # to think about how mutating an existing path branch would work:
+            self.check_timeout()
+            node = self.grow_into(WorstResultNode(self._random, expr, self.solver))
+            node.stacktail = stacktail
+
         self._search_position = node
         choose_true, chosen_probability, stem = node.choose(
             self, probability_true=probability_true
@@ -937,10 +916,10 @@ class StateSpace:
         currently_handling: Optional[BaseException] = None,
     ) -> NoReturn:
         lines = ["*** Begin Not Deterministic Debug ***"]
-        if hasattr(node, "iteration"):
-            lines.append(f"Previous iteration: {node.iteration}")
+        if getattr(node, "iteration", None) is not None:
+            lines.append(f"Previous iteration: {node.iteration}")  # type: ignore
         if hasattr(node, "expr"):
-            lines.append(f"Previous SMT expression: {node.expr}")
+            lines.append(f"Previous SMT expression: {node.expr}")  # type: ignore
         if expr is not None:
             lines.append(f"Current SMT expression: {expr}")
         if not stacktail:
@@ -966,11 +945,11 @@ class StateSpace:
     def find_model_value(self, expr: z3.ExprRef) -> Any:
         with NoTracing():
             while True:
-                if self._search_position.is_stem():
-                    self._search_position = self._search_position.grow_into(
+                if isinstance(self._search_position, NodeStem):
+                    self._search_position = self.grow_into(
                         ModelValueNode(self._random, expr, self.solver)
                     )
-                node = self._search_position.simplify()
+                node = self._search_position
                 if isinstance(node, SearchLeaf):
                     raise CrossHairInternal(
                         f"Cannot use symbolics; path is already terminated"
@@ -1109,14 +1088,14 @@ class StateSpace:
                 if not prefer_true(check_ret):
                     raise IgnoreAttempt("deferred assumption failed: " + description)
             self.is_detached = True
-            if not self._search_position.is_stem():
+            if not isinstance(self._search_position, NodeStem):
                 self.raise_not_deterministic(
                     self._search_position,
-                    f"Expect to detach path at a stem node, not at this node: {self._search_position.simplify()}",
+                    f"Expect to detach path at a stem node, not at this node: {self._search_position}",
                     currently_handling=currently_handling,
                 )
-            node = self._search_position.grow_into(DeatchedPathNode())
-            assert node.child.is_stem()
+            node = self.grow_into(DetachedPathNode())
+            assert isinstance(node.child, NodeStem)
             self.choices_made.append(node)
             self._search_position = node.child
             debug("Detached from search tree")
@@ -1130,12 +1109,9 @@ class StateSpace:
         self, analysis: CallAnalysis
     ) -> Tuple[Optional[CallAnalysis], bool]:
         # In some cases, we might ignore an attempt while not at a leaf.
-        if self._search_position.is_stem():
-            self._search_position = self._search_position.grow_into(
-                SearchLeaf(analysis)
-            )
+        if isinstance(self._search_position, NodeStem):
+            self._search_position = self.grow_into(SearchLeaf(analysis))
         else:
-            self._search_position = self._search_position.simplify()
             assert isinstance(self._search_position, SearchTreeNode)
             self._search_position.exhausted = True
             self._search_position.result = analysis

crosshair/test_util.py

@@ -1,9 +1,21 @@
 import pathlib
 import sys
-from collections.abc import Container
 from copy import deepcopy
 from dataclasses import dataclass, replace
-from typing import Callable, Iterable, List, Mapping, Optional, Sequence, Tuple
+from decimal import Decimal
+from math import isnan
+from numbers import Real
+from typing import (
+    Callable,
+    Collection,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+)
 
 from crosshair.core import (
     AnalysisMessage,
@@ -29,6 +41,13 @@ from crosshair.util import (
 ComparableLists = Tuple[List, List]
 
 
+class _Missing:
+    pass
+
+
+_MISSING = _Missing()
+
+
 def simplefs(path: pathlib.Path, files: dict) -> None:
     for name, contents in files.items():
         subpath = path / name
@@ -123,34 +142,39 @@ def check_messages(checkables: Iterable[Checkable], **kw) -> ComparableLists:
     return (msgs, [AnalysisMessage(**kw)])
 
 
-def flexible_equal(a, b):
+_NAN_ABLE = (Decimal, Real)
+
+
+def flexible_equal(a: object, b: object) -> bool:
     if a is b:
         return True
     if type(a) is type(b) and type(a).__eq__ is object.__eq__:
         # If types match and it uses identity-equals, we can't do much. Assume equal.
         return True
-    if a != a and b != b:  # handle float('nan')
+    if isinstance(a, _NAN_ABLE) and isinstance(b, _NAN_ABLE) and isnan(a) and isnan(b):
         return True
     if (
         is_iterable(a)
-        and not isinstance(a, Container)
+        and not isinstance(a, Collection)
         and is_iterable(b)
-        and not isinstance(b, Container)
+        and not isinstance(b, Collection)
     ):  # unsized iterables compare by contents
-        a, b = list(a), list(b)
-    if type(a) == type(b):
+        a, b = list(a), list(b)  # type: ignore
+    if (
+        type(a) == type(b)
+        and isinstance(a, Collection)
+        and not isinstance(a, (str, bytes, Set))
+    ):
         # Recursively apply flexible_equal for most containers:
+        if len(a) != len(b):  # type: ignore
+            return False
         if isinstance(a, Mapping):
-            if len(a) != len(b):
-                return False
             for k, v in a.items():
-                if not flexible_equal(v, b[k]):
+                if not flexible_equal(v, b.get(k, _MISSING)):  # type: ignore
                     return False
             return True
-        if isinstance(a, Container) and not isinstance(a, (str, bytes)):
-            if len(a) != len(b):
-                return False
-            return all(flexible_equal(ai, bi) for ai, bi in zip(a, b))
+        else:
+            return all(flexible_equal(ai, bi) for ai, bi in zip(a, b))  # type: ignore
 
     return a == b
 

crosshair/test_util_test.py

@@ -14,3 +14,13 @@ def test_flexible_equal():
     assert flexible_equal(gen(), iter([11, 22]))
     assert not flexible_equal(gen(), iter([11, 22, 33]))
     assert not flexible_equal(gen(), iter([11]))
+
+    ordered_set_1 = {10_000, 20_000} | {30_000}
+    ordered_set_2 = {30_000, 20_000} | {10_000}
+    assert list(ordered_set_1) != list(ordered_set_2)  # (different orderings)
+    assert flexible_equal(ordered_set_1, ordered_set_2)
+
+    ordered_dict_1 = {1: 2, 3: 4}
+    ordered_dict_2 = {3: 4, 1: 2}
+    assert list(ordered_dict_1.items()) != list(ordered_dict_2.items())
+    assert flexible_equal(ordered_dict_1, ordered_dict_2)

crosshair/type_repo.py

@@ -20,6 +20,8 @@ _IGNORED_MODULE_ROOTS = {
     "pkg_resources",
     "pytest",
     "py",  # (part of pytest)
+    # Disabled because the import attempt can cause problems:
+    "numpy",  # importing numpy/testing/_private/utils.py attempts a subprocess call
 }
 
 
@@ -59,8 +61,6 @@ def get_subclass_map() -> Dict[type, List[type]]:
             if module_name.split(".", 1)[0] in _IGNORED_MODULE_ROOTS:
                 continue
             if module is None:
-                # We set the internal _datetime module to None, ensuring that
-                # we don't load the C implementation.
                 continue
             try:
                 module_classes = inspect.getmembers(module, inspect.isclass)

crosshair/util.py

@@ -54,6 +54,8 @@ from crosshair.tracers import COMPOSITE_TRACER, NoTracing, ResumedTracing, is_tr
 _DEBUG_STREAM: Optional[TextIO] = None
 
 
+# NOTE: many of these is_* functions should use a TypeGuard in 3.10 (or even TypeIs in 3.13)
+
 if sys.version_info >= (3, 12):
     from collections.abc import Buffer
 

{crosshair_tool-0.0.87.dist-info → crosshair_tool-0.0.92.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crosshair-tool
-Version: 0.0.87
+Version: 0.0.92
 Summary: Analyze Python code for correctness using symbolic execution.
 Home-page: https://github.com/pschanely/CrossHair
 Author: Phillip Schanely

{crosshair_tool-0.0.87.dist-info → crosshair_tool-0.0.92.dist-info}/RECORD

@@ -1,9 +1,9 @@
-_crosshair_tracers.cpython-38-x86_64-linux-gnu.so,sha256=JbRTzxKqYhLs4Xhd9ixSUjtmtLzozo4H9w13RI1Q9wY,75744
-crosshair/__init__.py,sha256=pCHAq8T8tcr3KLNCJY6xCK4MAWSn-XIiJTIrjTaMpPE,936
+_crosshair_tracers.cpython-38-x86_64-linux-gnu.so,sha256=I2PQ2mjtjrfVX3uIISbP3TZ2i1ZIigIgZIWJxRFSX2Q,75984
+crosshair/__init__.py,sha256=pMTYFz7JCsH9F93C11wN9P-sZKW9G1H1Dxfu_XdZHkg,936
 crosshair/__main__.py,sha256=zw9Ylf8v2fGocE57o4FqvD0lc7U4Ld2GbeCGxRWrpqo,252
 crosshair/_mark_stacks.h,sha256=j86qubOUvVhoR19d74iQ084RrTEq8M6oT4wJsGQUySY,28678
 crosshair/_preliminaries_test.py,sha256=r2PohNNMfIkDqsnvI6gKlJTbwBaZA9NQJueQfJMN2Eo,504
-crosshair/_tracers.h,sha256=qaDWd-_eCZckSbezrXXst6lppzFiM2kD2AcZgvVQm18,2124
+crosshair/_tracers.h,sha256=QFBklLqMWmIpUzBIn_A4SKdpjwHs-N7ttx-F5jtWWCQ,2174
 crosshair/_tracers_pycompat.h,sha256=6IYnbQxrYkhBsLDAHSX25DPOwo1oYHCZUVWZ8c7YCnQ,14356
 crosshair/_tracers_test.py,sha256=KpCGspjOUeZuhwTYgn_RxI4M4wMbT5rldusFDgneQ6M,3596
 crosshair/abcstring.py,sha256=ROU8LzS7kfEU2L_D3QfhVxIjrYr1VctwUWfylC7KlCc,6549
@@ -32,11 +32,11 @@ crosshair/fuzz_core_test.py,sha256=q7WsZt6bj5OJrXaVsT3JaRYWWnL8X_1flSfty4Z7CcA,1
 crosshair/lsp_server.py,sha256=j7SX4pdVwa2MrtkNIjajLilzl5CZTY6PrBQsa26cdNo,8670
 crosshair/lsp_server_test.py,sha256=7LO1Qqxkper3Xt2krgOlGqF1O_uDObo76o4FZbIqykY,969
 crosshair/main.py,sha256=6RXjj1FIyBK6i6xOx-bs-CsHLgOZcc9hL3U1JRwxpA0,34378
-crosshair/main_test.py,sha256=DFXtE--616vCF1WAS576SHXO19K0LsDPzJIWNT5vuXM,14383
+crosshair/main_test.py,sha256=eEoK4LHKSaX-6iJx3tAVbwCaBJc0ri3VoCPtLD5em2U,14424
 crosshair/objectproxy.py,sha256=Uc6mNkJBInvETGWBHI10GSNEIrBYDIxlAZ30M3PAIhQ,8935
 crosshair/objectproxy_test.py,sha256=KykRJLSHCDA7jb_XPBDhXHnS6Q1fG4oIJ579CeSEz3k,567
 crosshair/opcode_intercept.py,sha256=z4Yb9prYE2UK21AxhjAeXyXAk5IriDuCSSCeNhbDu2A,21880
-crosshair/opcode_intercept_test.py,sha256=hBf04VwhaIzPdoAaqQmQJfx36yaznD9sm9x1Lb9VDm8,8790
+crosshair/opcode_intercept_test.py,sha256=Si3rJQR5cs5d4uB8uwE2K8MjP8rE1a4yHkjXzhfS10A,9241
 crosshair/options.py,sha256=htQNgnrpoRjSNq6rfLBAF8nos-NNIwmP6tQYyI8ugsM,6775
 crosshair/options_test.py,sha256=lzA-XtwEwQPa4wV1wwhCRKhyLOvIhThU9WK5QRaRbxQ,379
 crosshair/patch_equivalence_test.py,sha256=mvYpsbHZS2AiQra-jK8T8QywAG1gNNCUNQPPWI9k5t8,2506
@@ -44,7 +44,7 @@ crosshair/path_cover.py,sha256=wV0Vy8IPDzqXQ2VI8a94FxltS9p-Y1oF17OKePjvpgs,6710
 crosshair/path_cover_test.py,sha256=U46zw4-m7yAXhu8-3Xnhvf-_9Ov5ivfCAm5euGwpRFA,4089
 crosshair/path_search.py,sha256=wwZjp-3E4dENnJa6BlnSq8FARkIx0PyUYc7kvH32A2k,5588
 crosshair/path_search_test.py,sha256=7cqzAMXUYAtA00mq9XR5AaZChqeQyXyCfuuv53_51pk,1692
-crosshair/pathing_oracle.py,sha256=4mvZuXb-JXIxojidk5-43PXnPfIfAEFa-1LvAvVlCqk,9303
+crosshair/pathing_oracle.py,sha256=3M93zXMorWr8m5c1KM2zGU5X1M3lcV-AIw0lX74eN00,9219
 crosshair/pure_importer.py,sha256=-t4eowrZOQmfqK1N2tjI5POoaxRGavytwMmbRivelFg,878
 crosshair/pure_importer_test.py,sha256=Xjtlwn1mj7g-6VA87lrvzfUADCjlmn1wgHtbrnc0uuY,421
 crosshair/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -54,18 +54,18 @@ crosshair/simplestructs.py,sha256=CiZSuHH_j_bYitaW-n7vWd_42xSyV6Jh8es3BQLlcHk,34
 crosshair/simplestructs_test.py,sha256=6uDdrSISHLhwnFuESkR8mUGw7m1llM6vCNDFChkfSs8,8639
 crosshair/smtlib.py,sha256=hh-P32KHoH9BCq3oDYGp2PfOeOb8CwDj8tTkgqroLD8,689
 crosshair/smtlib_test.py,sha256=edzEn19u2YYHxSzG9RrMiu2HTiEexAuehC3IlG9LuJM,511
-crosshair/statespace.py,sha256=KeIIBwBKxDgQO0ML2LvYXhS5DgmelaYF-RRXopR9lqA,41794
+crosshair/statespace.py,sha256=TVjUhFZU0x72oLPN7-eRu7PoMh1OiQOy0uMASsFb_Qw,41236
 crosshair/statespace_test.py,sha256=LOblIarBbcB9oD_gVR5kK_4P2PWQymVGgJr3wNqP3Fs,2621
 crosshair/stubs_parser.py,sha256=rlBTQus5BlZ3Ygg6Xzk5dbQbDtRpv6w9i2HQmGrPVmc,14240
 crosshair/stubs_parser_test.py,sha256=0itTT0Udul_51RJXNv6KB97z44gYze6NZfKJL7yIDzA,1228
-crosshair/test_util.py,sha256=HQ1nd5KZJfrZ8S5iP0EkltCtGu0PGELB3hCcPXk78ow,10073
-crosshair/test_util_test.py,sha256=FIOWVBMiF-zyq0pGsDQ8W6lB6_E9sGpD80dioHHETyQ,512
+crosshair/test_util.py,sha256=D9-f-DdzJemfAUkQL0cwKxPL8RZ-5gkVmghyRcKlBJI,10367
+crosshair/test_util_test.py,sha256=_r8DtAI5b1Yn1ruv9o51FWHmARII3-WDkWWnnY1iaAw,943
 crosshair/tracers.py,sha256=_jaSDgZ_pYdqacWE_msXn7W7CoSdQ_-7hlrxa891oHo,17139
 crosshair/tracers_test.py,sha256=EBK_ZCy2MsxqmEaGjo0uw9zAztW9O6fhCW_0PJxyTS8,3270
-crosshair/type_repo.py,sha256=dqMnDNgBqchRwsbXJcZmPyPHfiQC9kqFAB7z-zoA_0I,4649
+crosshair/type_repo.py,sha256=x_eK-YlcHv_dxDKy6m7ty0zNO6y058o3r6QJ55RcG3s,4664
 crosshair/unicode_categories.py,sha256=g4pnUPanx8KkpwI06ZUGx8GR8Myruf_EpTjyti_V4z8,333519
 crosshair/unicode_categories_test.py,sha256=ZAU37IDGm9PDvwy_CGFcrF9Waa8JuUNdI4aq74wkB6c,739
-crosshair/util.py,sha256=eddHHvkn9NnsfYahpuIF4Xp03kIiQ8EJUaliFEO4XG4,22124
+crosshair/util.py,sha256=sIfaKFvNHR5w5VCno2d15d_LyfwoewKqRzJ_3ZNV-Vc,22218
 crosshair/util_test.py,sha256=_KTQ0O4cLhF1pAeB8Y8Cyqbd0UyZf5KxJUaiA-ew-tE,4676
 crosshair/watcher.py,sha256=kCCMlLe2KhW5MbEbMmixNRjRAvu5CypIAGd1V_YZ9QM,10048
 crosshair/watcher_test.py,sha256=Ef1YSwy68wWPR5nPjwvEKPqxltI9pE9lTbnesmDy3Bk,2764
@@ -100,16 +100,17 @@ crosshair/libimpl/binascii_ch_test.py,sha256=hFqSfF1Q8jl2LNBIWaQ6vBJIIshPOmSwrR0
 crosshair/libimpl/binascii_test.py,sha256=LOBqLAJ77Kx8vorjVTaT3X0Z93zw4P5BvwUapMCiSLg,1970
 crosshair/libimpl/binasciilib.py,sha256=9w4C37uxRNOmz9EUuhJduHlMKn0f7baY5fwwdvx1uto,5070
 crosshair/libimpl/bisectlib_test.py,sha256=ZQtYmBYD0Pb1IiFelsgdvqyeUMKaqaDb1BRb87LTSbI,753
-crosshair/libimpl/builtinslib.py,sha256=NjTvFTdPwQcBWC4PWmnD73rK37eXUp3pdwRoz2-IBEI,171512
+crosshair/libimpl/builtinslib.py,sha256=0NRP8l_weL0kh050cOKMrqK8y-glh3NySYLJYjdHVz8,171622
 crosshair/libimpl/builtinslib_ch_test.py,sha256=W4wWapqlxSjsC5XgREfgxS9e_iwKxgNQhbFE3umUfNI,30504
-crosshair/libimpl/builtinslib_test.py,sha256=Q0DvH7Q_Ja0Tg83enhB_y_Pdau_S-bA6ztorjvgl4Mw,90275
+crosshair/libimpl/builtinslib_test.py,sha256=Y_jRe5J6pPaJ_Nuk1lJ1biP5yczsfCj--NgNhwcbAfQ,90654
 crosshair/libimpl/codecslib.py,sha256=lB87T1EYSBh4JXaqzjSpQG9CMfKtgckwA7f6OIR0S-Q,2668
 crosshair/libimpl/codecslib_test.py,sha256=8K64njhxnTe7qLh-_onARNsm_qSG7BWM5dXgADYi54A,2536
 crosshair/libimpl/collectionslib.py,sha256=VuDIOUOGORiUT9J0tDVECr6oC-yUR3WAiFnMeVGzi-o,8583
 crosshair/libimpl/collectionslib_ch_test.py,sha256=PYitnmXXEZfm25FzBodEX1hOpwqnDspbqt5aqzeVar0,5855
 crosshair/libimpl/collectionslib_test.py,sha256=3h7XTToKWauMhjrEwLXVI0jT8FZKBlkvlw0oiPMmuKM,9164
 crosshair/libimpl/copylib.py,sha256=icHJWeFK_tsPSdJhvlS5fVcBwlh0uJh0nzXsRJCGtzs,527
-crosshair/libimpl/datetimelib.py,sha256=osysXCLJCgyCj0gR8e0iyCeulgUvJ9rrO60kz1gudAY,78869
+crosshair/libimpl/copylib_test.py,sha256=VpS9ICvIjzKw0kccsl1v5FB1chHHEIWdOAerEQ_pGMw,705
+crosshair/libimpl/datetimelib.py,sha256=kVWcoHMX-dPW-un7XoEIURfWlVOst6h_JFmjrhFiE1U,79168
 crosshair/libimpl/datetimelib_ch_test.py,sha256=r_V9H34a4POlEeffi46mEtVI9ek80DHaEOiCTKON9Us,9283
 crosshair/libimpl/datetimelib_test.py,sha256=v9Cg512AXIGy7_dsN2y_ZD7W7fqfSSz07eiCUZukM60,2659
 crosshair/libimpl/decimallib.py,sha256=zBKDrDZcg45oCKUkf6SIDuVpjA1Web7tD1MEQo5cjxI,177348
@@ -166,9 +167,9 @@ crosshair/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 crosshair/tools/check_help_in_doc.py,sha256=P21AH3mYrTVuBgWD6v65YXqBqmqpQDUTQeoZ10rB6TU,8235
 crosshair/tools/check_init_and_setup_coincide.py,sha256=kv61bXqKSKF_5J-kLNEhCrCPyszg7iZQWDu_Scnec98,3502
 crosshair/tools/generate_demo_table.py,sha256=0SeO0xQdiT-mbLNHt4rYL0wcc2DMh0v3qtzBdoQonDk,3831
-crosshair_tool-0.0.87.dist-info/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
-crosshair_tool-0.0.87.dist-info/METADATA,sha256=Cl5gBHvAgGxCsb0tJaQanEEYxRxamxXBybQs58zIeCg,6505
-crosshair_tool-0.0.87.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
-crosshair_tool-0.0.87.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
-crosshair_tool-0.0.87.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
-crosshair_tool-0.0.87.dist-info/RECORD,,
+crosshair_tool-0.0.92.dist-info/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
+crosshair_tool-0.0.92.dist-info/METADATA,sha256=RUQQoXFwTyS_7UN78XYKSPjCDReOdnGfYkZibT-jZKU,6505
+crosshair_tool-0.0.92.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
+crosshair_tool-0.0.92.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
+crosshair_tool-0.0.92.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
+crosshair_tool-0.0.92.dist-info/RECORD,,