crosshair-tool 0.0.88__cp39-cp39-win32.whl → 0.0.93__cp39-cp39-win32.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.cp39-win32.pyd,sha256=LWofHnbz5Q_Zh9LXLclULAUJUqP61VBfHK5A5upyAJA,16896
-crosshair/__init__.py,sha256=aoBTLbJ7tIqXmDmoBuAAVQkH2YErTHwp2Ji0ctl4OiI,978
+_crosshair_tracers.cp39-win32.pyd,sha256=WdlUdnnnS1Im5DEy2X6G04Ch0XOC9YvrKhESfpM2I1A,16896
+crosshair/__init__.py,sha256=aNQs81VDq95_ZF8wWBUtdIO4BNRcGH-CkBCuKIy37dE,978
 crosshair/__main__.py,sha256=i4pjsZlXvtieQHJTEB0sF3e40qJjLoOm1z5rm-u70Uo,260
 crosshair/_mark_stacks.h,sha256=IImygydFK9qethf41gUZDjySHR3WLXs-YsqWCHK9UFg,29468
 crosshair/_preliminaries_test.py,sha256=klkzKGpyyVDGctCXdvq1xyXbGa4PRnXda1jfgE-7LLY,522
@@ -16,7 +16,7 @@ crosshair/condition_parser_test.py,sha256=kosW60A4HnBBT3sOHxWCl_cixpbO1kmsjgNuNU
 crosshair/conftest.py,sha256=JjUauvXnjERszuS46iskuBRHBx-0uHacwKHeQ-gEQ2c,683
 crosshair/copyext.py,sha256=_SRnS6UrUFl2-CHl8uRIOq-Y0MKYNQTFK132S3Ru34A,5044
 crosshair/copyext_test.py,sha256=VSIoVeqAf18g2RNuLTbyNWJiMBgzHeab7LNX1KHCWZU,2182
-crosshair/core.py,sha256=uVUz_SUye6EeV9EKGSnBFfK9G0MaZ2kLCjFUqorGR_c,65380
+crosshair/core.py,sha256=bUkWzbyhEvk24_UJ7tYo489ccq-Q6V0Pnpj4aY165qg,65497
 crosshair/core_and_libs.py,sha256=U9GDCBE9Ecxy7T7bmJT7IYiQTdY1C8qbcoIoMMocu5U,4112
 crosshair/core_regestered_types_test.py,sha256=3o1GrtjCEWSW-paPp5-yVdE2K1_ZIviGCff7KVZ0VS0,2181
 crosshair/core_test.py,sha256=bHpq_OcUsVWFWGnsCUX4AEM22vLfoCzCsPaEnsbAzYc,33490
@@ -39,12 +39,12 @@ crosshair/opcode_intercept.py,sha256=RGcwx4f5-KKjY2C3Do4mBm4S8rEpn6nWtOQvaSKQnoM
 crosshair/opcode_intercept_test.py,sha256=giJ9HK0jJ4r41epJMZ4PPT6-qn8nqDjS-900ULxIlLM,9545
 crosshair/options.py,sha256=y3lYP5AfwkHFXjF7zl0kUrTH1_C5u1DMo_yAH_mivm8,6993
 crosshair/options_test.py,sha256=eTlaTqNb29I3ZyyV0yCq_kEeE441l4xh-jKF_W6cWqs,389
-crosshair/patch_equivalence_test.py,sha256=JsJkKSjjyXynTAnZBGIJsFN_vyoiZfNTeiq5FjRVXIE,2579
+crosshair/patch_equivalence_test.py,sha256=2obUF4jZWlF_HBawn6uOb53XuD7qNRiX6f8Y1A5-fUI,2655
 crosshair/path_cover.py,sha256=rHWsTLVr-LR5rEBu18xRSJbpWk3ZTl11OG_QOkgRrxI,6915
 crosshair/path_cover_test.py,sha256=DFB_fIC2d1waNfyUAP4wVv-hdbNkHAKRxgBcftxcKLY,4227
 crosshair/path_search.py,sha256=5gsiY41aMcTnO5XONgjsnVulWbRIw0mYcpmRYedqORo,5749
 crosshair/path_search_test.py,sha256=xhY7qmLRaDMnueFgokJaDKOufs2fhJdqU6okM4hWgF4,1744
