crosshair-tool 0.0.56__cp39-cp39-macosx_11_0_arm64.whl → 0.0.100__cp39-cp39-macosx_11_0_arm64.whl

crosshair/libimpl/codecslib.py

@@ -1,8 +1,28 @@
 import codecs
 
 from crosshair import NoTracing, register_patch
-from crosshair.core import realize
+from crosshair.core import class_with_realized_methods, realize, with_realized_args
 from crosshair.libimpl.encodings import codec_search
+from crosshair.util import is_iterable
+
+
+class RealizingCodecInfo(codecs.CodecInfo):
+    def __new__(cls, c: codecs.CodecInfo):
+        encode = with_realized_args(c.encode)
+        decode = with_realized_args(c.decode)
+        streamreader = class_with_realized_methods(c.streamreader)
+        streamwriter = class_with_realized_methods(c.streamwriter)
+        incrementaldecoder = class_with_realized_methods(c.incrementaldecoder)
+        incrementalencoder = class_with_realized_methods(c.incrementalencoder)
+        return codecs.CodecInfo(
+            encode,
+            decode,
+            streamreader=streamreader,
+            streamwriter=streamwriter,
+            incrementalencoder=incrementalencoder,
+            incrementaldecoder=incrementaldecoder,
+            name=c.name,
+        )
 
 
 def _decode(obj, encoding="utf-8", errors="strict"):
@@ -50,7 +70,7 @@ def _lookup(encoding: str) -> codecs.CodecInfo:
         try:
             return codecs.lookup("crosshair_" + encoding)
         except LookupError:
-            return codecs.lookup(encoding)
+            return RealizingCodecInfo(codecs.lookup(encoding))
 
 
 def make_registrations() -> None:

crosshair/libimpl/codecslib_test.py

@@ -1,8 +1,11 @@
 import codecs
+import io
+import sys
 
 import pytest
 
-from crosshair.core_and_libs import ResumedTracing
+from crosshair.core import proxy_for_type
+from crosshair.core_and_libs import ResumedTracing, standalone_statespace
 from crosshair.libimpl.builtinslib import LazyIntSymbolicStr, SymbolicBytes, SymbolicInt
 from crosshair.options import AnalysisOptionSet
 from crosshair.statespace import POST_FAIL, MessageType
@@ -22,27 +25,56 @@ def test_encode_utf8_literal(space):
 
 def test_encode_utf8_symbolic_char(space):
     cp = SymbolicInt("cp")
-    space.add(cp.var >= ord("a"))
-    space.add(cp.var <= ord("z"))
     with ResumedTracing():
+        space.add(cp >= ord("a"))
+        space.add(cp <= ord("z"))
         encoded = codecs.encode(chr(cp), "utf-8")
     assert isinstance(encoded, SymbolicBytes)
     byte_value = encoded[0]
-    assert space.is_possible(byte_value.var == ord("a"))
-    assert space.is_possible(byte_value.var == ord("b"))
+    with ResumedTracing():
+        assert space.is_possible(byte_value == ord("a"))
+        assert space.is_possible(byte_value == ord("b"))
 
 
 def test_decode_utf8_symbolic_char(space):
     cp = SymbolicInt("cp")
-    space.add(cp.var >= ord("a"))
-    space.add(cp.var <= ord("z"))
     with ResumedTracing():
+        space.add(cp >= ord("a"))
+        space.add(cp <= ord("z"))
         decoded = codecs.decode(SymbolicBytes([cp]), "utf-8")
     assert isinstance(decoded, LazyIntSymbolicStr)
