crosshair-tool 0.0.94__cp38-cp38-musllinux_1_2_x86_64.whl → 0.0.96__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.94"  # Do not forget to update in setup.py!
+__version__ = "0.0.96"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

crosshair/condition_parser_test.py

@@ -1,8 +1,6 @@
 import inspect
 import json
 import sys
-import textwrap
-import unittest
 from typing import List
 
 import pytest

crosshair/core.py

@@ -377,7 +377,8 @@ def with_symbolic_self(symbolic_cls: Type, fn: Callable):
             elif any(isinstance(a, CrossHairValue) for a in args) or (
                 kwargs and any(isinstance(a, CrossHairValue) for a in kwargs.values())
             ):
-                self = symbolic_cls._smt_promote_literal(self)
+                # NOTE: _ch_create_from_literal is suppoerted for very few types right now
+                self = symbolic_cls._ch_create_from_literal(self)
                 target_fn = getattr(symbolic_cls, fn.__name__)
             else:
                 args = map(realize, args)

crosshair/core_test.py

@@ -5,7 +5,6 @@ import re
 import sys
 import time
 from typing import *
-from unittest import skipIf
 
 import pytest  # type: ignore
 
@@ -736,7 +735,7 @@ def test_newtype() -> None:
     assert isinstance(x, SymbolicInt)
 
 
-@skipIf(sys.version_info < (3, 12), "type statements added in 3.12")
+@pytest.mark.skipif(sys.version_info < (3, 12), reason="type statements added in 3.12")
 def test_type_statement() -> None:
     env: dict[str, Any] = {}
     exec("type MyIntNew = int\n", env)
@@ -747,7 +746,7 @@ def test_type_statement() -> None:
     assert isinstance(x, SymbolicInt)
 
 
-@skipIf(sys.version_info < (3, 12), "type statements added in 3.12")
+@pytest.mark.skipif(sys.version_info < (3, 12), reason="type statements added in 3.12")
 def test_parameterized_type_statement() -> None:
     env: dict[str, Any] = {}
     exec("type Pair[A, B] = tuple[B, A]\n", env)

crosshair/diff_behavior_test.py

@@ -1,5 +1,3 @@
-import sys
-import unittest
 from typing import Callable, List, Optional
 
 from crosshair.diff_behavior import (

crosshair/libimpl/builtinslib.py

@@ -346,7 +346,7 @@ class AtomicSymbolicValue(SymbolicValue):
         raise CrossHairInternal(f"_pytype not implemented in {cls}")
 
     @classmethod
-    def _smt_promote_literal(cls, val: object) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal: object) -> Optional[z3.ExprRef]:
         raise CrossHairInternal(f"_smt_promote_literal not implemented in {cls}")
 
     @classmethod
@@ -1120,7 +1120,7 @@ class SymbolicBool(SymbolicIntable, AtomicSymbolicValue):
         return bool
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, bool):
             return z3.BoolVal(literal)
         return None
@@ -1189,7 +1189,7 @@ class SymbolicInt(SymbolicIntable, AtomicSymbolicValue):
         return int
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, int):
             return z3IntVal(literal)
         return None
@@ -1410,7 +1410,7 @@ class PreciseIeeeSymbolicFloat(SymbolicFloat):
         return _PRECISE_IEEE_FLOAT_SORT
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, float):
             return z3.FPVal(literal, cls._ch_smt_sort())
         return None
@@ -1533,7 +1533,7 @@ class RealBasedSymbolicFloat(SymbolicFloat):
         return z3.RealSort()
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, float) and isfinite(literal):
             return z3.RealVal(literal)
         return None
@@ -2447,7 +2447,7 @@ class SymbolicType(AtomicSymbolicValue, SymbolicValue, Untracable):
         return type
 
     @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
+    def _smt_promote_literal(cls, literal) -> Optional[z3.ExprRef]:
         if isinstance(literal, type):
             return context_statespace().extra(SymbolicTypeRepository).get_type(literal)
         return None
@@ -2611,18 +2611,6 @@ class SymbolicObject(ObjectProxy, CrossHairValue, Untracable):
             return object()
         return proxy_for_type(pytype, varname, allow_subtypes=False)
 
-    def _wrapped(self):
-        with NoTracing():
-            inner = _MISSING
-            try:
-                inner = object.__getattribute__(self, "_inner")
-            except AttributeError:
-                pass
-            if inner is _MISSING:
-                inner = self._realize()
-                object.__setattr__(self, "_inner", inner)
-            return inner
-
     def __ch_realize__(self):
         return realize(self._wrapped())
 
@@ -2680,10 +2668,25 @@ class SymbolicCallable:
     __annotations__: dict = {}
 
     def __init__(self, values: list):
+        """
+        A function that will ignore its arguments and produce return values
+        from the list given.
+        If the given list is exhausted, the function will just repeatedly
+        return the final value in the list.
+
+        If `values` is concrete, it must be non-mepty.
+        If `values` is a symbolic list, it will be forced to be non-empty
+        (the caller must enure that's possible).
+        """
         assert not is_tracing()
         with ResumedTracing():
-            if not values:
-                raise IgnoreAttempt
+            has_values = len(values) > 0
+        if isinstance(values, CrossHairValue):
+            space = context_statespace()
+            assert space.is_possible(has_values)
+            space.add(has_values)
+        else:
+            assert has_values
         self.values = values
         self.idx = 0
 
@@ -2707,6 +2710,7 @@ class SymbolicCallable:
         if idx >= len(values):
             return values[-1]
         else:
+            self.idx += 1
             return values[idx]
 
     def __bool__(self):
@@ -3418,6 +3422,26 @@ class AnySymbolicStr(AbcString):
             return "0" * fill_length + self
 
 