-crosshair/pathing_oracle.py,sha256=Q73EBnlO_Ousa8s6OiZbaoDdeEAOTUogRjqpa4RDg9Y,9538
+crosshair/pathing_oracle.py,sha256=XmCva1sjBbQfzeQZ01UozNP-Mbdak3PepaPqQPIuylM,9453
 crosshair/pure_importer.py,sha256=yA1HkM3Jykt2w00OQALwxi5Gt_FFa-NU9JRiBcDS2DM,905
 crosshair/pure_importer_test.py,sha256=Tp4RitGWUhtLhNxOlJkdz43WyXZLynARbCcY4lzG7Bk,437
 crosshair/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -54,18 +54,18 @@ crosshair/simplestructs.py,sha256=DQu4LVS5KLEIH3-z_DEg0LU3VxovKE_JRjHvBdGCzb4,35
 crosshair/simplestructs_test.py,sha256=XizES1bMUx3PAMsGw6zZIzhu-ZHaP1HUVorTI1w21_s,8922
 crosshair/smtlib.py,sha256=WJnOtT4xSDsllQ7o-WEL_-eqJrujB9KMkMO9cVNa5YA,713
 crosshair/smtlib_test.py,sha256=uR_X_32tqPjCp9gzExY_5AZIqw8wdOrIJ9vGONJmmOg,525
-crosshair/statespace.py,sha256=6P9KZzBqhCZeDD7ra23iRU5W2E5ry0sH2diSqG7fkm8,42959
+crosshair/statespace.py,sha256=gkbYlMuJwQU7UuzIJoZom3Hs50OMTkfdVGoenwRCDzY,42377
 crosshair/statespace_test.py,sha256=Z9YENLVeEMEc0SvDt1gGYvNZuleu4lOMq4kC9kaagaw,2704
 crosshair/stubs_parser.py,sha256=tJwChs8--UZjCtkshijzA-1K2tiZ2-mgpea_hJIdVJI,14592
 crosshair/stubs_parser_test.py,sha256=eUIy8E7LoR7tmUy3dkZEOQqDWFq7hoqbIBdJ_nwkeIE,1271
-crosshair/test_util.py,sha256=O2Uqvv4deGh_OEX3npy3WnceP89kH1lo1ySl3UYKrwE,10378
-crosshair/test_util_test.py,sha256=0A82V5O1bvg-cbc7GsaeWM6lzVSKF45cQRNJU9v1fzQ,528
+crosshair/test_util.py,sha256=jtFZdNMR9cp-7sGmhDDfzeeIrWQAenyF4QRDE-kXdwA,10696
+crosshair/test_util_test.py,sha256=6S3BfmWB4YM4z6D7rhc4cCtV7VAstN7L_STP1iT0QgU,969
 crosshair/tracers.py,sha256=kMUixlsd5zMjfXt_eNn7HS86yIu6c5tP45Cold76yWs,17662
 crosshair/tracers_test.py,sha256=73lIgNCVf4QhJo5uzoonH55vKWoYDffeYb8AdCZEQHw,3424
-crosshair/type_repo.py,sha256=TTgWOb-8yzTKn4ptZQWWGAot6tJn9T92r0DHGjhs5N4,4800
+crosshair/type_repo.py,sha256=9gmajt6r1XYm4OAObA4yYh2FsZIRDbxFVSa95CF3Hyg,4815
 crosshair/unicode_categories.py,sha256=JWGv47BSq1Cj-uYSWBQ4kYlsIPlmcPvaUxO6YG8d9I0,334108
 crosshair/unicode_categories_test.py,sha256=KZ2OKOSMALmFp1BQbWj1-x6Ek5Iv2byxF4ytx2mN7LU,766
-crosshair/util.py,sha256=26cnzKvzWVfVs-azDEyy7Mu-wZunDDo_6BnC2VkYVRo,22858
+crosshair/util.py,sha256=UlZYLXChOyUpjuMWQxr_nLDLwhOrDo0Lxkco06IG2m4,22954
 crosshair/util_test.py,sha256=fIc3TeMbyu9nI430_gGbUrqXhPJ5wl9TxWAtIGgEL4s,4849
 crosshair/watcher.py,sha256=A8ywSNPUY6Y4BHVO51dGM18nQcwGYx_kbBEwIOMTzF4,10355
 crosshair/watcher_test.py,sha256=TCOdXmdGZ3NJ59X_w7SRVqiJY-BL2tUqyXK-3ql1d6s,2871