-    assert space.is_possible(decoded._codepoints[0].var == ord("a"))
-    assert space.is_possible(decoded._codepoints[0].var == ord("b"))
+    with ResumedTracing():
+        assert space.is_possible(decoded._codepoints[0] == ord("a"))
+        assert space.is_possible(decoded._codepoints[0] == ord("b"))
+
+
+def test_unsupported_codec_encode(space):
+    s = proxy_for_type(str, "s")
+    with ResumedTracing():
+        s.encode("cp858")
+
+
+def test_unsupported_codec_streamwriter(space):
+    s = proxy_for_type(str, "s")
+    buf = bytearray()
+    with ResumedTracing():
+        codecs.getwriter("cp858")(io.BytesIO(buf)).write(s)
+
+
+@pytest.mark.xfail(reason="not yet implemented")
+def test_supported_codec_streamwriter(space):
+    s = proxy_for_type(str, "s")
+    with ResumedTracing():
+        space.add(len(s) == 1)
+        buf = bytearray()
+        codecs.getwriter("ascii")(io.BytesIO(buf)).write(s)
+        space.is_possible(buf[0] == ord("x"))
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 13),
+    reason="Need to intercept UnicodeDecodeError.str in 3.13+",
+)
 def test_decode_e2e():
     def f(byts: bytes) -> str:
         """

crosshair/libimpl/collectionslib.py

@@ -1,21 +1,25 @@
 import collections
+import sys
 from typing import (
     Any,
     Callable,
     Dict,
     Generic,
     Iterable,
+    KeysView,
     List,
     Optional,
     Set,
     Tuple,
     TypeVar,
+    Union,
+    ValuesView,
 )
 
 from crosshair import register_type
-from crosshair.core import CrossHairValue, realize
+from crosshair.core import realize
 from crosshair.tracers import NoTracing, ResumedTracing
-from crosshair.util import is_iterable
+from crosshair.util import CrossHairValue, is_iterable
 
 T = TypeVar("T")
 
@@ -122,8 +126,19 @@ class ListBasedDeque(collections.abc.MutableSequence, CrossHairValue, Generic[T]
         prefix.reverse()
         self._contents = prefix + self._contents
 
-    def index(self, item: T, *bounds) -> int:
-        return self._contents.index(item, *bounds)
+    if sys.version_info >= (3, 14):
+
+        def index(self, item: T, *bounds) -> int:
+            try:
+                return self._contents.index(item, *bounds)
+            except ValueError as exc:
+                exc.args = ("deque.index(x): x not in deque",)
+                raise
+
+    else:
+
+        def index(self, item: T, *bounds) -> int:
+            return self._contents.index(item, *bounds)
 
     def insert(self, index: int, item: T) -> None:
         self._contents.insert(index, item)
@@ -203,11 +218,29 @@ def make_registrations():
     register_type(collections.abc.Mapping, lambda p, kt=Any, vt=Any: p(Dict[kt, vt]))  # type: ignore
     register_type(collections.abc.MutableMapping, lambda p, kt=Any, vt=Any: p(Dict[kt, vt]))  # type: ignore
     register_type(collections.OrderedDict, lambda p, kt=Any, vt=Any: collections.OrderedDict(p(Dict[kt, vt])))  # type: ignore
+    # TODO: This implementation of Counter probably over-realizes the symbolic map it is given:
     register_type(collections.Counter, lambda p, t=Any: collections.Counter(p(Dict[t, int])))  # type: ignore
     # TODO: MappingView is missing
-    register_type(collections.abc.ItemsView, lambda p, kt=Any, vt=Any: p(Set[Tuple[kt, vt]]))  # type: ignore
-    register_type(collections.abc.KeysView, lambda p, t=Any: p(Set[t]))  # type: ignore
-    register_type(collections.abc.ValuesView, lambda p, t=Any: p(List[t]))  # type: ignore
+    register_type(
+        collections.abc.ItemsView,
+        lambda p, k=Any, v=Any: p(Dict.__getitem__((k, v))).items(),
+    )
+    register_type(
+        collections.abc.MappingView,
+        lambda p, t=Any: p(
+            Union[
+                KeysView.__getitem__((t,)),
+                ValuesView.__getitem__((t,)),
+            ]
+        ),
+    )
+    register_type(
+        collections.abc.KeysView, lambda p, t=Any: p(Dict.__getitem__((t, Any))).keys()
+    )
+    register_type(
+        collections.abc.ValuesView,
+        lambda p, t=Any: p(Dict.__getitem__((Any, t))).values(),
+    )
 
     register_type(collections.abc.Container, lambda p, t=Any: p(Tuple[t, ...]))
     register_type(collections.abc.Collection, lambda p, t=Any: p(Tuple[t, ...]))
@@ -224,5 +257,8 @@ def make_registrations():
 
     register_type(collections.abc.MutableSet, lambda p, t=Any: p(Set[t]))  # type: ignore
 
-    register_type(collections.abc.ByteString, lambda p: p(bytes))
+    if sys.version_info < (3, 14):
+        register_type(collections.abc.ByteString, lambda p: p(bytes))
+    if sys.version_info >= (3, 12):
+        register_type(collections.abc.Buffer, lambda p: p(bytes))
     register_type(collections.abc.Hashable, lambda p: p(int))

crosshair/libimpl/collectionslib_test.py

@@ -1,14 +1,24 @@
-import collections
-from typing import DefaultDict, Deque, Tuple
+import re
+import sys
+from collections import Counter, defaultdict, deque, namedtuple
+from copy import deepcopy
+from inspect import Parameter, Signature
+from typing import Callable, Counter, DefaultDict, Deque, Dict, NamedTuple, Tuple
 
 import pytest
 
-from crosshair.core import proxy_for_type, realize, standalone_statespace
-from crosshair.libimpl.collectionslib import ListBasedDeque
+from crosshair.core import (
+    deep_realize,
+    get_constructor_signature,
+    proxy_for_type,
+    realize,
+    standalone_statespace,
+)
+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
-from crosshair.util import set_debug
+from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.util import CrossHairValue
 
 
 @pytest.fixture
@@ -16,6 +26,20 @@ def test_list():
     return ListBasedDeque([1, 2, 3, 4, 5])
 
 
+def test_counter_symbolic_deep(space):
+    d = proxy_for_type(Counter[int], "d")
+    with ResumedTracing():
+        deep_realize(d)
+        deepcopy(d)
+
+
+def test_counter_deep(space):
+    d = Counter()
+    with ResumedTracing():
+        deep_realize(d)
+        deepcopy(d)
+
+
 def test_deque_appendleft(test_list) -> None:
     test_list.appendleft(0)
     assert test_list.popleft() == 0
@@ -75,7 +99,11 @@ def test_deque_index_with_start_index_throws_correct_exception(test_list) -> Non
     with pytest.raises(ValueError) as context:
         test_list.index(1, 2)
 
-    assert context.match("1 is not in list")
+    if sys.version_info >= (3, 14):
+        # assert context.match(re.escape("list.index(x): x not in list"))
+        assert context.match(re.escape("deque.index(x): x not in deque"))
+    else:
+        assert context.match("1 is not in list")
 
 
 def test_deque_index_with_start_and_end_index(test_list) -> None:
@@ -89,7 +117,10 @@ def test_deque_index_with_start_and_end_index_throws_correct_exception(
     with pytest.raises(ValueError) as context:
         test_list.index(6, 0, 1)
 
-    assert context.match("6 is not in list")
+    if sys.version_info >= (3, 14):
+        assert context.match(re.escape("deque.index(x): x not in deque"))
+    else:
+        assert context.match("6 is not in list")
 
 
 def test_deque_insert(test_list) -> None:
@@ -162,7 +193,7 @@ def test_deque_extendleft_method() -> None:
         """
         Can any deque be extended by itself and form this palindrome?
 