+def _unfindable_range(start: Optional[int], end: Optional[int], mylen: int) -> bool:
+    """
+    Emulates some preliminary checks that CPython makes before searching
+    for substrings within some bounds. (in e.g. str.find, str.startswith, etc)
+    """
+    if start is None or start == 0 or start <= -mylen:
+        return False
+
+    # At this point, we know that `start` is defined and points to an index after 0
+    if end is None or end >= mylen:
+        return start > mylen
+
+    # At this point, we know that `end` is defined and points to an index before the end of the string
+    if start < 0:
+        start += mylen
+    if end < 0:
+        end += mylen
+    return end < start
+
+
 class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
     """
     A symbolic string that lazily generates SymbolicInt-based characters as needed.
@@ -3456,10 +3480,8 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
             codepoints = tuple(self._codepoints)
         return "".join(chr(realize(x)) for x in codepoints)
 
-    # This is normally an AtomicSymbolicValue method, but sometimes it's used in a
-    # duck-typing way.
     @classmethod
-    def _smt_promote_literal(cls, val: object) -> Optional[z3.SortRef]:
+    def _ch_create_from_literal(cls, val: object) -> Optional[CrossHairValue]:
         if isinstance(val, str):
             return LazyIntSymbolicStr(list(map(ord, val)))
         return None
@@ -3493,6 +3515,10 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         with NoTracing():
             if not isinstance(i, (Integral, slice)):
                 raise TypeError(type(i))
+            # This could/should? be symbolic by naming all the possibilities.
+            # Note the slice case still must realize the return length.
+            # Especially because we no longer explore realization trees except
+            # as a last resort.
             i = deep_realize(i)
             with ResumedTracing():
                 newcontents = self._codepoints[i]
@@ -3573,11 +3599,15 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
             return any(self.endswith(s, start, end) for s in substr)
         if not isinstance(substr, str):
             raise TypeError
+        substrlen = len(substr)
         if start is None and end is None:
             matchable = self
         else:
             matchable = self[start:end]
-        return matchable[-len(substr) :] == substr
+        if substrlen == 0:
+            return not _unfindable_range(start, end, len(self))
+        else:
+            return matchable[-substrlen:] == substr
 
     def startswith(self, substr, start=None, end=None):
         if isinstance(substr, tuple):
@@ -3587,6 +3617,10 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         if start is None and end is None:
             matchable = self
         else:
+            # Wacky special case: the empty string is findable off the left
+            # side but not the right!
+            if _unfindable_range(start, end, len(self)):
+                return False
             matchable = self[start:end]
         return matchable[: len(substr)] == substr
 
@@ -3627,7 +3661,7 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
             end += mylen
         matchstr = self[start:end] if start != 0 or end is not mylen else self
         if len(substr) == 0:
-            # Add oddity of CPython. We can find the empty string when over-slicing
+            # An oddity of CPython. We can find the empty string when over-slicing
             # off the left side of the string, but not off the right:
             # ''.find('', 3, 4) == -1
             # ''.find('', -4, -3) == 0
@@ -4802,14 +4836,17 @@ def _str_format_map(self, map) -> Union[AnySymbolicStr, str]:
 
 
 def _str_startswith(self, substr, start=None, end=None) -> bool:
-    if not isinstance(self, str):
-        raise TypeError
     with NoTracing():
+        if isinstance(self, LazyIntSymbolicStr):
+            with ResumedTracing():
+                return self.startswith(substr, start, end)
+        elif not isinstance(self, str):
+            raise TypeError
         # Handle native values with native implementation:
         if type(substr) is str:
             return self.startswith(substr, start, end)
         if type(substr) is tuple:
-            if all(type(i) is str for i in substr):
+            if all(type(s) is str for s in substr):
                 return self.startswith(substr, start, end)
         symbolic_self = LazyIntSymbolicStr([ord(c) for c in self])
     return symbolic_self.startswith(substr, start, end)

crosshair/libimpl/builtinslib_ch_test.py

@@ -606,9 +606,14 @@ def check_str_endswith(
     string: str, suffix: str, start: Optional[int], end: Optional[int]
 ) -> ResultComparison:
     """post: _"""
+    # crosshair: max_uninteresting_iterations=100
+
+    for i in (len(string), len(suffix), start, end):
+        if i is not None and abs(i) >= 1:
+            pass
+
     return compare_results(
-        lambda s, *a: s.endswith(*a),
-        string,
+        lambda s, *a, **kw: s.endswith(*a, **kw), string, suffix, start, end
     )
 
 
@@ -825,6 +830,11 @@ def check_str_startswith(
     end: Optional[int],
 ) -> ResultComparison:
     """post: _"""
+    # crosshair: max_uninteresting_iterations=100
+
+    for i in (len(string), len(prefix), start, end):
+        if i is not None and abs(i) >= 1:
+            pass
     return compare_results(
         lambda s, *a, **kw: s.startswith(*a, **kw), string, prefix, start, end
     )

crosshair/libimpl/builtinslib_test.py

@@ -939,6 +939,31 @@ def test_str_replace_method() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_str_startswith(space) -> None:
+    symbolic_char = proxy_for_type(str, "x")
+    symbolic_empty = proxy_for_type(str, "y")
+    with ResumedTracing():
+        space.add(len(symbolic_char) == 1)
+        space.add(len(symbolic_empty) == 0)
+        assert symbolic_char.startswith(symbolic_empty)
+        assert symbolic_char.startswith(symbolic_char)
+        assert symbolic_char.startswith(("foo", symbolic_empty))
+        assert not symbolic_char.startswith(("foo", "bar"))
+        assert symbolic_char.startswith(("", "bar"))
+        assert symbolic_char.startswith("")
+        assert symbolic_char.startswith(symbolic_empty, 1)
+        assert symbolic_char.startswith(symbolic_empty, 1, 1)
+        assert str.startswith(symbolic_char, symbolic_empty)
+        assert "foo".startswith(symbolic_empty)
+        assert not "".startswith(symbolic_char)
+
+        # Yes, the empty string is findable off the left side but not the right
+        assert "x".startswith("", -10, -9)
+        assert symbolic_char.startswith(symbolic_empty, -10, -9)
+        assert not "x".startswith("", 9, 10)
+        assert not symbolic_char.startswith(symbolic_empty, 9, 10)
+
+
 @pytest.mark.demo
 def test_str_index_method() -> None:
     def f(a: str) -> int:
@@ -3134,6 +3159,17 @@ def test_callable_as_bool() -> None:
     check_states(f, CONFIRMED)
 
 
+def test_callable_can_return_different_values(space) -> None:
+    fn = proxy_for_type(Callable[[], int], "fn")
+    with ResumedTracing():
+        first_return = fn()
+        second_return = fn()
+        returns_are_equal = first_return == second_return
+        returns_are_not_equal = first_return != second_return
+    assert space.is_possible(returns_are_equal)
+    assert space.is_possible(returns_are_not_equal)
+
+
 @pytest.mark.smoke
 def test_callable_repr() -> None:
     def f(f1: Callable[[int], int]) -> int:

crosshair/libimpl/collectionslib_test.py

@@ -3,7 +3,7 @@ import sys
 from collections import Counter, defaultdict, deque, namedtuple
 from copy import deepcopy
 from inspect import Parameter, Signature
-from typing import Counter, DefaultDict, Deque, NamedTuple, Tuple
+from typing import Callable, Counter, DefaultDict, Deque, Dict, NamedTuple, Tuple
 
 import pytest
 
@@ -14,7 +14,7 @@ from crosshair.core import (
     realize,
     standalone_statespace,
 )
-from crosshair.libimpl.collectionslib import ListBasedDeque
+from crosshair.libimpl.collectionslib import ListBasedDeque, PureDefaultDict
 from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
 from crosshair.test_util import check_states
 from crosshair.tracers import NoTracing, ResumedTracing
@@ -246,10 +246,10 @@ def test_defaultdict_default_fail(test_list) -> None:
 
 
 def test_defaultdict_default_ok(test_list) -> None:
-    def f(a: DefaultDict[int, int], k1: int, k2: int) -> DefaultDict[int, int]:
+    def f(a: DefaultDict[int, int], k: int) -> DefaultDict[int, int]:
         """
         pre: len(a) == 0 and a.default_factory is not None
