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

crosshair/core.py

@@ -127,6 +127,14 @@ from crosshair.util import (
     warn,
 )
 
+if sys.version_info >= (3, 12):
+    from typing import TypeAliasType
+
+    TypeAliasTypes = (TypeAliasType,)
+else:
+    TypeAliasTypes = ()
+
+
 _MISSING = object()
 
 
@@ -667,6 +675,11 @@ def proxy_for_type(
         typ = normalize_pytype(typ)
         origin = origin_of(typ)
         type_args = type_args_of(typ)
+        while isinstance(origin, TypeAliasTypes):
+            type_var_bindings = dict(zip(origin.__type_params__, type_args))
+            unified = dynamic_typing.realize(origin.__value__, type_var_bindings)
+            return proxy_for_type(unified, varname, allow_subtypes)
+
         # special cases
         if isinstance(typ, type) and issubclass(typ, enum.Enum):
             enum_values = list(typ)  # type:ignore

crosshair/core_test.py

@@ -5,6 +5,7 @@ import re
 import sys
 import time
 from typing import *
+from unittest import skipIf
 
 import pytest  # type: ignore
 
@@ -28,7 +29,7 @@ from crosshair.core_and_libs import (
     standalone_statespace,
 )
 from crosshair.fnutil import FunctionInfo, walk_qualname
-from crosshair.libimpl.builtinslib import SymbolicInt
+from crosshair.libimpl.builtinslib import LazyIntSymbolicStr, SymbolicInt
 from crosshair.options import DEFAULT_OPTIONS, AnalysisOptionSet
 from crosshair.statespace import (
     CANNOT_CONFIRM,
@@ -735,6 +736,29 @@ def test_newtype() -> None:
     assert isinstance(x, SymbolicInt)
 
 
+@skipIf(sys.version_info < (3, 12), "type statements added in 3.12")
+def test_type_statement() -> None:
+    env: dict[str, Any] = {}
+    exec("type MyIntNew = int\n", env)
+    assert "MyIntNew" in env
+    MyIntNew = env["MyIntNew"]
+    with standalone_statespace:
+        x = proxy_for_type(MyIntNew, "x")
+    assert isinstance(x, SymbolicInt)
+
+
+@skipIf(sys.version_info < (3, 12), "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)
+    assert "Pair" in env
+    Pair = env["Pair"]
+    with standalone_statespace:
+        x = proxy_for_type(Pair[int, str], "x")
+    assert isinstance(x[0], LazyIntSymbolicStr)
+    assert isinstance(x[1], SymbolicInt)
+
+
 def test_container_typevar() -> None:
     T = TypeVar("T")
 

crosshair/dynamic_typing.py

@@ -1,4 +1,5 @@
 import collections.abc
+import sys
 import typing
 from inspect import Parameter, Signature
 from itertools import zip_longest
@@ -223,21 +224,41 @@ def get_bindings_from_type_arguments(pytype: Type) -> Mapping[object, type]:
     return {}
 
 
-def realize(pytype: Type, bindings: Mapping[object, type]) -> object:
-    if typing_inspect.is_typevar(pytype):
-        return bindings[pytype]
-    if not hasattr(pytype, "__args__"):
-        return pytype
-    newargs: List = []
-    for arg in pytype.__args__:  # type:ignore
-        newargs.append(realize(arg, bindings))
-    # print('realizing pytype', repr(pytype), 'newargs', repr(newargs))
-    pytype_origin = origin_of(pytype)
-    if not hasattr(pytype_origin, "_name"):
-        pytype_origin = getattr(typing, pytype._name)  # type:ignore
-    if pytype_origin is Callable:  # Callable args get flattened
-        newargs = [newargs[:-1], newargs[-1]]
-    return pytype_origin.__getitem__(tuple(newargs))
+if sys.version_info >= (3, 9):
+
+    def realize(pytype: Type, bindings: Mapping[object, type]) -> object:
+        if typing_inspect.is_typevar(pytype):
+            return bindings[pytype]
+        if not hasattr(pytype, "__args__"):
+            return pytype
+        newargs: List = []
+        for arg in pytype.__args__:  # type:ignore
+            newargs.append(realize(arg, bindings))
+        pytype_origin = origin_of(pytype)
+        if pytype_origin in (
+            collections.abc.Callable,
+            typing.Callable,
+        ):  # Callable args get flattened
+            newargs = [newargs[:-1], newargs[-1]]
+        return pytype_origin.__class_getitem__(tuple(newargs))
+
+else:
+
+    def realize(pytype: Type, bindings: Mapping[object, type]) -> object:
+        if typing_inspect.is_typevar(pytype):
+            return bindings[pytype]
+        if not hasattr(pytype, "__args__"):
+            return pytype
+        newargs: List = []
+        for arg in pytype.__args__:  # type:ignore
+            newargs.append(realize(arg, bindings))
+        # print('realizing pytype', repr(pytype), 'newargs', repr(newargs))
+        pytype_origin = origin_of(pytype)
+        if not hasattr(pytype_origin, "_name"):
+            pytype_origin = getattr(typing, pytype._name)  # type:ignore
+        if pytype_origin is Callable:  # Callable args get flattened
+            newargs = [newargs[:-1], newargs[-1]]
+        return pytype_origin.__getitem__(tuple(newargs))
 
 
 def isolate_var_params(

crosshair/dynamic_typing_test.py

@@ -1,4 +1,5 @@
 import collections
+import sys
 from inspect import Parameter, Signature, signature
 from typing import (
     Callable,
@@ -60,7 +61,12 @@ def test_typedicts():
 def test_typevars():
     bindings = collections.ChainMap()
     assert unify(Tuple[int, str, List[int]], Tuple[int, _T, _U], bindings)
-    assert realize(Mapping[_U, _T], bindings) == Mapping[List[int], str]
+
+    ret = realize(Mapping[_U, _T], bindings)
+    if sys.version_info >= (3, 9):
+        assert ret == collections.abc.Mapping[List[int], str]
+    else:
+        assert ret == Mapping[List[int], str]
 
 
 def test_bound_vtypears():
@@ -79,7 +85,13 @@ def test_callable():
 
     assert not unify(Callable[[List], bool], Callable[[Iterable], bool], bindings)
     assert unify(Callable[[int, _T], List[int]], Callable[[int, str], _U], bindings)
-    assert realize(Callable[[_U], _T], bindings) == Callable[[List[int]], str]
+    if sys.version_info >= (3, 9):
+        assert (
+            realize(Callable[[_U], _T], bindings)
+            == collections.abc.Callable[[List[int]], str]
+        )
+    else:
+        assert realize(Callable[[_U], _T], bindings) == Callable[[List[int]], str]
 
 
 def test_plain_callable():
@@ -131,7 +143,10 @@ class Pair(Generic[_U, _T]):
 def test_bindings_from_type_arguments():
     var_mapping = get_bindings_from_type_arguments(Pair[int, str])
     assert var_mapping == {_U: int, _T: str}
-    assert realize(List[_U], var_mapping) == List[int]
+    if sys.version_info >= (3, 9):
+        assert realize(List[_U], var_mapping) == list[int]
+    else:
+        assert realize(List[_U], var_mapping) == List[int]
 
 
 def test_intersect_signatures_basic():

crosshair/examples/check_examples_test.py

@@ -24,7 +24,7 @@ def extract_linenums(text: str) -> List[int]:
 
 def find_examples() -> Iterable[Path]:
     examples_dir = pathlib.Path(os.path.realpath(__file__)).parent
-    for path in sorted(examples_dir.glob("**/*.py")):
+    for path in sorted(examples_dir.glob("*/**/*.py")):
         if path.stem != "__init__":
             yield path
 

crosshair/libimpl/builtinslib.py

@@ -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())
 

crosshair/main.py

@@ -860,16 +860,24 @@ def check(
     if isinstance(entities, int):
         return entities
     full_options = DEFAULT_OPTIONS.overlay(report_verbose=False).overlay(options)
-    for entity in entities:
-        debug("Check ", getattr(entity, "__name__", str(entity)))
-        for message in run_checkables(analyze_any(entity, options)):
-            line = describe_message(message, full_options)
-            if line is None:
-                continue
-            stdout.write(line + "\n")
-            debug("Traceback for output message:\n", message.traceback)
-            if message.state > MessageType.PRE_UNSAT:
-                any_problems = True
+    checkables = [c for e in entities for c in analyze_any(e, options)]
+    if not checkables:
+        extra_help = ""
+        if full_options.analysis_kind == [AnalysisKind.asserts]:
+            extra_help = "\nHINT: Ensure that your functions to analyze lead with assert statements."
+        print(
+            "WARNING: Targets found, but contain no checkable functions." + extra_help,
+            file=stderr,
+        )
+
+    for message in run_checkables(checkables):
+        line = describe_message(message, full_options)
+        if line is None:
+            continue
+        stdout.write(line + "\n")
+        debug("Traceback for output message:\n", message.traceback)
+        if message.state > MessageType.PRE_UNSAT:
+            any_problems = True
     return 1 if any_problems else 0
 
 

crosshair/main_test.py

@@ -251,19 +251,28 @@ def test_no_args_prints_usage(root):
     assert re.search(r"^usage", out)
 
 
-def DISABLE_TODO_test_assert_mode_e2e(root):
+def test_assert_mode_e2e(root, capsys: pytest.CaptureFixture[str]):
     simplefs(root, ASSERT_BASED_FOO)
-    try:
-        sys.stdout = io.StringIO()
-        exitcode = unwalled_main(["check", root / "foo.py", "--analysis_kind=asserts"])
-    finally:
-        out = sys.stdout.getvalue()
-        sys.stdout = sys.__stdout__
-    assert exitcode == 1
+    exitcode = unwalled_main(["check", str(root / "foo.py"), "--analysis_kind=asserts"])
+    (out, err) = capsys.readouterr()
+    assert err == ""
     assert re.search(
-        r"foo.py\:8\: error\: AssertionError\:  when calling foofn\(x \= 100\)", out
+        r"foo.py\:8\: error\: AssertionError\:  when calling foofn\(100\)", out
     )
     assert len([ls for ls in out.split("\n") if ls]) == 1
+    assert exitcode == 1
+
+
+def test_assert_without_checkable(root, capsys: pytest.CaptureFixture[str]):
+    simplefs(root, SIMPLE_FOO)
+    exitcode = unwalled_main(["check", str(root / "foo.py"), "--analysis_kind=asserts"])
+    (out, err) = capsys.readouterr()
+    assert (
+        err
+        == "WARNING: Targets found, but contain no checkable functions.\nHINT: Ensure that your functions to analyze lead with assert statements.\n"
+    )
+    assert out == ""
+    assert exitcode == 0
 
 
 def test_directives(root):

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

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

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

@@ -1,5 +1,5 @@
 _crosshair_tracers.cpython-38-x86_64-linux-gnu.so,sha256=I2PQ2mjtjrfVX3uIISbP3TZ2i1ZIigIgZIWJxRFSX2Q,75984
-crosshair/__init__.py,sha256=LfHa3bjHbl9WlLnVFSn-2R3qe0yEptc8-0Edze71rmo,936
+crosshair/__init__.py,sha256=nR2D8DuGMw_J17BMCTn9eHoipZzO7JmRusDfFoLt41k,936
 crosshair/__main__.py,sha256=zw9Ylf8v2fGocE57o4FqvD0lc7U4Ld2GbeCGxRWrpqo,252
 crosshair/_mark_stacks.h,sha256=j86qubOUvVhoR19d74iQ084RrTEq8M6oT4wJsGQUySY,28678
 crosshair/_preliminaries_test.py,sha256=r2PohNNMfIkDqsnvI6gKlJTbwBaZA9NQJueQfJMN2Eo,504
@@ -16,14 +16,14 @@ 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=YegFbe3RMJwxHCadhJ42gUJjL9mICaLAE_Dmb1-lsK4,63750
+crosshair/core.py,sha256=7CHbmWvCVK2MlKXJUUe3eILPWGZniF8qXkBJNDkU4qg,64168
 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
+crosshair/core_test.py,sha256=540ASl3zOQf3AnZORGJus4PMYHP5YM15zTWhNI16Dew,33009
 crosshair/diff_behavior.py,sha256=_5X_pTN0_-rSPrh8dfpODJG_phFMn7fWc-_zLgO3UTk,11253
 crosshair/diff_behavior_test.py,sha256=ckK3HScFrmRRZdyq1iCmkwToksMJG2UVUjABnfnSwCM,7242
-crosshair/dynamic_typing.py,sha256=jbI9FXv5-WXREQjeDtlDQladv-xCW21TUOM3qErJaJ4,11998
-crosshair/dynamic_typing_test.py,sha256=oyg94OXjF_2jNFy33UJjkfWnDXKnM4or2TXbxrOqOQs,5478
+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
 crosshair/enforce_test.py,sha256=C6CQ4P1FjkdIJeJg3aJynp1iLDCE6BFCEVtSqXbvmQk,4665
 crosshair/fnutil.py,sha256=X80bD2Lh4QAh-rF561r3JRxjxcuZepF3hJaxaj1GG9s,13123
@@ -31,10 +31,10 @@ crosshair/fnutil_test.py,sha256=wXtfIxAupRm0KUzKob8luEsNI4YegBQUfwz7msWbfHY,2186
 crosshair/fuzz_core_test.py,sha256=q7WsZt6bj5OJrXaVsT3JaRYWWnL8X_1flSfty4Z7CcA,16903
 crosshair/lsp_server.py,sha256=j7SX4pdVwa2MrtkNIjajLilzl5CZTY6PrBQsa26cdNo,8670
 crosshair/lsp_server_test.py,sha256=7LO1Qqxkper3Xt2krgOlGqF1O_uDObo76o4FZbIqykY,969
-crosshair/main.py,sha256=6RXjj1FIyBK6i6xOx-bs-CsHLgOZcc9hL3U1JRwxpA0,34378
-crosshair/main_test.py,sha256=eEoK4LHKSaX-6iJx3tAVbwCaBJc0ri3VoCPtLD5em2U,14424
-crosshair/objectproxy.py,sha256=Uc6mNkJBInvETGWBHI10GSNEIrBYDIxlAZ30M3PAIhQ,8935
-crosshair/objectproxy_test.py,sha256=KykRJLSHCDA7jb_XPBDhXHnS6Q1fG4oIJ579CeSEz3k,567
+crosshair/main.py,sha256=TkaOr39tMV9ZHQXgfJobKFEVW60XpHUqdY520nMIWw8,34659
+crosshair/main_test.py,sha256=2xpgNqog__XcYffGcwPeEEmr0Vy4EgVZE8GCAjQnE8U,14834
+crosshair/objectproxy.py,sha256=1cO_ApA0AKPfCRu6MIsxUOKUUEGn0b1U4IHxTC4nDGI,9790
+crosshair/objectproxy_test.py,sha256=UJuO_jUt8_OEUtgQWyhlekPOdvtM8IQ5M9I_1AqXPWM,1081
 crosshair/opcode_intercept.py,sha256=z4Yb9prYE2UK21AxhjAeXyXAk5IriDuCSSCeNhbDu2A,21880
 crosshair/opcode_intercept_test.py,sha256=Si3rJQR5cs5d4uB8uwE2K8MjP8rE1a4yHkjXzhfS10A,9241
 crosshair/options.py,sha256=htQNgnrpoRjSNq6rfLBAF8nos-NNIwmP6tQYyI8ugsM,6775
@@ -72,7 +72,7 @@ crosshair/watcher_test.py,sha256=Ef1YSwy68wWPR5nPjwvEKPqxltI9pE9lTbnesmDy3Bk,276
 crosshair/z3util.py,sha256=AkslxCSfzgSni6oWXUckWihWn3LuceQycR0X3D3ZhD8,1759
 crosshair/z3util_test.py,sha256=CZovn4S9mYcG_yQegcxm80VHrvUdvNei0gvGTF9TOrk,173
 crosshair/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-crosshair/examples/check_examples_test.py,sha256=CPKG0lKgxpPSjrEf02bBTAivQZwrDyFNTBU-4sSRrr0,4060
+crosshair/examples/check_examples_test.py,sha256=pFZRUi_yubIOaIZ_n7KkrG_qCKyHZnzcL5_y0NFqZKM,4062
 crosshair/examples/PEP316/__init__.py,sha256=LdmvJx2cbzC3iip3NwtT0Ds2v99l3KXl1q9Kc0TmCWE,34
 crosshair/examples/PEP316/bugs_detected/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 crosshair/examples/PEP316/bugs_detected/getattr_magic.py,sha256=vZ6pWnBsSE641rzNx55iB8lLOI4zB0nXkUU1WxtD0RI,319
@@ -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=UU2WDnQbPQMIETjvKfJlDXAFYyAXcRVvGt4SFYs-Jgk,171663
+crosshair/libimpl/builtinslib.py,sha256=Mr3bDiM6pQhLh5lkMoa4UYM3Hi4A_xm0dLteYCohZzQ,171289
 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
@@ -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.93.dist-info/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
-crosshair_tool-0.0.93.dist-info/METADATA,sha256=soS7KCkL9yyhosaHwR1ROIhEijfFIgqDZtgu-0zPadA,6558
-crosshair_tool-0.0.93.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
-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.95.dist-info/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
+crosshair_tool-0.0.95.dist-info/METADATA,sha256=K8KjIbicUtnjDKfPB4UiIlxtYp295WZQ4ZTheC0iqaA,6558
+crosshair_tool-0.0.95.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
+crosshair_tool-0.0.95.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
+crosshair_tool-0.0.95.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
+crosshair_tool-0.0.95.dist-info/RECORD,,