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

crosshair/_mark_stacks.h

@@ -538,31 +538,6 @@ static const uint8_t _ch_DE_INSTRUMENT[256] = {
 #endif
 #endif
 
-static const uint8_t _ch_TRACABLE_INSTRUCTIONS[256] = {
-    // This must be manually kept in sync the the various
-    // instructions that we care about on the python side.
-    [MAP_ADD] = 1,
-    [BINARY_SUBSCR] = 1,
-    [BINARY_SLICE] = 1,
-    [CONTAINS_OP] = 1,
-    [BUILD_STRING] = 1,
-#if PY_VERSION_HEX < 0x030D0000
-    // <= 3.12
-    [FORMAT_VALUE] = 1,
-#elif PY_VERSION_HEX < 0x030E0000
-    // 3.13
-    [CALL_KW] = 1,
-    [CONVERT_VALUE] = 1,
-#endif
-    [UNARY_NOT] = 1,
-    [SET_ADD] = 1,
-    [IS_OP] = 1,
-    [BINARY_OP] = 1,
-    [CALL] = 1,
-    [CALL_FUNCTION_EX] = 1,
-};
-
-
 /* Get the underlying opcode, stripping instrumentation */
 int _ch_Py_GetBaseOpcode(PyCodeObject *code, int i)
 {

crosshair/_tracers.h

@@ -88,4 +88,6 @@ typedef struct TraceSwap {
 
 extern PyTypeObject TraceSwapType;
 
+extern const uint8_t _ch_TRACABLE_INSTRUCTIONS[256];
+
 #endif /* _COVERAGE_TRACER_H */

crosshair/_tracers_test.py

@@ -89,7 +89,10 @@ def _log_execution_stacks(fn, *a, **kw):
     return stacks
 
 
-@pytest.mark.skipif(sys.version_info < (3, 12), reason="stack depth on 3.12+")
+@pytest.mark.skipif(
+    sys.version_info < (3, 12) or sys.version_info >= (3, 14),
+    reason="stack depths only in 3.12 & 3.13",
+)
 def test_one_function_stack_depth():
     _E = (TypeError, KeyboardInterrupt)
 
@@ -100,7 +103,10 @@ def test_one_function_stack_depth():
     _log_execution_stacks(a, 4)
 
 
-@pytest.mark.skipif(sys.version_info < (3, 12), reason="stack depth on 3.12+")
+@pytest.mark.skipif(
+    sys.version_info < (3, 12) or sys.version_info >= (3, 14),
+    reason="stack depths only in 3.12 & 3.13",
+)
 def test_stack_get():
     def to_be_traced(x):
         r = 8 - x

crosshair/auditwall.py

@@ -135,7 +135,6 @@ def make_handler(event: str) -> Callable[[str, Tuple], None]:
         "imaplib",
         "msvcrt",
         "nntplib",
-        "os",
         "pathlib",
         "poplib",
         "shutil",

crosshair/auditwall_test.py

@@ -42,6 +42,10 @@ def test_popen_disallowed():
     assert call([pyexec, __file__, "popen", "withwall"]) == 10
 
 
+def test_chdir_allowed():
+    assert call([pyexec, __file__, "chdir", "withwall"]) == 0
+
+
 @pytest.mark.skipif(sys.version_info < (3, 9), reason="Python 3.9+ required")
 def test_popen_via_platform_allowed():
     assert call([pyexec, __file__, "popen_via_platform", "withwall"]) == 0
@@ -58,6 +62,7 @@ _ACTIONS = {
     "popen_via_platform": lambda: platform._syscmd_ver(  # type: ignore
         supported_platforms=(sys.platform,)
     ),
+    "chdir": lambda: os.chdir("."),
 }
 
 if __name__ == "__main__":

crosshair/condition_parser.py

@@ -47,6 +47,7 @@ from crosshair.options import AnalysisKind
 from crosshair.register_contract import get_contract
 from crosshair.tracers import NoTracing
 from crosshair.util import (
+    CrossHairInternal,
     DynamicScopeVar,
     EvalFriendlyReprContext,
     IdKeyedDict,
@@ -485,6 +486,7 @@ class ConcreteConditionParser(ConditionParser):
             method = cls.__dict__.get(method_name, None)
             super_method_conditions = super_methods.get(method_name)
             if super_method_conditions is not None:
+                # Re-type the super's `self` argument to be this class:
                 revised_sig = set_first_arg_type(super_method_conditions.sig, cls)
                 super_method_conditions = replace(
                     super_method_conditions, sig=revised_sig
@@ -511,17 +513,15 @@ class ConcreteConditionParser(ConditionParser):
             final_pre = list(conditions.pre)
             final_post = list(conditions.post)
             if method_name in (
-                "__new__",  # isn't passed a concrete instance.
+                "__new__",  # a staticmethod, but not isinstance(staticmethod)
                 "__repr__",  # is itself required for reporting problems with invariants.
                 # [set/del]attr can do anything; we can't resonably enforce invariants:
                 "__setattr__",
                 "__delattr__",
+                "__replace__",  # Will raise an exception with most arbitrary **kwargs.
+                "__annotate__",  # a staticmethod, but not isinstance(staticmethod)
             ):
                 pass
-            elif method_name == "__replace__":
-                # TODO: remove this case when fixed in 3.13
-                # see https://github.com/python/cpython/issues/114198
-                pass
             elif method_name == "__del__":
                 final_pre.extend(inv)
             elif method_name == "__init__":

crosshair/condition_parser_test.py

@@ -133,41 +133,32 @@ def test_parse_sphinx_raises() -> None:
     assert parse_sphinx_raises(sphinx_raises) == {LocallyDefiendException}
 
 
-class Pep316ParserTest(unittest.TestCase):
+class TestPep316Parser:
     def test_class_parse(self) -> None:
         class_conditions = Pep316Parser().get_class_conditions(Foo)
-        self.assertEqual(
-            set([c.expr_source for c in class_conditions.inv]),
-            set(["self.x >= 0", "self.y >= 0"]),
-        )
-        self.assertEqual(
-            set(class_conditions.methods.keys()), set(["isready", "__init__"])
-        )
+        assert set([c.expr_source for c in class_conditions.inv]) == {
+            "self.x >= 0",
+            "self.y >= 0",
+        }
+        assert {"isready", "__init__"} <= set(class_conditions.methods.keys())
         method = class_conditions.methods["isready"]
-        self.assertEqual(
-            set([c.expr_source for c in method.pre]),
-            set(["self.x >= 0", "self.y >= 0"]),
-        )
+        assert set([c.expr_source for c in method.pre]) == {
+            "self.x >= 0",
+            "self.y >= 0",
+        }
         startlineno = inspect.getsourcelines(Foo)[1]
-        self.assertEqual(
-            set([(c.expr_source, c.line) for c in method.post]),
-            set(
-                [
-                    ("self.x >= 0", startlineno + 7),
-                    ("self.y >= 0", startlineno + 12),
-                    ("__return__ == (self.x == 0)", startlineno + 24),
-                ]
-            ),
-        )
+        assert set([(c.expr_source, c.line) for c in method.post]) == {
+            ("self.x >= 0", startlineno + 7),
+            ("self.y >= 0", startlineno + 12),
+            ("__return__ == (self.x == 0)", startlineno + 24),
+        }
 
     def test_single_line_condition(self) -> None:
         conditions = Pep316Parser().get_fn_conditions(
             FunctionInfo.from_fn(single_line_condition)
         )
         assert conditions is not None
-        self.assertEqual(
-            set([c.expr_source for c in conditions.post]), set(["__return__ >= x"])
-        )
+        assert set([c.expr_source for c in conditions.post]) == {"__return__ >= x"}
 
     def test_implies_condition(self):
         conditions = Pep316Parser().get_fn_conditions(
@@ -182,37 +173,35 @@ class Pep316ParserTest(unittest.TestCase):
             FunctionInfo.from_fn(locally_defined_raises_condition)
         )
         assert conditions is not None
-        self.assertEqual([], list(conditions.syntax_messages()))
-        self.assertEqual(set([LocallyDefiendException]), conditions.raises)
+        assert [] == list(conditions.syntax_messages())
+        assert set([LocallyDefiendException]) == conditions.raises
 
     def test_tricky_raises_condition(self) -> None:
         conditions = Pep316Parser().get_fn_conditions(
             FunctionInfo.from_fn(tricky_raises_condition)
         )
         assert conditions is not None
-        self.assertEqual([], list(conditions.syntax_messages()))
-        self.assertEqual(conditions.raises, set([KeyError, json.JSONDecodeError]))
+        assert [] == list(conditions.syntax_messages())
+        assert conditions.raises == {KeyError, json.JSONDecodeError}
 
     def test_invariant_is_inherited(self) -> None:
         class_conditions = Pep316Parser().get_class_conditions(SubClassExample)
-        self.assertEqual(set(class_conditions.methods.keys()), set(["foo", "__init__"]))
+        assert set(class_conditions.methods.keys()) == {"foo", "__init__"}
         method = class_conditions.methods["foo"]
-        self.assertEqual(len(method.pre), 1)
-        self.assertEqual(set([c.expr_source for c in method.pre]), set(["True"]))
-        self.assertEqual(len(method.post), 2)
-        self.assertEqual(
-            set([c.expr_source for c in method.post]), set(["True", "False"])
-        )
+        assert len(method.pre) == 1
+        assert set([c.expr_source for c in method.pre]) == {"True"}
+        assert len(method.post) == 2
+        assert set([c.expr_source for c in method.post]) == {"True", "False"}
 
     def test_invariant_applies_to_init(self) -> None:
         class_conditions = Pep316Parser().get_class_conditions(BaseClassExample)
-        self.assertEqual(set(class_conditions.methods.keys()), set(["__init__", "foo"]))
+        assert set(class_conditions.methods.keys()) == {"__init__", "foo"}
 
     @pytest.mark.skipif(
         sys.version_info >= (3, 13), reason="builtins have signatures in 3.13"
     )
     def test_builtin_conditions_are_null(self) -> None:
-        self.assertIsNone(Pep316Parser().get_fn_conditions(FunctionInfo.from_fn(zip)))
+        assert Pep316Parser().get_fn_conditions(FunctionInfo.from_fn(zip)) is None
 
     def test_conditions_with_closure_references_and_string_type(self) -> None:
         # This is a function that refers to something in its closure.
@@ -228,7 +217,7 @@ class Pep316ParserTest(unittest.TestCase):
 
 
 @pytest.mark.skipif(not icontract, reason="icontract is not installed")
-class IcontractParserTest(unittest.TestCase):
+class TestIcontractParser:
     def test_simple_parse(self):
         @icontract.require(lambda ls: len(ls) > 0)
         @icontract.ensure(lambda ls, result: min(ls) <= result <= max(ls))
@@ -237,17 +226,17 @@ class IcontractParserTest(unittest.TestCase):
 
         conditions = IcontractParser().get_fn_conditions(FunctionInfo.from_fn(avg))
         assert conditions is not None
-        self.assertEqual(len(conditions.pre), 1)
-        self.assertEqual(len(conditions.post), 1)
-        self.assertEqual(conditions.pre[0].evaluate({"ls": []}), False)
+        assert len(conditions.pre) == 1
+        assert len(conditions.post) == 1
+        assert conditions.pre[0].evaluate({"ls": []}) is False
         post_args = {
             "ls": [42, 43],
             "__old__": AttributeHolder({}),
             "__return__": 40,
             "_": 40,
         }
-        self.assertEqual(conditions.post[0].evaluate(post_args), False)
-        self.assertEqual(len(post_args), 4)  # (check args are unmodified)
+        assert conditions.post[0].evaluate(post_args) is False
+        assert len(post_args) == 4  # (check args are unmodified)
 
     def test_simple_class_parse(self):
         @icontract.invariant(lambda self: self.i >= 0)
@@ -268,14 +257,14 @@ class IcontractParserTest(unittest.TestCase):
                 self.i -= 1
 
         conditions = IcontractParser().get_class_conditions(Counter)
-        self.assertEqual(len(conditions.inv), 1)
+        assert len(conditions.inv) == 1
 
         decr_conditions = conditions.methods["decr"]
-        self.assertEqual(len(decr_conditions.pre), 2)
+        assert len(decr_conditions.pre) == 2
         # decr() precondition: count > 0
-        self.assertEqual(decr_conditions.pre[0].evaluate({"self": Counter()}), False)
+        assert decr_conditions.pre[0].evaluate({"self": Counter()}) is False
         # invariant: count >= 0
-        self.assertEqual(decr_conditions.pre[1].evaluate({"self": Counter()}), True)
+        assert decr_conditions.pre[1].evaluate({"self": Counter()}) is True
 
         class TruncatedCounter(Counter):
             @icontract.require(
@@ -287,21 +276,19 @@ class IcontractParserTest(unittest.TestCase):
 
         conditions = IcontractParser().get_class_conditions(TruncatedCounter)
         decr_conditions = conditions.methods["decr"]
-        self.assertEqual(
-            decr_conditions.pre[0].evaluate({"self": TruncatedCounter()}), True
-        )
+        assert decr_conditions.pre[0].evaluate({"self": TruncatedCounter()}) is True
 
         # check the weakened precondition
-        self.assertEqual(
-            len(decr_conditions.pre), 2
+        assert (
+            len(decr_conditions.pre) == 2
         )  # one for the invariant, one for the disjunction
         ctr = TruncatedCounter()
         ctr.i = 1
-        self.assertEqual(decr_conditions.pre[1].evaluate({"self": ctr}), True)
-        self.assertEqual(decr_conditions.pre[0].evaluate({"self": ctr}), True)
+        assert decr_conditions.pre[1].evaluate({"self": ctr}) is True
+        assert decr_conditions.pre[0].evaluate({"self": ctr}) is True
         ctr.i = 0
-        self.assertEqual(decr_conditions.pre[1].evaluate({"self": ctr}), True)
-        self.assertEqual(decr_conditions.pre[0].evaluate({"self": ctr}), True)
+        assert decr_conditions.pre[1].evaluate({"self": ctr}) is True
+        assert decr_conditions.pre[0].evaluate({"self": ctr}) is True
 
 
 @pytest.mark.skipif(not deal, reason="deal is not installed")
@@ -395,20 +382,20 @@ def fn_with_docstring_comments_and_assert(numbers: List[int]) -> None:
     assert min(numbers) > smallest
 
 
-class AssertsParserTest(unittest.TestCase):
+class TestAssertsParser:
     def tests_simple_parse(self) -> None:
         conditions = AssertsParser().get_fn_conditions(
             FunctionInfo.from_fn(avg_with_asserts)
         )
         assert conditions is not None
         conditions.fn([])
-        self.assertEqual(conditions.fn([2.2]), 2.2)
-        with self.assertRaises(AssertionError):
+        assert conditions.fn([2.2]) == 2.2
+        with pytest.raises(AssertionError):
             conditions.fn([9.2, 17.8])
 
     def tests_empty_parse(self) -> None:
         conditions = AssertsParser().get_fn_conditions(FunctionInfo.from_fn(debug))
-        self.assertEqual(conditions, None)
+        assert conditions is None
 
     def tests_extra_ast_nodes(self) -> None:
         conditions = AssertsParser().get_fn_conditions(
@@ -422,10 +409,10 @@ class AssertsParserTest(unittest.TestCase):
         # normal, passing case:
         nums = [3, 1, 2]
         conditions.fn(nums)
-        self.assertEqual(nums, [3, 2])
+        assert nums == [3, 2]
 
         # Failing case (duplicate minimum values):
-        with self.assertRaises(AssertionError):
+        with pytest.raises(AssertionError):
             nums = [3, 1, 1, 2]
             conditions.fn(nums)
 

crosshair/copyext.py

@@ -1,4 +1,9 @@
-from copy import _deepcopy_atomic  # type: ignore
+import sys
+
+if sys.version_info >= (3, 14):
+    from copy import _atomic_types
+else:
+    from copy import _deepcopy_atomic  # type: ignore
 from copy import _deepcopy_dict  # type: ignore
 from copy import _deepcopy_dispatch  # type: ignore
 from copy import _deepcopy_list  # type: ignore
@@ -9,7 +14,7 @@ from copy import Error
 from copyreg import dispatch_table  # type: ignore
 from enum import Enum
 from types import MappingProxyType
-from typing import Any, Dict, Tuple
+from typing import Any, Callable, Dict, Tuple
 
 from crosshair.tracers import ResumedTracing
 from crosshair.util import (
@@ -85,17 +90,28 @@ def deepcopyext(obj: object, mode: CopyMode, memo: Dict) -> Any:
     return cpy
 
 
+if sys.version_info >= (3, 14):
+
+    def lookup_dispatch(cls: type) -> Callable:
+        if cls in _atomic_types:
+            return lambda obj, memo: obj
+        return _deepcopy_dispatch.get(cls)
+
+else:
+
+    def lookup_dispatch(cls: type) -> Callable:
+        return _deepcopy_dispatch.get(cls)
+
+
 def _deepconstruct(obj: object, mode: CopyMode, memo: Dict):
     cls = type(obj)
 
     def subdeepcopy(obj: object, memo: Dict):
         return deepcopyext(obj, mode, memo)
 
-    if cls in _deepcopy_dispatch:
-        creator = _deepcopy_dispatch[cls]
-        if creator is _deepcopy_atomic:
-            return obj
-        elif creator in (_deepcopy_dict, _deepcopy_list, _deepcopy_tuple):
+    creator = lookup_dispatch(cls)
+    if creator is not None:
+        if creator in (_deepcopy_dict, _deepcopy_list, _deepcopy_tuple):
             return creator(obj, memo, deepcopy=subdeepcopy)
         else:
             # TODO: We loose subdeepcopy in this case - won't

crosshair/copyext_test.py

@@ -7,7 +7,7 @@ import pytest
 from crosshair.copyext import CopyMode, deepcopyext
 from crosshair.core_and_libs import proxy_for_type, standalone_statespace
 from crosshair.libimpl.builtinslib import SymbolicInt
-from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.tracers import NoTracing
 
 
 def test_deepcopyext_best_effort():
@@ -33,6 +33,16 @@ def test_deepcopyext_symbolic_set():
             deepcopyext(s, CopyMode.REALIZE, {})
 
 
+def test_deepcopyext_realize_simple(space):
+    x = SymbolicInt("x")
+    input = (x,)
+    output = deepcopyext(input, CopyMode.REALIZE, {})
+    assert input is not output
+    assert input[0] is not output[0]
+    assert type(input[0]) is SymbolicInt
+    assert type(output[0]) is int
+
+
 def test_deepcopyext_realize(space):
     x = SymbolicInt("x")
     lock = RLock()

crosshair/core.py

@@ -429,24 +429,30 @@ def get_constructor_signature(cls: Type) -> Optional[inspect.Signature]:
         sig = resolve_signature(cls)
         if isinstance(sig, inspect.Signature):
             return sig
+
+    applicable_sigs: List[Signature] = []
     new_fn = cls.__new__
-    sig = resolve_signature(new_fn)
-    # TODO: merge the type signatures of __init__ and __new__, pulling the
-    # most specific types from each.
-    # Fall back to __init__ if we don't have types:
-    if isinstance(sig, str) or all(
-        p.annotation is Signature.empty for p in sig.parameters.values()
-    ):
-        init_fn = cls.__init__
-        if init_fn is not object.__init__:
-            sig = resolve_signature(init_fn)
-        else:
-            return inspect.Signature([])
-    if isinstance(sig, inspect.Signature):
-        # strip first argument
-        newparams = list(sig.parameters.values())[1:]
-        return sig.replace(parameters=newparams)
-    return None
+    if new_fn is not object.__new__:
+        sig = resolve_signature(new_fn)
+        if not isinstance(sig, str):
+            applicable_sigs.append(sig)
+    init_fn = cls.__init__
+    if init_fn is not object.__init__:
+        sig = resolve_signature(init_fn)
+        if not isinstance(sig, str):
+            sig = sig.replace(
+                return_annotation=object
+            )  # make return types compatible (& use __new__'s return)
+            applicable_sigs.append(sig)
+    if len(applicable_sigs) == 0:
+        return inspect.Signature([])
+    if len(applicable_sigs) == 2:
+        sig = dynamic_typing.intersect_signatures(*applicable_sigs)
+    else:
+        sig = applicable_sigs[0]
+    # strip first argument ("self" or "cls")
+    newparams = list(sig.parameters.values())[1:]
+    return sig.replace(parameters=newparams)
 
 
 _TYPE_HINTS = IdKeyedDict()