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

crosshair/condition_parser.py

@@ -10,7 +10,7 @@ import traceback
 import types
 from dataclasses import dataclass, replace
 from functools import partial, wraps
-from inspect import BoundArguments, Parameter, Signature
+from inspect import BoundArguments, Signature
 from itertools import chain
 from typing import (
     Any,
@@ -41,35 +41,22 @@ try:
 except ModuleNotFoundError:
     deal = None  # type: ignore
 
-
-try:
-    import hypothesis
-    from hypothesis import strategies as st
-    from hypothesis.control import BuildContext
-    from hypothesis.database import ExampleDatabase
-    from hypothesis.internal.conjecture.data import ConjectureData
-except ImportError:
-    hypothesis = None  # type: ignore
-    ExampleDatabase = object  # type: ignore
-
 from crosshair.auditwall import opened_auditwall
 from crosshair.fnutil import FunctionInfo, fn_globals, set_first_arg_type
 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,
-    IgnoreAttempt,
-    UnexploredPath,
     debug,
     eval_friendly_repr,
     format_boundargs,
     frame_summary_for_fn,
     is_pure_python,
     sourcelines,
-    test_stack,
 )
 
 
@@ -128,7 +115,7 @@ def get_doc_lines(thing: object) -> Iterable[Tuple[int, str]]:
     if not isinstance(firstnode, ast.Expr):
         return
     strnode = firstnode.value
-    if not isinstance(strnode, ast.Str):
+    if not (isinstance(strnode, ast.Constant) and isinstance(strnode.value, str)):
         return
     end_lineno = getattr(strnode, "end_lineno", None)
     if end_lineno is not None:
@@ -457,7 +444,7 @@ class ConditionParser:
     def get_class_conditions(self, cls: type) -> ClassConditions:
         raise NotImplementedError
 
-    def class_can_have_conditions(sel, cls: type) -> bool:
+    def class_can_have_conditions(self, cls: type) -> bool:
         raise NotImplementedError
 
 