-        post: _[k1] == _[k2]
+        post: _[k] == _[k]
         """
         return a
 

crosshair/libimpl/functoolslib.py

@@ -1,4 +1,4 @@
-from functools import _lru_cache_wrapper, partial, reduce
+from functools import _lru_cache_wrapper, partial, reduce, update_wrapper, wraps
 
 from crosshair.core import register_patch
 
@@ -7,7 +7,13 @@ from crosshair.core import register_patch
 
 def _partial(func, *a1, **kw1):
     if callable(func):
-        return partial(lambda *a2, **kw2: func(*a2, **kw2), *a1, **kw1)
+        # We make a do-nothing wrapper to ensure that the tracer has a crack
+        # at this function when it is called.
+        def wrapper(*a2, **kw2):
+            return func(*a2, **kw2)
+
+        update_wrapper(wrapper, func)
+        return partial(wrapper, *a1, **kw1)
     else:
         raise TypeError
 

crosshair/libimpl/functoolslib_test.py

@@ -1,20 +1,36 @@
 import functools
+import inspect
 
 from crosshair.core import proxy_for_type, standalone_statespace
 from crosshair.libimpl.builtinslib import LazyIntSymbolicStr
-from crosshair.tracers import NoTracing
+from crosshair.tracers import NoTracing, ResumedTracing
 
 
-def test_partial():
-    with standalone_statespace as space:
-        with NoTracing():
-            abc = LazyIntSymbolicStr(list(map(ord, "abc")))
-            xyz = LazyIntSymbolicStr(list(map(ord, "xyz")))
+def test_partial(space):
+    abc = LazyIntSymbolicStr(list(map(ord, "abc")))
+    xyz = LazyIntSymbolicStr(list(map(ord, "xyz")))
+    with ResumedTracing():
         joiner = functools.partial(str.join, ",")
         ret = joiner([abc, xyz])
         assert ret == "abc,xyz"
 
 
+def test_partial_is_interceptable(space):
+    x = proxy_for_type(str, "x")
+    y = proxy_for_type(str, "y")
+    with ResumedTracing():
+        joiner = functools.partial(str.startswith, x)
+        # Ensure we don't explode
+        list(map(joiner, ["foo", y]))
+
+
+def test_partial_arg_is_inspectable(space):
+    with ResumedTracing():
+        joiner = functools.partial(str.join, ",")
+        assert isinstance(joiner, functools.partial)
+        assert inspect.getdoc(joiner.func) == inspect.getdoc(str.join)
+
+
 def test_reduce():
     with standalone_statespace as space:
         with NoTracing():

crosshair/objectproxy.py

@@ -10,11 +10,36 @@ from crosshair.tracers import NoTracing
 # (which is BSD licenced)
 #
 
+_MISSING = object()
+
+
+def proxy_inplace_op(proxy, op, *args):
+    my_original_value = proxy._wrapped()
+    my_new_value = op(my_original_value, *args)
+    # We need to return our own identity if (and only if!) the underlying value does.
+    if my_new_value is my_original_value:
+        return proxy
+    else:
+        object.__setattr__(proxy, "_inner", my_new_value)
+        return my_new_value
+
 
 class ObjectProxy:
-    def _wrapped(self):
+    def _realize(self):
         raise NotImplementedError
 
+    def _wrapped(self):
+        with NoTracing():
+            inner = _MISSING
+            try:
+                inner = object.__getattribute__(self, "_inner")
+            except AttributeError:
+                pass
+            if inner is _MISSING:
+                inner = self._realize()
+                object.__setattr__(self, "_inner", inner)
+            return inner
+
     def __get_module__(self) -> str:
         return self._wrapped().__module__
 
@@ -233,40 +258,40 @@ class ObjectProxy:
         return other | self._wrapped()
 
     def __iadd__(self, other):
-        return operator.iadd(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.iadd, other)
 
     def __isub__(self, other):
-        return operator.isub(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.isub, other)
 
     def __imul__(self, other):
-        return operator.imul(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.imul, other)
 
     def __itruediv__(self, other):
-        return operator.itruediv(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.itruediv, other)
 
     def __ifloordiv__(self, other):
-        return operator.iflootdiv(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ifloordiv, other)
 
     def __imod__(self, other):
-        return operator.imod(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.imod, other)
 
     def __ipow__(self, other, *args):
-        return operator.ipow(self._wrapped(), other, *args)
+        return proxy_inplace_op(self, operator.ipow, other, *args)
 
     def __ilshift__(self, other):
-        return operator.ilshift(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ilshift, other)
 
     def __irshift__(self, other):
-        return operator.irshift(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.irshift, other)
 
     def __iand__(self, other):
-        return operator.iand(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.iand, other)
 
     def __ixor__(self, other):
-        return operator.ixor(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ixor, other)
 
     def __ior__(self, other):
-        return operator.ior(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ior, other)
 
     def __neg__(self):
         return -self._wrapped()

crosshair/objectproxy_test.py

@@ -7,12 +7,12 @@ class ObjectWrap(ObjectProxy):
     def __init__(self, obj):
         object.__setattr__(self, "_o", obj)
 
-    def _wrapped(self):
+    def _realize(self):
         return object.__getattribute__(self, "_o")
 
 
 class TestObjectProxy:
-    def test_object_proxy(self) -> None:
+    def test_object_proxy_over_list(self) -> None:
         i = [1, 2, 3]
         proxy = ObjectWrap(i)
         assert i == proxy
@@ -21,3 +21,21 @@ class TestObjectProxy:
         assert [1, 2, 3, 4, 5] == proxy + [5]
         assert [2, 3] == proxy[1:3]
         assert [1, 2, 3, 4] == proxy
+
+    def test_inplace_identities(self) -> None:
+        proxy = ObjectWrap(3.0)
+        orig_proxy = proxy
+        proxy += 1.0
+        assert proxy is not orig_proxy
+        proxy = ObjectWrap([1, 2])
+        orig_proxy = proxy
+        proxy += [3, 4]
+        assert proxy is orig_proxy
+
+    def test_object_proxy_over_float(self) -> None:
+        proxy = ObjectWrap(4.5)
+        proxy //= 2.0
+        assert 2.0 == proxy
+        proxy = ObjectWrap(5.0)
+        proxy /= 2.0
+        assert 2.5 == proxy

crosshair/opcode_intercept.py

@@ -5,7 +5,9 @@ from collections import defaultdict
 from collections.abc import MutableMapping, Set
 from sys import version_info
 from types import CodeType, FrameType
-from typing import Any, Callable, Iterable, Mapping, Tuple, Union
+from typing import Any, Callable, Iterable, List, Mapping, Tuple, Union
+
+from z3 import ExprRef
 
 from crosshair.core import (
     ATOMIC_IMMUTABLE_TYPES,
@@ -83,13 +85,6 @@ class MultiSubscriptableContainer:
             if isinstance(container, Mapping):
                 kv_pairs: Iterable[Tuple[Any, Any]] = container.items()
             else:
-                in_bounds = space.smt_fork(
-                    z3Or(-len(container) <= key.var, key.var < len(container)),
-                    desc=f"index_in_bounds",
-                    probability_true=0.9,
-                )
-                if not in_bounds:
-                    raise IndexError
                 kv_pairs = enumerate(container)
 
             values_by_type = defaultdict(list)
@@ -118,7 +113,7 @@ class MultiSubscriptableContainer:
                 keys_by_value_id[id(cur_value)].append(cur_key)
             for value_type, cur_pairs in values_by_type.items():
                 hypothetical_result = symbolic_for_pytype(value_type)(
-                    "item_at_" + space.uniq(), value_type
+                    "item_" + space.uniq(), value_type
                 )
                 with ResumedTracing():
                     condition_pairs = []
@@ -139,20 +134,17 @@ class MultiSubscriptableContainer:
                         space.add(any([all(pair) for pair in condition_pairs]))
                         return hypothetical_result
 
-            for (value_id, value), probability_true in with_uniform_probabilities(
-                values_by_id.items()
-            ):
+            exprs_and_values: List[Tuple[ExprRef, object]] = []
+            for value_id, value in values_by_id.items():
                 keys_for_value = keys_by_value_id[value_id]
                 with ResumedTracing():
                     is_match = any([key == k for k in keys_for_value])
                 if isinstance(is_match, SymbolicBool):
-                    if space.smt_fork(
-                        is_match.var,
-                        probability_true=probability_true,
-                    ):
-                        return value
+                    exprs_and_values.append((is_match.var, value))
                 elif is_match:
                     return value
+            if exprs_and_values:
+                return space.smt_fanout(exprs_and_values, desc="multi_subscript")
 
             if type(container) is dict:
                 raise KeyError  # ( f"Key {key} not found in dict")

crosshair/path_cover.py

@@ -133,7 +133,11 @@ def path_cover(
     selected: List[PathSummary] = []
     while paths:
         next_best = max(
-            paths, key=lambda p: len(p.coverage.offsets_covered - opcodes_found)
+            paths,
+            key=lambda p: (
+                len(p.coverage.offsets_covered - opcodes_found),  # high coverage
+                -len(p.formatted_args),  # with small input size
+            ),
         )
         cur_offsets = next_best.coverage.offsets_covered
         if coverage_type == CoverageType.OPCODE:

crosshair/pathing_oracle.py

@@ -2,7 +2,7 @@ import math
 from collections import defaultdict
 from typing import Counter, Dict, List, Optional, Sequence, Tuple
 
-from z3 import ExprRef  # type: ignore
+from z3 import ExprRef
 
 from crosshair.statespace import (
     AbstractPathingOracle,
@@ -11,9 +11,11 @@ from crosshair.statespace import (
     NodeLike,
     RootNode,
     SearchTreeNode,
+    StateSpace,
     WorstResultNode,
 )
 from crosshair.util import CrossHairInternal, debug, in_debug
+from crosshair.z3util import z3And, z3Not, z3Or
 
 CodeLoc = Tuple[str, ...]
 
@@ -60,7 +62,8 @@ class CoveragePathingOracle(AbstractPathingOracle):
     # (even just a 10% change could be much larger than it would be otherwise)
     _delta_probabilities = {-1: 0.1, 0: 0.25, 1: 0.9}
 
-    def pre_path_hook(self, root: RootNode) -> None:
+    def pre_path_hook(self, space: StateSpace) -> None:
+        root = space._root
         visits = self.visits
         _delta_probabilities = self._delta_probabilities
 
@@ -213,16 +216,50 @@ class PreferNegativeOracle(AbstractPathingOracle):
         return 0.25
 
 
+class ConstrainedOracle(AbstractPathingOracle):
+    """
+    A pathing oracle that prefers to take a path that satisfies
+    explicitly provided constraints.
+    """
+
+    def __init__(self, inner_oracle: AbstractPathingOracle):
+        self.inner_oracle = inner_oracle
+        self.exprs: List[ExprRef] = []
+
+    def prefer(self, expr: ExprRef):
+        self.exprs.append(expr)
+
+    def pre_path_hook(self, space: StateSpace) -> None:
+        self.space = space
+        self.exprs = []
+        self.inner_oracle.pre_path_hook(space)
+
+    def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
+        self.inner_oracle.post_path_hook(path)
+
+    def decide(
+        self, root, node: "WorstResultNode", engine_probability: Optional[float]
+    ) -> float:
+        # We always run the inner oracle in case it's tracking something about the path.
+        default_probability = self.inner_oracle.decide(root, node, engine_probability)
+        if not self.space.is_possible(z3And(*[node.expr, *self.exprs])):
+            return 0.0
+        elif not self.space.is_possible(z3And(*[z3Not(node.expr), *self.exprs])):
+            return 1.0
+        else:
+            return default_probability
+
+
 class RotatingOracle(AbstractPathingOracle):
     def __init__(self, oracles: List[AbstractPathingOracle]):
         self.oracles = oracles
         self.index = -1
 
-    def pre_path_hook(self, root: "RootNode") -> None:
+    def pre_path_hook(self, space: StateSpace) -> None:
         oracles = self.oracles
         self.index = (self.index + 1) % len(oracles)
         for oracle in oracles:
-            oracle.pre_path_hook(root)
+            oracle.pre_path_hook(space)
 
     def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
         for oracle in self.oracles:

crosshair/pathing_oracle_test.py

@@ -0,0 +1,21 @@
+import random
+
+import z3
+
+from crosshair.pathing_oracle import ConstrainedOracle, PreferNegativeOracle
+from crosshair.statespace import RootNode, SimpleStateSpace, WorstResultNode
+
+
+def test_constrained_oracle():
+    oracle = ConstrainedOracle(PreferNegativeOracle())
+    x = z3.Int("x")
+    root = RootNode()
+    space = SimpleStateSpace()
+    oracle.pre_path_hook(space)
+    oracle.prefer(x >= 7)
+    rand = random.Random()
+    assert oracle.decide(root, WorstResultNode(rand, x < 7, space.solver), None) == 0.0
+    assert oracle.decide(root, WorstResultNode(rand, x >= 3, space.solver), None) == 1.0
+    assert (
+        oracle.decide(root, WorstResultNode(rand, x == 7, space.solver), None) == 0.25
+    )

crosshair/statespace.py

@@ -46,7 +46,7 @@ from crosshair.util import (
     in_debug,
     name_of_type,
 )
-from crosshair.z3util import z3Aassert, z3Not, z3PopNot
+from crosshair.z3util import z3Aassert, z3Not, z3Or, z3PopNot
 
 
 @functools.total_ordering
@@ -219,7 +219,7 @@ class StateSpaceCounter(Counter):
 
 
 class AbstractPathingOracle:
-    def pre_path_hook(self, root: "RootNode") -> None:
+    def pre_path_hook(self, space: "StateSpace") -> None:
         pass
 
     def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
@@ -350,6 +350,7 @@ def solver_is_sat(solver, *exprs) -> bool:
     ret = solver.check(*exprs)
     if ret == z3.unknown:
         debug("Z3 Unknown satisfiability. Reason:", solver.reason_unknown())
+        debug("Call stack at time of unknown sat:", ch_stack())
         if solver.reason_unknown() == "interrupted from keyboard":
             raise KeyboardInterrupt
         if exprs:
@@ -427,7 +428,7 @@ class RootNode(SinglePathNode):
         )
         from crosshair.pathing_oracle import CoveragePathingOracle  # circular import
 
-        self.pathing_oracle = CoveragePathingOracle()
+        self.pathing_oracle: AbstractPathingOracle = CoveragePathingOracle()
         self.iteration = 0
 
 
@@ -704,6 +705,17 @@ def debug_path_tree(node, highlights, prefix="") -> List[str]:
             return [f"{prefix} -> {str(node)} {node.stats()}"]
 
 
+def make_default_solver() -> z3.Solver:
+    """Create a new solver with default settings."""
+    smt_tactic = z3.Tactic("smt")
+    solver = smt_tactic.solver()
+    solver.set("mbqi", True)
+    # turn off every randomization thing we can think of:
+    solver.set("random-seed", 42)
+    solver.set("smt.random-seed", 42)
+    return solver
+
+
 class StateSpace:
     """Holds various information about the SMT solver's current state."""
 