-        post[ls]: ls != collections.deque([1, 2, 3, 3, 2, 1])
+        post[ls]: ls != deque([1, 2, 3, 3, 2, 1])
         """
         ls.extendleft(ls)
 
@@ -171,28 +202,28 @@ def test_deque_extendleft_method() -> None:
 
 def test_deque_add_symbolic_to_concrete():
     with standalone_statespace as space:
-        d = ListBasedDeque([1, 2]) + collections.deque([3, 4])
+        d = ListBasedDeque([1, 2]) + deque([3, 4])
         assert list(d) == [1, 2, 3, 4]
 
 
 def test_deque_eq():
     with standalone_statespace as space:
         assert ListBasedDeque([1, 2]) == ListBasedDeque([1, 2])
-        assert collections.deque([1, 2]) == ListBasedDeque([1, 2])
+        assert deque([1, 2]) == ListBasedDeque([1, 2])
         assert ListBasedDeque([1, 2]) != ListBasedDeque([1, 55])
-        assert collections.deque([1, 2]) != ListBasedDeque([1, 55])
+        assert deque([1, 2]) != ListBasedDeque([1, 55])
 
 
 def test_defaultdict_repr_equiv(test_list) -> None:
     def f(symbolic: DefaultDict[int, int]) -> Tuple[dict, dict]:
         """post: _[0] == _[1]"""
-        concrete = collections.defaultdict(symbolic.default_factory, symbolic.items())
+        concrete = defaultdict(symbolic.default_factory, symbolic.items())
         return (symbolic, concrete)
 
     check_states(f, CANNOT_CONFIRM)
 
 
-def test_defaultdict_basic_fail(test_list) -> None:
+def test_defaultdict_basic_fail() -> None:
     def f(a: DefaultDict[int, int], k: int, v: int) -> None:
         """
         post[a]: a[42] != 42