@@ -478,7 +465,7 @@ class ConcreteConditionParser(ConditionParser):
         """
         raise NotImplementedError
 
-    def class_can_have_conditions(sel, cls: type) -> bool:
+    def class_can_have_conditions(self, cls: type) -> bool:
         # We can't get conditions/line numbers for classes written in C.
         return is_pure_python(cls)
 
@@ -499,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
@@ -524,13 +512,16 @@ class ConcreteConditionParser(ConditionParser):
             # Selectively add conditions inferred from invariants:
             final_pre = list(conditions.pre)
             final_post = list(conditions.post)
-            if method_name in ("__new__", "__repr__"):
-                # __new__ isn't passed a concrete instance.
-                # __repr__ is itself required for reporting problems with invariants.
-                pass
-            elif method_name == "__replace__":
-                # TODO: remove this case when fixed in 3.13
-                # see https://github.com/python/cpython/issues/114198
+            if method_name in (
+                "__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)
+                "__annotate_func__",
+            ):
                 pass
             elif method_name == "__del__":
                 final_pre.extend(inv)
@@ -1117,112 +1108,6 @@ class AssertsParser(ConcreteConditionParser):
         return []
 
 
-class CrossHairDatabaseWrapper(ExampleDatabase):
-    """Save buffers to the underlying database but discard all other actions."""
-
-    def __init__(self, db: ExampleDatabase) -> None:
-        super().__init__()
-        self._db = db
-        from crosshair.core import realize
-
-        self._realize = realize
-
-    def save(self, key: bytes, value: bytes) -> None:
-        with NoTracing(), opened_auditwall():
-            realkey = self._realize(key)
-            realvalue = self._realize(value)
-            self._db.save(realkey, realvalue)
-
-    def fetch(self, key: bytes) -> Iterable[bytes]:
-        return ()
-
-    def delete(self, key: bytes, value: bytes) -> None:
-        pass
-
-    def move(self, src: bytes, dest: bytes, value: bytes) -> None:
-        pass
-
-
-class HypothesisParser(ConcreteConditionParser):
-    def __init__(self, toplevel_parser: Optional[ConditionParser] = None):
-        super().__init__(toplevel_parser)
-
-    def _generate_args(self, payload: bytes, decorated_fn: Callable):
-        given_kwargs = decorated_fn.hypothesis._given_kwargs  # type: ignore
-        strategy = st.fixed_dictionaries(given_kwargs)
-        data = ConjectureData.for_buffer(payload)
-        with BuildContext(data):
-            return data.draw(strategy)
-
-    def _format_counterexample(
-        self,
-        fn: Callable,
-        args: BoundArguments,
-        return_val: object,
-        repr_overrides: IdKeyedDict,
-    ) -> Tuple[str, str]:
-        payload_bytes = args.arguments["payload"]
-        kwargs = self._generate_args(payload_bytes, fn)
-        sig = inspect.signature(fn.hypothesis.inner_test)  # type: ignore
-        real_args = sig.bind(**kwargs)
-        return default_counterexample(fn.__name__, real_args, None, repr_overrides)
-
-    def get_fn_conditions(self, ctxfn: FunctionInfo) -> Optional[Conditions]:
-        fn_and_sig = ctxfn.get_callable()
-        if fn_and_sig is None:
-            return None
-        (fn, sig) = fn_and_sig
-        if not getattr(fn, "is_hypothesis_test", False):
-            return None
-        handle = getattr(fn, "hypothesis", None)
-        if handle is None:
-            return None
-
-        # Mess with the settings to wrap whatever database we're using for CrossHair
-        if hasattr(fn, "_hypothesis_internal_use_settings"):
-            db = fn._hypothesis_internal_use_settings.database  # type: ignore
-            fn._hypothesis_internal_use_settings = hypothesis.settings(  # type: ignore
-                database=CrossHairDatabaseWrapper(db),
-                phases=[hypothesis.Phase.generate],
-            )
-        fuzz_one = getattr(handle, "fuzz_one_input", None)
-        if fuzz_one is None:
-            return None
-
-        filename, first_line, _lines = sourcelines(fn)
-        post = [
-            ConditionExpr(
-                POSTCONDITION,
-                lambda _: True,
-                filename,
-                first_line,
-                "",
-            )
-        ]
-        sig = inspect.Signature(
-            parameters=[
-                inspect.Parameter(
-                    "payload", inspect.Parameter.POSITIONAL_ONLY, annotation=bytes
-                )
-            ]
-        )
-
-        return Conditions(
-            fuzz_one,
-            fn,
-            [],  # (pre)
-            post,
-            raises=frozenset(),
-            sig=sig,
-            mutable_args=None,
-            fn_syntax_messages=[],
-            counterexample_description_maker=partial(self._format_counterexample, fn),
-        )
-
-    def get_class_invariants(self, cls: type) -> List[ConditionExpr]:
-        return []
-
-
 class RegisteredContractsParser(ConcreteConditionParser):
     """Parser for manually registered contracts."""
 
@@ -1310,7 +1195,7 @@ class RegisteredContractsParser(ConcreteConditionParser):
             fn_syntax_messages=[],
         )
 
-    def class_can_have_conditions(sel, cls: type) -> bool:
+    def class_can_have_conditions(self, cls: type) -> bool:
         # We might have registered contracts for classes written in C, so we don't want
         # to skip evaluating conditions on the class methods.
         return True
@@ -1325,7 +1210,6 @@ _PARSER_MAP = {
     AnalysisKind.PEP316: Pep316Parser,
     AnalysisKind.icontract: IcontractParser,
     AnalysisKind.deal: DealParser,
-    AnalysisKind.hypothesis: HypothesisParser,
 }
 
 

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
@@ -11,7 +9,6 @@ from crosshair.condition_parser import (
     AssertsParser,
     CompositeConditionParser,
     DealParser,
-    HypothesisParser,
     IcontractParser,
     Pep316Parser,
     parse_sections,
@@ -31,11 +28,6 @@ try:
 except ImportError:
     deal = None  # type: ignore
 
-try:
-    import hypothesis  # type: ignore
-except ImportError:
-    hypothesis = None  # type: ignore
-
 
 class LocallyDefiendException(Exception):
     pass
@@ -139,41 +131,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(
@@ -188,37 +171,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.
@@ -234,7 +215,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))
@@ -243,17 +224,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)
@@ -274,14 +255,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(
@@ -293,21 +274,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")
@@ -401,20 +380,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(
@@ -428,10 +407,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)
 
@@ -492,18 +471,10 @@ def test_lines_with_trailing_comment():
 
 def test_format_counterexample_positional_only():
     if sys.version_info >= (3, 8):
-        # Use exec() here because the "/" marker is a syntax error in Python 3.7
-        ns = {}
-        foo = exec(
-            textwrap.dedent(
-                '''
-                def foo(a=10, /, b=20):
-                    """post: True"""
-                '''
-            ),
-            ns,
-        )
-        foo = ns["foo"]
+
+        def foo(a=10, /, b=20):
+            """post: True"""
+
         args = inspect.BoundArguments(inspect.signature(foo), {"a": 1, "b": 2})
         conditions = Pep316Parser().get_fn_conditions(FunctionInfo.from_fn(foo))
         assert conditions.format_counterexample(args, None, {}) == (
@@ -524,16 +495,3 @@ def test_format_counterexample_keyword_only():
             "foo(1, b=2)",
             "None",
         )
-
-
-@pytest.mark.skipif(not hypothesis, reason="hypothesis is not installed")
-def test_hypothesis_arg_regen():
-    @hypothesis.given(hypothesis.strategies.integers())
-    def hypothesis_fn_int(x):
-        pass
-
-    parser = HypothesisParser(None)
-    # NOTE: Enocding not stable across hypothesis versions.
-    # Byte string may need to be updated when our hypothesis dev version changes.
-    ret = parser._generate_args(b"\x01\x04T", hypothesis_fn_int)
-    assert ret == {"x": 42}

crosshair/conftest.py

@@ -11,7 +11,7 @@ def pytest_configure(config):
         set_debug(True)
 
 
-LEAK_LIMIT_KB = 200 * 1024
+LEAK_LIMIT_KB = 400 * 1024
 
 
 @pytest.hookimpl(hookwrapper=True)