@@ -717,18 +729,12 @@ class StateSpace:
         model_check_timeout: float,
         search_root: RootNode,
     ):
-        smt_tactic = z3.Tactic("smt")
-        self.solver = smt_tactic.solver()
+        self.solver = make_default_solver()
         if model_check_timeout < 1 << 63:
             self.smt_timeout: Optional[int] = int(model_check_timeout * 1000 + 1)
             self.solver.set(timeout=self.smt_timeout)
         else:
             self.smt_timeout = None
-        self.solver.set(mbqi=True)
-        # turn off every randomization thing we can think of:
-        self.solver.set("random-seed", 42)
-        self.solver.set("smt.random-seed", 42)
-        # self.solver.set('randomize', False)
         self.choices_made: List[SearchTreeNode] = []
         self.status_cap: Optional[VerificationStatus] = None
         self.heaps: List[List[Tuple[z3.ExprRef, Type, object]]] = [[]]
@@ -745,7 +751,7 @@ class StateSpace:
         self._deferred_assumptions = []
         assert search_root.iteration is not None
         search_root.iteration += 1
-        search_root.pathing_oracle.pre_path_hook(search_root)
+        search_root.pathing_oracle.pre_path_hook(self)
 
     def add(self, expr) -> None:
         with NoTracing():