@@ -215,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
 
@@ -229,16 +260,73 @@ def test_defaultdict_realize():
     with standalone_statespace:
         with NoTracing():
             d = proxy_for_type(DefaultDict[int, int], "d")
-            assert type(realize(d)) is collections.defaultdict
+            assert type(realize(d)) is defaultdict
 
 
 #
-# We don't patch namedtuple, but namedtuple performs magic like dynamic type
+# We don't patch namedtuple, but namedtuple performs magic dynamic type
 # generation, which can interfere with CrossHair.
 #
 
 
 def test_namedtuple_creation():
     with standalone_statespace:
-        # Ensure type creation doesn't raise exception:
-        Color = collections.namedtuple("Color", ("name", "hex"))
+        # Ensure type creation under trace doesn't raise exception:
+        Color = namedtuple("Color", ("name", "hex"))
+
+
+def test_namedtuple_argument_detection_untyped():
+    UntypedColor = namedtuple("UntypedColor", ("name", "hex"))
+    expected_signature = Signature(
+        parameters=[
+            Parameter("name", Parameter.POSITIONAL_OR_KEYWORD),
+            Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD),
+        ],
+        return_annotation=Signature.empty,
+    )
+    assert get_constructor_signature(UntypedColor) == expected_signature
+
+
+def test_namedtuple_argument_detection_typed_with_subclass():
+    class ClassTypedColor(NamedTuple):
+        name: str
+        hex: int
+
+    expected_parameters = {
+        "name": Parameter("name", Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+        "hex": Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+    }
+    assert get_constructor_signature(ClassTypedColor).parameters == expected_parameters
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="Functional namedtuple field types supported on Python >= 3.9",
+)
+def test_namedtuple_argument_detection_typed_functionally():
+    FunctionallyTypedColor = NamedTuple(
+        "FunctionallyTypedColor", [("name", str), ("hex", int)]
+    )
+    expected_parameters = {
+        "name": Parameter("name", Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+        "hex": Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+    }
+    assert (
+        get_constructor_signature(FunctionallyTypedColor).parameters
+        == expected_parameters
+    )
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="Functional namedtuple field types supported on Python >= 3.9",
+)
+def test_namedtuple_symbolic_creation(space):
+    UntypedColor = namedtuple("Color", "name hex")
+    Color = NamedTuple("Color", [("name", str), ("hex", int)])
+    untyped_color = proxy_for_type(UntypedColor, "color")
+    assert isinstance(untyped_color.hex, CrossHairValue)
+    color = proxy_for_type(Color, "color")
+    with ResumedTracing():
+        assert space.is_possible(color.hex == 5)
+        assert space.is_possible(color.hex == 10)

crosshair/libimpl/copylib.py

@@ -1,7 +1,7 @@
 from copy import copy, deepcopy
 
 from crosshair import NoTracing, register_patch
-from crosshair.core import CrossHairValue
+from crosshair.util import CrossHairValue
 
 
 def _copy(x):

crosshair/libimpl/copylib_test.py

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