@@ -100,7 +100,7 @@ crosshair/libimpl/binascii_ch_test.py,sha256=qWAYU1Sid3muwYL8pvVoCsMQtm5t3J8jFto
 crosshair/libimpl/binascii_test.py,sha256=Yg37_B-eywcLq7EbsJZR3BUYYF6A1PGxE4qsmeBMyXg,2037
 crosshair/libimpl/binasciilib.py,sha256=kBFH5-W_q1gCTC-wusSq0cAsUsB_xOUpcW0XQbLzkSQ,5220
 crosshair/libimpl/bisectlib_test.py,sha256=rVpcalZ4g3xr_b6z1Bv2FU1N07vPZyWhU9_CPzC8sBk,776
-crosshair/libimpl/builtinslib.py,sha256=rZGm31Z5g7OzI_Orpp-haAwxWhnhrhlOBtbll2XkKVE,176713
+crosshair/libimpl/builtinslib.py,sha256=oW9VY8DBOOouWmw6tjvVZp01-GFZ7aFwr_BW4EM3c7Y,176755
 crosshair/libimpl/builtinslib_ch_test.py,sha256=Do8kWNgfosLfI3yzZvTZ3ceuKTF0axN1ckkNZyn4ozE,31685
 crosshair/libimpl/builtinslib_test.py,sha256=yqNE0027NV7-5l9JI-YdsZ8_TPx4F6kOrYxA5Czu2XQ,94322
 crosshair/libimpl/codecslib.py,sha256=cvpCbieFRB4BdfLqmKeJzpvm35qZ0ONqtilXPmN8OWI,2754
@@ -118,7 +118,7 @@ crosshair/libimpl/decimallib_ch_test.py,sha256=8iQpb1c0-TNqtY4EznYkgAGnBV2uOitFj
 crosshair/libimpl/decimallib_test.py,sha256=gbLoEtgpkq6Xod-9Am18mTpVH1VY_cZHvktS4_z2yQ4,2314
 crosshair/libimpl/encodings_ch_test.py,sha256=jZM2XqiGd-40kDiC1YSlDoQafRrbtx6BBBeHTIRx3TE,2596
 crosshair/libimpl/fractionlib.py,sha256=lGqUcl5S9lPC18pKP8Ihzirmgn8hf2QNPvdZejzK8IM,474
-crosshair/libimpl/fractionlib_test.py,sha256=fl4Ka9m5UV_-pYtsC0JDQWJLpPk4GhZapArRDLub7Wc,1695
+crosshair/libimpl/fractionlib_test.py,sha256=gl9PIZFoKyA10KMhfmA4SSK1i1y2yUO_IDvxIr-8lBc,2437
 crosshair/libimpl/functoolslib.py,sha256=szPJ4ZB0CevfCxMBvVfD_3RX-BwDp0Sv5YchWncmnu4,811
 crosshair/libimpl/functoolslib_test.py,sha256=OSeY-C9zYhFMfDHJ9QNaXxx6sVJ-CLOgrYIyXBl-vvk,1154
 crosshair/libimpl/hashliblib.py,sha256=0s4yx2l-hNkqWEd1Xbmxf-2w_E3LmjHn0SShni_r_-8,1264
@@ -167,9 +167,9 @@ crosshair/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 crosshair/tools/check_help_in_doc.py,sha256=An-2EJ0_Xr-Szo431AoEgJafoFWwnPl8HoT4bi86dd8,8499
 crosshair/tools/check_init_and_setup_coincide.py,sha256=f4TvPg1Q3C_BQYtGgPfY_fqxo_ZTeU7QCy7WwQjaIlA,3621
 crosshair/tools/generate_demo_table.py,sha256=qm4ZUXjUBKkVZ3bVVK9h6dJMDKYme8zMl-7at_aG7b0,3958
-crosshair_tool-0.0.88.dist-info/licenses/LICENSE,sha256=qQLSJN48eqvalILMr3uzkg0p74FtK7WSwkux-0twy-s,4552
-crosshair_tool-0.0.88.dist-info/METADATA,sha256=cUC5UYnQOq1z8CxQn-MECRuIECyUW5H04tHwBzKJN64,6871
-crosshair_tool-0.0.88.dist-info/WHEEL,sha256=Q3uEVTFw-CqGed7ywmQZcdvBC5FiRV941NvAhTjjkOQ,95
-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.93.dist-info/licenses/LICENSE,sha256=qQLSJN48eqvalILMr3uzkg0p74FtK7WSwkux-0twy-s,4552
+crosshair_tool-0.0.93.dist-info/METADATA,sha256=wU-Na0XKBWSJJwBqDh4EsyZzqsW21lerfZqHpKXYIs8,6923
+crosshair_tool-0.0.93.dist-info/WHEEL,sha256=Q3uEVTFw-CqGed7ywmQZcdvBC5FiRV941NvAhTjjkOQ,95
+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,,