crosshair-tool 0.0.88__cp313-cp313-musllinux_1_2_x86_64.whl → 0.0.93__cp313-cp313-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.88"  # Do not forget to update in setup.py!
+__version__ = "0.0.93"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

crosshair/core.py

@@ -329,9 +329,10 @@ def with_realized_args(fn: Callable, deep=False) -> Callable:
 
     def realizer(*a, **kw):
         with NoTracing():
-            a = map(realize_fn, a)
+            a = [realize_fn(arg) for arg in a]
             kw = {k: realize_fn(v) for (k, v) in kw.items()}
-            return fn(*a, **kw)
+        # You might think we don't need tracing here, but some operations can invoke user-defined behavior:
+        return fn(*a, **kw)
 
     functools.update_wrapper(realizer, fn)
     return realizer

crosshair/libimpl/builtinslib.py

@@ -4441,10 +4441,11 @@ def _int(val: Any = 0, base=_MISSING):
                     else:
                         ret = (ret * base) + ch_num
                 return ret
-        if base is _MISSING:
-            return int(deep_realize(val))
-        else:
-            return int(deep_realize(val), base=realize(base))
+        elif isinstance(val, CrossHairValue):
+            val = deep_realize(val)
+            base = deep_realize(base)
+
+    return int(val) if base is _MISSING else int(val, base=base)
 
 
 _FLOAT_REGEX = re.compile(
@@ -4549,7 +4550,7 @@ def _len(ls):
 def _map(fn, *iters):
     # Wrap the `map` callback in a pure Python lambda.
     # This de-optimization ensures that the callback can be intercepted.
-    return map(lambda x: fn(x), *iters)
+    return map(lambda *a: fn(*a), *iters)
 
 
 def _memoryview(source):

crosshair/libimpl/fractionlib_test.py

@@ -5,7 +5,8 @@ from crosshair.core import deep_realize
 from crosshair.core_and_libs import proxy_for_type
 from crosshair.statespace import POST_FAIL
 from crosshair.test_util import check_states
-from crosshair.tracers import ResumedTracing
+from crosshair.tracers import ResumedTracing, is_tracing
+from crosshair.util import CrossHairInternal
 
 
 def test_fraction_realize(space):
@@ -16,6 +17,28 @@ def test_fraction_realize(space):
         deep_realize(Fraction(n, d))
 
 
+class UserFraction(Fraction):
+    def __int__(self):
+        if not is_tracing():
+            raise CrossHairInternal("tracing required while in user code")
+        return 1
+
+    def __round__(self, *a, **kw):
+        if not is_tracing():
+            raise CrossHairInternal("tracing required while in user code")
+        return super().__round__(*a, **kw)
+
+
+def test_user_fraction_tracing(space):
+    n = proxy_for_type(int, "n")
+    d = proxy_for_type(int, "d")
+    with ResumedTracing():
+        space.add(d != 0)
+        fraction = UserFraction(n, d)
+        round(fraction)  # (works via with_realized_args)
+        int(fraction)  # (custom interception)
+
+
 def test_fraction_copy_doesnt_realize(space):
     n = proxy_for_type(int, "n")
     with ResumedTracing():

crosshair/patch_equivalence_test.py

@@ -1,5 +1,6 @@
 import copy
 import itertools
+import operator
 import re
 import sys
 from dataclasses import dataclass
@@ -39,6 +40,7 @@ possible_args = [
     (42, int),  # isinstance
     (re.compile("(ab|a|b)"), r"\n", ""),  # re methods
     (bool, [1, 1, 0]),  # itertools.takewhile and friends
+    (operator.add, [1, 0], [1, 1]),  # multi-iterable map
     ([(1, 2), (3, 4)]),  # key-value pairs
     ([(1, 2), ([], 4)]),  # key-value pairs w/ unhashable key
 ]

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.88.dist-info → crosshair_tool-0.0.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crosshair-tool
-Version: 0.0.88
+Version: 0.0.93
 Summary: Analyze Python code for correctness using symbolic execution.
 Home-page: https://github.com/pschanely/CrossHair
 Author: Phillip Schanely
@@ -47,6 +47,7 @@ Requires-Dist: setuptools; extra == "dev"
 Requires-Dist: sphinx>=3.4.3; extra == "dev"
 Requires-Dist: sphinx-rtd-theme>=0.5.1; extra == "dev"
 Requires-Dist: rst2pdf>=0.102; extra == "dev"
+Requires-Dist: z3-solver==4.14.1.0; extra == "dev"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{crosshair_tool-0.0.88.dist-info → crosshair_tool-0.0.93.dist-info}/RECORD

@@ -1,5 +1,5 @@
-_crosshair_tracers.cpython-313-x86_64-linux-musl.so,sha256=Z2SgScHtOg2z92ZHPdmaV5EYqiTFsEOVcOGGI8g95AQ,121680
-crosshair/__init__.py,sha256=SSP_9GXeo_0ypAR-f-Zt32yVGvXY3tEY9SWKDgy_m_A,936
+_crosshair_tracers.cpython-313-x86_64-linux-musl.so,sha256=3LUEPD-dVqiKIuAp-hqgfrasmI2ai2dbn1IODJAK8Lc,121688
+crosshair/__init__.py,sha256=LfHa3bjHbl9WlLnVFSn-2R3qe0yEptc8-0Edze71rmo,936
 crosshair/__main__.py,sha256=zw9Ylf8v2fGocE57o4FqvD0lc7U4Ld2GbeCGxRWrpqo,252
 crosshair/_mark_stacks.h,sha256=j86qubOUvVhoR19d74iQ084RrTEq8M6oT4wJsGQUySY,28678
 crosshair/_preliminaries_test.py,sha256=r2PohNNMfIkDqsnvI6gKlJTbwBaZA9NQJueQfJMN2Eo,504
@@ -16,7 +16,7 @@ crosshair/condition_parser_test.py,sha256=eUQYnVkHewn8qg-XbzcElb0mHkPxPJAX548dPV
 crosshair/conftest.py,sha256=BkLszApkdy6FrvzaHO7xh8_BJrG9AfytFTse-HuQVvg,653
 crosshair/copyext.py,sha256=GBGQP9YAHoezLXwb_M59Hh1VXSou5EQt4ZmmUA0T_og,4899
 crosshair/copyext_test.py,sha256=uJzdC9m2FqMjqQ-ITFoP0MZg3OCiO8paU-d533KocD8,2108
-crosshair/core.py,sha256=K7147xrvcvtrP1T9oIRywq2uHMMsIu8ZwFZWBQXPozg,63634
+crosshair/core.py,sha256=YegFbe3RMJwxHCadhJ42gUJjL9mICaLAE_Dmb1-lsK4,63750
 crosshair/core_and_libs.py,sha256=8FGL62GnyX6WHOqKh0rqJ0aJ_He5pwZm_zwPXTaPqhI,3963
 crosshair/core_regestered_types_test.py,sha256=er3ianvu-l0RS-WrS46jmOWr4Jq06Cec9htAXGXJSNg,2099
 crosshair/core_test.py,sha256=H6qZFBFuUhgh9qWgxxc1Cs7xuC8s6FYvewmTYUh0Dpg,32200
@@ -39,12 +39,12 @@ crosshair/opcode_intercept.py,sha256=z4Yb9prYE2UK21AxhjAeXyXAk5IriDuCSSCeNhbDu2A
 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
+crosshair/patch_equivalence_test.py,sha256=eoLaGRvrR9nGUO_ybZ9XsWhs5ejC4IEPd0k-ihG3Nsg,2580
 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,7 +100,7 @@ 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=0NRP8l_weL0kh050cOKMrqK8y-glh3NySYLJYjdHVz8,171622
+crosshair/libimpl/builtinslib.py,sha256=UU2WDnQbPQMIETjvKfJlDXAFYyAXcRVvGt4SFYs-Jgk,171663
 crosshair/libimpl/builtinslib_ch_test.py,sha256=W4wWapqlxSjsC5XgREfgxS9e_iwKxgNQhbFE3umUfNI,30504
 crosshair/libimpl/builtinslib_test.py,sha256=Y_jRe5J6pPaJ_Nuk1lJ1biP5yczsfCj--NgNhwcbAfQ,90654
 crosshair/libimpl/codecslib.py,sha256=lB87T1EYSBh4JXaqzjSpQG9CMfKtgckwA7f6OIR0S-Q,2668
@@ -118,7 +118,7 @@ crosshair/libimpl/decimallib_ch_test.py,sha256=FVCY4KB8lJWeRKnz8txNkEc1te4QRKQYJ
 crosshair/libimpl/decimallib_test.py,sha256=393MkVB9-LPcA7JJK6wGAbDyd-YejkjwrXRaEDaVhjM,2238
 crosshair/libimpl/encodings_ch_test.py,sha256=0qLsioOuFUZkOjP4J9Wct4CGBaBY8BnHx9paZHnIofI,2513
 crosshair/libimpl/fractionlib.py,sha256=qdbiAHHC480YdKq3wYK_piZ3UD7oT64YfuNclypMUfQ,458
-crosshair/libimpl/fractionlib_test.py,sha256=lLMbGvzP5E_tnZ2Yi5_MawRxwqsSJZRW1A7vtgSSBvM,1638
+crosshair/libimpl/fractionlib_test.py,sha256=g7uNHTfzDebyc-SgH_4ziUAz7rJLZlHGZmPpny2P6hs,2357
 crosshair/libimpl/functoolslib.py,sha256=LnMtmq2Sawde6XtPd6Yg_YOc6S5ai-pMpBWPQAkR3X4,783
 crosshair/libimpl/functoolslib_test.py,sha256=DswrS51n93EaxPvDGB-d3tZSLawEp38zQ5sNdYlbn50,1114
 crosshair/libimpl/hashliblib.py,sha256=Ki_cw28OnhZExgKbSoh5GaDbBfNRIOqH7O2aYQJGS3M,1234
@@ -167,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.88.dist-info/METADATA,sha256=fb65F1neoaCfY1YaRda8cocX3gOjjCWW5it7Xn2DXto,6726
-crosshair_tool-0.0.88.dist-info/WHEEL,sha256=4VbEOkf4fdBUBHdV24POjoH-zuik_eIDLSImZZCAQpQ,112
-crosshair_tool-0.0.88.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
-crosshair_tool-0.0.88.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
-crosshair_tool-0.0.88.dist-info/RECORD,,
-crosshair_tool-0.0.88.dist-info/licenses/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
+crosshair_tool-0.0.93.dist-info/METADATA,sha256=EYRE-NAWbA23Od5TfsbHDQ_R70UNonJPNCdNawPlT-c,6777
+crosshair_tool-0.0.93.dist-info/WHEEL,sha256=4VbEOkf4fdBUBHdV24POjoH-zuik_eIDLSImZZCAQpQ,112
+crosshair_tool-0.0.93.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
+crosshair_tool-0.0.93.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
+crosshair_tool-0.0.93.dist-info/RECORD,,
+crosshair_tool-0.0.93.dist-info/licenses/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459