@@ -1049,6 +1055,51 @@ class StateSpace:
         self.next_uniq += 1
         return "_{:x}".format(self.next_uniq)
 
+    @assert_tracing(False)
+    def smt_fanout(
+        self,
+        exprs_and_results: Sequence[Tuple[z3.ExprRef, object]],
+        desc: str,
+        weights: Optional[Sequence[float]] = None,
+        none_of_the_above_weight: float = 0.0,
+    ):
+        """Performs a weighted binary search over the given SMT expressions."""
+        exprs = [e for (e, _) in exprs_and_results]
+        final_weights = [1.0] * len(exprs) if weights is None else weights
+        if CROSSHAIR_EXTRA_ASSERTS:
+            if len(final_weights) != len(exprs):
+                raise CrossHairInternal("inconsistent smt_fanout exprs and weights")
+            if not all(0 < w for w in final_weights):
+                raise CrossHairInternal("smt_fanout weights must be greater than zero")
+            if not self.is_possible(z3Or(*exprs)):
+                raise CrossHairInternal(
+                    "no smt_fanout option is possible: " + repr(exprs)
+                )
+            if self.is_possible(z3Not(z3Or(*exprs))):
+                raise CrossHairInternal(
+                    "smt_fanout options are not exhaustive: " + repr(exprs)
+                )
+
+        def attempt(start: int, end: int):
+            size = end - start
+            if size == 1:
+                return exprs_and_results[start][1]
+            mid = (start + end) // 2
+            left_exprs = exprs[start:mid]
+            left_weight = sum(final_weights[start:mid])
+            right_weight = sum(final_weights[mid:end])
+            if self.smt_fork(
+                z3Or(*left_exprs),
+                probability_true=left_weight / (left_weight + right_weight),
+                desc=f"{desc}_fan_size_{size}",
+            ):
+                return attempt(start, mid)
+            else:
+                return attempt(mid, end)
+
+        return attempt(0, len(exprs))
+
+    @assert_tracing(False)
     def smt_fork(
         self,
         expr: Optional[z3.ExprRef] = None,
@@ -1062,6 +1113,14 @@ class StateSpace:
     def defer_assumption(self, description: str, checker: Callable[[], bool]) -> None:
         self._deferred_assumptions.append((description, checker))
 
+    def extend_timeouts(
+        self, constant_factor: float = 0.0, smt_multiple: Optional[float] = None
+    ) -> None:
+        self.execution_deadline += constant_factor
+        if self.smt_timeout is not None and smt_multiple is not None:
+            self.smt_timeout = int(self.smt_timeout * smt_multiple)
+            self.solver.set(timeout=self.smt_timeout)
+
     def detach_path(self, currently_handling: Optional[BaseException] = None) -> None:
         """
         Mark the current path exhausted.
@@ -1075,13 +1134,9 @@ class StateSpace:
             if self.is_detached:
                 debug("Path is already detached")
                 return
-            else:
-                # Give ourselves a time extension for deferred assumptions and
-                # (likely) counterexample generation to follow.
-                self.execution_deadline += 4.0
-                if self.smt_timeout is not None:
-                    self.smt_timeout = self.smt_timeout * 2
-                    self.solver.set(timeout=self.smt_timeout)
+            # Give ourselves a time extension for deferred assumptions and
+            # (likely) counterexample generation to follow.
+            self.extend_timeouts(constant_factor=4.0, smt_multiple=2.0)
             for description, checker in self._deferred_assumptions:
                 with ResumedTracing():
                     check_ret = checker()

crosshair/statespace_test.py

@@ -81,3 +81,19 @@ def test_model_value_to_python_AlgebraicNumRef():
     rt2 = z3.simplify(z3.Sqrt(2))
     assert type(rt2) == z3.AlgebraicNumRef
     model_value_to_python(rt2)
+
+
+def test_smt_fanout(space: SimpleStateSpace):
+    option1 = z3.Bool("option1")
+    option2 = z3.Bool("option2")
+    space.add(z3.Xor(option1, option2))  # Ensure exactly one option can be set
+    exprs_and_results = [(option1, "result1"), (option2, "result2")]
+
+    result = space.smt_fanout(exprs_and_results, desc="choose_one")
+    assert result in ("result1", "result2")
+    if result == "result1":
+        assert space.is_possible(option1)
+        assert not space.is_possible(option2)
+    else:
+        assert not space.is_possible(option1)
+        assert space.is_possible(option2)

{crosshair_tool-0.0.94.dist-info → crosshair_tool-0.0.96.dist-info}/METADATA

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

{crosshair_tool-0.0.94.dist-info → crosshair_tool-0.0.96.dist-info}/RECORD

@@ -1,5 +1,5 @@
 _crosshair_tracers.cpython-38-x86_64-linux-gnu.so,sha256=I2PQ2mjtjrfVX3uIISbP3TZ2i1ZIigIgZIWJxRFSX2Q,75984
-crosshair/__init__.py,sha256=5u1xF74Cj90mIqU71fUSrQIoexYRT3mwC7WOse0f2EQ,936
+crosshair/__init__.py,sha256=pX7dpKGv0frAXPUfHUH9_8CmbQ0ItGRkG9yPi7_uApI,936
 crosshair/__main__.py,sha256=zw9Ylf8v2fGocE57o4FqvD0lc7U4Ld2GbeCGxRWrpqo,252
 crosshair/_mark_stacks.h,sha256=j86qubOUvVhoR19d74iQ084RrTEq8M6oT4wJsGQUySY,28678
 crosshair/_preliminaries_test.py,sha256=r2PohNNMfIkDqsnvI6gKlJTbwBaZA9NQJueQfJMN2Eo,504
@@ -12,16 +12,16 @@ crosshair/auditwall_test.py,sha256=VPcw_OW3nl3BkOZY4wEEtVDyTamdgqD4IjRccI2p5vI,2
 crosshair/codeconfig.py,sha256=GgF-ND8Ha3FysSTQ-JuezHjlhGVBbo5aCJov1Ps3VSE,3959
 crosshair/codeconfig_test.py,sha256=RnC-RnNpr6If4eHmOepDZ33MCmfyhup08dzHKCm5xWA,3350
 crosshair/condition_parser.py,sha256=oquaht026eZUigh2lyaFLXYDbmENdBKjddszx0a-B3w,42647
-crosshair/condition_parser_test.py,sha256=eUQYnVkHewn8qg-XbzcElb0mHkPxPJAX548dPVyxqqk,15532
+crosshair/condition_parser_test.py,sha256=UcgxzqrBLUMScif_RrgHvrhjzWx1KUPgAQOEmfJw7lc,15500
 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=7CHbmWvCVK2MlKXJUUe3eILPWGZniF8qXkBJNDkU4qg,64168
+crosshair/core.py,sha256=nUdmPCcEWxaYawkydj2AJ7VdXe8IIu7hVyDi83Bxwec,64262
 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=540ASl3zOQf3AnZORGJus4PMYHP5YM15zTWhNI16Dew,33009
+crosshair/core_test.py,sha256=P-r-qzHPZ2yLmSBZByYPccJZfxYi2ZCwn9o1mEfzRe8,33019
 crosshair/diff_behavior.py,sha256=_5X_pTN0_-rSPrh8dfpODJG_phFMn7fWc-_zLgO3UTk,11253
-crosshair/diff_behavior_test.py,sha256=ckK3HScFrmRRZdyq1iCmkwToksMJG2UVUjABnfnSwCM,7242
+crosshair/diff_behavior_test.py,sha256=nCpzOjrw0qsYgVhD2iCvKiNAt82SrfUWxWS5mPSE73w,7215
 crosshair/dynamic_typing.py,sha256=ANq42kxSQ5B0STZF3uwOEys_fLCj20cMCCcBH6dbXWo,12758
 crosshair/dynamic_typing_test.py,sha256=8p4NOJ6i9q9mozgCYlZP3VCs-TFMDaE_7W-TyNEse4o,5907
 crosshair/enforce.py,sha256=FsZx3D-KtGrhb8xdAZbPUtwvVmEu8IAn7rwf7tmkrRY,10010
@@ -33,18 +33,19 @@ crosshair/lsp_server.py,sha256=j7SX4pdVwa2MrtkNIjajLilzl5CZTY6PrBQsa26cdNo,8670
 crosshair/lsp_server_test.py,sha256=7LO1Qqxkper3Xt2krgOlGqF1O_uDObo76o4FZbIqykY,969
 crosshair/main.py,sha256=TkaOr39tMV9ZHQXgfJobKFEVW60XpHUqdY520nMIWw8,34659
 crosshair/main_test.py,sha256=2xpgNqog__XcYffGcwPeEEmr0Vy4EgVZE8GCAjQnE8U,14834
-crosshair/objectproxy.py,sha256=Uc6mNkJBInvETGWBHI10GSNEIrBYDIxlAZ30M3PAIhQ,8935
-crosshair/objectproxy_test.py,sha256=KykRJLSHCDA7jb_XPBDhXHnS6Q1fG4oIJ579CeSEz3k,567
-crosshair/opcode_intercept.py,sha256=z4Yb9prYE2UK21AxhjAeXyXAk5IriDuCSSCeNhbDu2A,21880
+crosshair/objectproxy.py,sha256=1cO_ApA0AKPfCRu6MIsxUOKUUEGn0b1U4IHxTC4nDGI,9790
+crosshair/objectproxy_test.py,sha256=UJuO_jUt8_OEUtgQWyhlekPOdvtM8IQ5M9I_1AqXPWM,1081
+crosshair/opcode_intercept.py,sha256=ZNePiOMX5xmREkA-x2t1MuM8fmHPbaogMOmGYn21NzU,21579
 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=eoLaGRvrR9nGUO_ybZ9XsWhs5ejC4IEPd0k-ihG3Nsg,2580
-crosshair/path_cover.py,sha256=wV0Vy8IPDzqXQ2VI8a94FxltS9p-Y1oF17OKePjvpgs,6710
+crosshair/path_cover.py,sha256=TCofZ9D5q7hpEIOnifp53BvY_YyPpZZC-heZw_NuTOQ,6838
 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=3M93zXMorWr8m5c1KM2zGU5X1M3lcV-AIw0lX74eN00,9219
+crosshair/pathing_oracle.py,sha256=PvqX7396SaQK3m-bMpCwBKmHW9SYiioooUWNvmmEqNw,10497
+crosshair/pathing_oracle_test.py,sha256=-6U-n1k6MahHYnQ6lvI9ahFjPr9vUfaUAnFThXR2k78,709
 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,8 +55,8 @@ 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=TVjUhFZU0x72oLPN7-eRu7PoMh1OiQOy0uMASsFb_Qw,41236
-crosshair/statespace_test.py,sha256=LOblIarBbcB9oD_gVR5kK_4P2PWQymVGgJr3wNqP3Fs,2621
+crosshair/statespace.py,sha256=h1un79C-vkyKJ1iLAU4lQlVu3A6YqqbpcrqHGCsTsrg,43442
+crosshair/statespace_test.py,sha256=Eq7LNpjradHyCoCKU91Fxmo9DUpK2Mk4PyxxiAEp-Yk,3211
 crosshair/stubs_parser.py,sha256=rlBTQus5BlZ3Ygg6Xzk5dbQbDtRpv6w9i2HQmGrPVmc,14240
 crosshair/stubs_parser_test.py,sha256=0itTT0Udul_51RJXNv6KB97z44gYze6NZfKJL7yIDzA,1228
 crosshair/test_util.py,sha256=D9-f-DdzJemfAUkQL0cwKxPL8RZ-5gkVmghyRcKlBJI,10367
@@ -100,14 +101,14 @@ 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=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/builtinslib.py,sha256=j275QUgWqnq62immbBqUzlPesOq0t-oTb0C9WL7sIiA,173276
+crosshair/libimpl/builtinslib_ch_test.py,sha256=Fyu2fZLXI-pUaS3gyyM6zMQhsTFdpRCnnp1rXwxKXwk,30854
+crosshair/libimpl/builtinslib_test.py,sha256=jbN2t-zteWqF5TxA7oo4c9UsPrqklBY7wlEt16rxqtI,92230
 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/collectionslib_test.py,sha256=0qmCRQbxfX8vMZLaok1GS68NIocR--RyTVVDqbtHalU,9185
 crosshair/libimpl/copylib.py,sha256=icHJWeFK_tsPSdJhvlS5fVcBwlh0uJh0nzXsRJCGtzs,527
 crosshair/libimpl/copylib_test.py,sha256=VpS9ICvIjzKw0kccsl1v5FB1chHHEIWdOAerEQ_pGMw,705
 crosshair/libimpl/datetimelib.py,sha256=kVWcoHMX-dPW-un7XoEIURfWlVOst6h_JFmjrhFiE1U,79168
@@ -119,8 +120,8 @@ crosshair/libimpl/decimallib_test.py,sha256=393MkVB9-LPcA7JJK6wGAbDyd-YejkjwrXRa
 crosshair/libimpl/encodings_ch_test.py,sha256=0qLsioOuFUZkOjP4J9Wct4CGBaBY8BnHx9paZHnIofI,2513
 crosshair/libimpl/fractionlib.py,sha256=qdbiAHHC480YdKq3wYK_piZ3UD7oT64YfuNclypMUfQ,458
 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/functoolslib.py,sha256=YD0g9UnC4v_wZXR3ekQa2gLrKJnr6dHdYtT9qIMUIGM,1009
+crosshair/libimpl/functoolslib_test.py,sha256=eaT_JWu-C3j8l9ekwDXd2dhPJvuB577T9DuXRohL0fc,1604
 crosshair/libimpl/hashliblib.py,sha256=Ki_cw28OnhZExgKbSoh5GaDbBfNRIOqH7O2aYQJGS3M,1234
 crosshair/libimpl/hashliblib_test.py,sha256=HhPdm5CBTAeqrs41NpCxkexWYWyIf1JiA4cls72WQfM,406
 crosshair/libimpl/heapqlib.py,sha256=TWH55dg-Hi5FRz2oZuXHcBU_xJzHjvhe9YQVvw7ZbfI,1311
@@ -167,9 +168,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.94.dist-info/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
-crosshair_tool-0.0.94.dist-info/METADATA,sha256=TPswJ5qMY4_kuA_pNeu-OiXn22HtZABqBpS9PkMdFx8,6558
-crosshair_tool-0.0.94.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
-crosshair_tool-0.0.94.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
-crosshair_tool-0.0.94.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
-crosshair_tool-0.0.94.dist-info/RECORD,,
+crosshair_tool-0.0.96.dist-info/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
+crosshair_tool-0.0.96.dist-info/METADATA,sha256=UaPu-bjAbWd7htrz1n-BFz0AuNy_NtGKhZklVoNs6x8,6558
+crosshair_tool-0.0.96.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
+crosshair_tool-0.0.96.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
+crosshair_tool-0.0.96.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
+crosshair_tool-0.0.96.dist-info/RECORD,,