crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/decimallib_ch_test.py

@@ -0,0 +1,78 @@
+import operator
+import sys
+from decimal import BasicContext, Decimal, ExtendedContext, localcontext
+from typing import Union
+
+import pytest  # type: ignore
+
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.test_util import ResultComparison, compare_results, compare_returns
+
+
+def _binary_op_under_context(ctx, op):
+    def run_op(d1, d2):
+        with localcontext(ctx):
+            return op(d1, d2)
+
+    return run_op
+
+
+def check_division(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_returns(operator.truediv, decimal1, decimal2)
+
+
+def check_pow(decimal1: Decimal, decimal2: Decimal) -> ResultComparison:
+    """post: _"""
+    return compare_results(operator.pow, decimal1, decimal2)
+
+
+def check_extended_context(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_results(
+        _binary_op_under_context(ExtendedContext, operator.truediv), decimal1, decimal2
+    )
+
+
+def check_basic_context(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_results(
+        _binary_op_under_context(BasicContext, operator.truediv), decimal1, decimal2
+    )
+
+
+def check_div_using_context_method(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_returns(BasicContext.divide, decimal1, decimal2)
+
+
+def check_div_using_context_parameter(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_returns(
+        lambda d1, d2: d1.divide(d2, context=BasicContext), decimal1, decimal2
+    )
+
+
+def check_create_decimal_from_float(float_number: float):
+    """post: _"""
+    return compare_results(BasicContext.create_decimal_from_float, float_number)
+
+
+# This is the only real test definition.
+# It runs crosshair on each of the "check" functions defined above.
+@pytest.mark.parametrize("fn_name", [fn for fn in dir() if fn.startswith("check_")])
+def test_builtin(fn_name: str) -> None:
+    this_module = sys.modules[__name__]
+    messages = run_checkables(analyze_function(getattr(this_module, fn_name)))
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []

crosshair/libimpl/decimallib_test.py

@@ -0,0 +1,76 @@
+from decimal import (
+    Decimal,
+    DivisionByZero,
+    ExtendedContext,
+    InvalidOperation,
+    localcontext,
+)
+
+import pytest
+
+from crosshair.core import proxy_for_type, standalone_statespace
+from crosshair.libimpl.decimallib import Decimal as PyDecimal
+from crosshair.tracers import NoTracing
+from crosshair.util import debug
+
+
+def test_mixed_decimal_addition() -> None:
+    d1 = Decimal("1.05")
+    with standalone_statespace:
+        d2 = proxy_for_type(Decimal, "d2")
+        debug("type(d2)", type(d2))
+        d1 + d2
+
+
+def test_external_decimal_context() -> None:
+    with localcontext(ExtendedContext):
+        Decimal("43.4") / 0  # does not raise
+    with pytest.raises(DivisionByZero):
+        Decimal("43.4") / 0
+    with pytest.raises(InvalidOperation):
+        Decimal("0") / 0
+    with pytest.raises(DivisionByZero):
+        PyDecimal("43.4") / 0
+    with standalone_statespace as space:
+        with NoTracing():
+            d1 = proxy_for_type(Decimal, "d1")
+        if d1 == 0:
+            d1 += 1
+        with pytest.raises(DivisionByZero):
+            d1 / 0
+        with pytest.raises(InvalidOperation):
+            (d1 - d1) / 0
+
+
+def test_context_method_on_symbolic():
+    with standalone_statespace:
+        ExtendedContext.exp(proxy_for_type(Decimal, "d"))
+        ExtendedContext.divide_int(Decimal(12), proxy_for_type(Decimal, "d"))
+        ExtendedContext.divide_int(Decimal(12), Decimal(2))
+
+
+def test_precision():
+    """post: _"""
+    d1, d2 = Decimal("3.4445"), Decimal("1.0023")
+    expected = Decimal("4.45")
+    assert d1 + d2 != expected
+    with standalone_statespace:
+        with localcontext() as ctx:
+            ctx.prec = 3
+            assert d1 + d2 == expected
+        with localcontext() as ctx:
+            ctx.prec = 1
+            assert +expected == Decimal("4")
+
+
+# Still working on this! (rn, issue with z3 int exponent vars becoming reals)
+# def test_decimal_end_to_end():
+#     def add_tax(price: Decimal):
+#         """post: _ != Decimal('1.05')"""
+#         ctx = ExtendedContext.copy()
+#         ctx.prec = 3
+#         with localcontext(ctx):
+#             return price + Decimal("0.05")
+#             # return price * Decimal("1.05")
+
+#     check_states(add_tax, POST_FAIL)

crosshair/libimpl/encodings/__init__.py

@@ -0,0 +1,23 @@
+import codecs
+import importlib
+from encodings import normalize_encoding
+from encodings.aliases import aliases
+from typing import Optional
+
+
+def codec_search(encoding: str) -> Optional[codecs.CodecInfo]:
+    enc_prefix = "crosshair_"
+    if not encoding.startswith(enc_prefix):
+        return None
+
+    encoding = normalize_encoding(encoding[len(enc_prefix) :])
+    encoding = aliases.get(encoding, encoding)
+
+    try:
+        module = importlib.import_module(f"crosshair.libimpl.encodings.{encoding}")
+    except ImportError:
+        pass
+    else:
+        if callable(getattr(module, "getregentry", None)):
+            return module.getregentry()  # type: ignore
+    return None

crosshair/libimpl/encodings/_encutil.py

@@ -0,0 +1,187 @@
+import codecs
+import sys
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Type, Union
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from collections.abc import ByteString as Buffer
+
+from crosshair.core import realize
+from crosshair.libimpl.builtinslib import AnySymbolicStr, SymbolicBytes
+
+
+class ChunkError:
+    def reason(self) -> str:
+        raise NotImplementedError
+
+
+class UnexpectedEndError(ChunkError):
+    def reason(self) -> str:
+        return "unexpected end of data"
+
+
+@dataclass
+class MidChunkError(ChunkError):
+    _reason: str
+
+    # _errlen: int = 1
+    def reason(self) -> str:
+        return self._reason
+
+
+class _UnicodeDecodeError(UnicodeDecodeError):
+    def __init__(self, enc, byts, start, end, reason):
+        UnicodeDecodeError.__init__(self, enc, b"", start, end, reason)
+        self.object = byts
+
+    def __ch_deep_realize__(self, memo) -> object:
+        enc, obj, reason = self.encoding, self.object, self.reason
+        start, end = self.start, self.end
+        return UnicodeDecodeError(
+            realize(enc), realize(obj), realize(start), realize(end), realize(reason)
+        )
+
+    def __repr__(self):
+        enc, obj, reason = self.encoding, self.object, self.reason
+        start, end = self.start, self.end
+        return f"UnicodeDecodeError({enc!r}, {obj!r}, {start!r}, {end!r}, {reason!r})"
+
+
+class StemEncoder:
+
+    encoding_name: str
+
+    @classmethod
+    def _encode_chunk(
+        cls, intput: str, start: int
+    ) -> Tuple[Union[bytes, SymbolicBytes], int, Optional[ChunkError]]:
+        raise NotImplementedError
+
+    @classmethod
+    def _decode_chunk(
+        cls, intput: bytes, start: int
+    ) -> Tuple[Union[str, AnySymbolicStr], int, Optional[ChunkError]]:
+        raise NotImplementedError
+
+    @classmethod
+    def encode(
+        cls, input: str, errors: str = "strict"
+    ) -> Tuple[Union[bytes, SymbolicBytes], int]:
+        if not (isinstance(input, str) and isinstance(errors, str)):
+            raise TypeError
+        parts: List[bytes] = []
+        idx = 0
+        inputlen = len(input)
+        while idx < inputlen:
+            out, idx, err = cls._encode_chunk(input, idx)
+            parts.append(out)  # type: ignore
+            if err is not None:
+                realized_input = realize(input)  # TODO: avoid realization here.
+                # (which possibly requires implementing the error handlers in python)
+                exc = UnicodeEncodeError(
+                    cls.encoding_name, realized_input, idx, idx + 1, err.reason()
+                )
+                replacement, idx = codecs.lookup_error(errors)(exc)
+                if isinstance(replacement, str):
+                    replacement = codecs.encode(replacement, cls.encoding_name)
+                parts.append(replacement)
+        return b"".join(parts), idx
+
+    @classmethod
+    def decode(
+        cls, input: bytes, errors: str = "strict"
+    ) -> Tuple[Union[str, AnySymbolicStr], int]:
+        if not (isinstance(input, Buffer) and isinstance(errors, str)):
+            raise TypeError
+        parts: List[Union[str, AnySymbolicStr]] = []
+        idx = 0
+        inputlen = len(input)
+        while idx < inputlen:
+            out, idx, err = cls._decode_chunk(input, idx)
+            parts.append(out)
+            if err is not None:
+                # 1. Handle some well-known error modes directly:
+                if errors == "strict":
+                    raise _UnicodeDecodeError(
+                        cls.encoding_name, input, idx, idx + 1, err.reason()
+                    )
+                # TODO: continuation after erros seems poorly tested right now
+                if errors == "ignore":
+                    idx += 1
+                    continue
+                if errors == "replace":
+                    idx += 1
+                    parts.append("\ufffd")
+                    continue
+
+                # 2. Then fall back to native implementations if necessary:
+                exc = UnicodeDecodeError(
+                    cls.encoding_name, realize(input), idx, idx + 1, err.reason()
+                )
+                replacement, idx = codecs.lookup_error(errors)(exc)
+                if isinstance(replacement, bytes):
+                    replacement = codecs.decode(replacement, cls.encoding_name)
+                parts.append(replacement)
+        return "".join(parts), idx  # type: ignore
+
+    @classmethod
+    def getregentry(cls) -> codecs.CodecInfo:
+        return _getregentry(cls)
+
+
+def _getregentry(stem_encoder: Type[StemEncoder]):
+    class StemIncrementalEncoder(codecs.BufferedIncrementalEncoder):
+        def _buffer_encode(
+            self, input: str, errors: str, final: bool
+        ) -> Tuple[bytes, int]:
+            enc_name = stem_encoder.encoding_name
+            out, idx, err = stem_encoder._encode_chunk(input, 0)
+            assert isinstance(out, bytes)
+            if not err:
+                return (out, idx)
+            if isinstance(err, UnexpectedEndError) or not final:
+                return (out, idx)
+            exc = UnicodeEncodeError(enc_name, input, idx, idx + 1, err.reason())
+            replacement, idx = codecs.lookup_error(errors)(exc)
+            if isinstance(replacement, str):
+                replacement = codecs.encode(replacement, enc_name)
+            return (out + replacement, idx)
+
+    class StemIncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        def _buffer_decode(
+            self, input: Buffer, errors: str, final: bool
+        ) -> Tuple[str, int]:
+            if not isinstance(input, bytes):
+                input = memoryview(input).tobytes()
+            enc_name = stem_encoder.encoding_name
+            out, idx, err = stem_encoder._decode_chunk(input, 0)
+            assert isinstance(out, str)
+            if not err:
+                return out, idx
+            if isinstance(err, UnexpectedEndError) or not final:
+                return out, idx
+            exc = UnicodeDecodeError(enc_name, input, idx, idx + 1, err.reason())
+            replacement, idx = codecs.lookup_error(errors)(exc)
+            if isinstance(replacement, bytes):
+                replacement = codecs.decode(replacement, enc_name)
+            return (out + replacement, idx)
+
+    class StemStreamWriter(codecs.StreamWriter):
+        def encode(self, input: str, errors: str = "strict") -> Tuple[bytes, int]:
+            raise Exception  # TODO implement
+
+    class StemStreamReader(codecs.StreamReader):
+        def decode(self, input: bytes, errors: str = "strict") -> Tuple[str, int]:
+            raise Exception
+
+    return codecs.CodecInfo(
+        name=stem_encoder.encoding_name,
+        encode=stem_encoder.encode,  # type: ignore
+        decode=stem_encoder.decode,  # type: ignore
+        incrementalencoder=StemIncrementalEncoder,
+        incrementaldecoder=StemIncrementalDecoder,
+        streamreader=StemStreamReader,
+        streamwriter=StemStreamWriter,
+    )

crosshair/libimpl/encodings/ascii.py

@@ -0,0 +1,44 @@
+import codecs
+from typing import List, Optional, Tuple, Union
+
+from crosshair.libimpl.builtinslib import SymbolicBytes
+from crosshair.libimpl.encodings._encutil import ChunkError, MidChunkError, StemEncoder
+
+
+class AsciiStemEncoder(StemEncoder):
+    encoding_name = "ascii"
+
+    @classmethod
+    def _encode_chunk(
+        cls, string: str, start: int
+    ) -> Tuple[Union[bytes, SymbolicBytes], int, Optional[ChunkError]]:
+        byte_ints: List[int] = []
+        for idx in range(start, len(string)):
+            ch = string[idx]
+            cp = ord(ch)
+            if cp >= 0x80:
+                return (
+                    SymbolicBytes(byte_ints),
+                    idx,
+                    MidChunkError("ordinal not in range"),
+                )
+            else:
+                byte_ints.append(cp)
+        return (SymbolicBytes(byte_ints), len(string), None)
+
+    @classmethod
+    def _decode_chunk(
+        cls, byts: bytes, start: int
+    ) -> Tuple[str, int, Optional[ChunkError]]:
+        chars: List[str] = []
+        for idx in range(start, len(byts)):
+            cp = byts[idx]
+            if cp >= 0x80:
+                return ("".join(chars), idx, MidChunkError("ordinal not in range"))
+            else:
+                chars.append(chr(cp))
+        return ("".join(chars), len(byts), None)  # type: ignore
+
+
+def getregentry() -> codecs.CodecInfo:
+    return AsciiStemEncoder.getregentry()

crosshair/libimpl/encodings/latin_1.py

@@ -0,0 +1,40 @@
+import codecs
+from typing import List, Optional, Tuple, Union
+
+from crosshair.libimpl.builtinslib import SymbolicBytes
+from crosshair.libimpl.encodings._encutil import ChunkError, MidChunkError, StemEncoder
+
+
+class Latin1StemEncoder(StemEncoder):
+    encoding_name = "iso8859-1"
+
+    @classmethod
+    def _encode_chunk(
+        cls, string: str, start: int
+    ) -> Tuple[Union[bytes, SymbolicBytes], int, Optional[ChunkError]]:
+        byte_ints: List[int] = []
+        for idx in range(start, len(string)):
+            ch = string[idx]
+            cp = ord(ch)
+            if cp < 256:
+                byte_ints.append(cp)
+            else:
+                return (
+                    SymbolicBytes(byte_ints),
+                    idx,
+                    MidChunkError("bytes must be in range(0, 256)"),
+                )
+        return (SymbolicBytes(byte_ints), len(string), None)
+
+    @classmethod
+    def _decode_chunk(
+        cls, byts: bytes, start: int
+    ) -> Tuple[str, int, Optional[ChunkError]]:
+        chars: List[str] = []
+        for cp in byts[start:]:
+            chars.append(chr(cp))
+        return ("".join(chars), len(byts), None)
+
+
+def getregentry() -> codecs.CodecInfo:
+    return Latin1StemEncoder.getregentry()

crosshair/libimpl/encodings/utf_8.py

@@ -0,0 +1,93 @@
+import codecs
+from typing import List, Optional, Tuple, Union
+
+from crosshair.libimpl.builtinslib import SymbolicBytes
+from crosshair.libimpl.encodings._encutil import (
+    ChunkError,
+    MidChunkError,
+    StemEncoder,
+    UnexpectedEndError,
+)
+
+
+def _encode_codepoint(codepoint: int) -> Tuple[int, ...]:
+    if codepoint <= 0b01111111:
+        return (codepoint,)
+    elif codepoint <= 0b111_11111111:
+        return (
+            (0b11000000 + ((codepoint >> 6) & 0b00011111)),
+            (0b10000000 + (codepoint & 0b00111111)),
+        )
+    elif codepoint <= 0b11111111_11111111:
+        return (
+            (0b11100000 + ((codepoint >> 12) & 0b00001111)),
+            (0b10000000 + ((codepoint >> 6) & 0b00111111)),
+            (0b10000000 + (codepoint & 0b00111111)),
+        )
+    else:
+        return (
+            (0b11110000 + ((codepoint >> 18) & 0b00000111)),
+            (0b10000000 + ((codepoint >> 12) & 0b00111111)),
+            (0b10000000 + ((codepoint >> 6) & 0b00111111)),
+            (0b10000000 + (codepoint & 0b00111111)),
+        )
+
+
+class Utf8StemEncoder(StemEncoder):
+    encoding_name = "utf-8"
+
+    @classmethod
+    def _encode_chunk(
+        cls, string: str, start: int
+    ) -> Tuple[Union[bytes, SymbolicBytes], int, Optional[ChunkError]]:
+        byte_ints: List[int] = []
+        for ch in string[start:]:
+            byte_ints.extend(_encode_codepoint(ord(ch)))
+        return (SymbolicBytes(byte_ints), len(string), None)
+
+    @classmethod
+    def _decode_chunk(
+        cls, byts: bytes, start: int
+    ) -> Tuple[str, int, Optional[ChunkError]]:
+        num_bytes = len(byts)
+        byt = byts[start]
+        end = start + 1
+        if byt >= 0b11000000:
+            end += 1
+            if byt >= 0b11100000:
+                end += 1
+                if byt >= 0b11110000:
+                    if byt > 0b11110111:
+                        return ("", start, MidChunkError(f"can't decode byte"))
+                    end += 1
+                    cp = byt & 0b00000111
+                    mincp, maxcp = 0x10000, 0x10FFFF
+                else:
+                    if byt > 0b11101111:
+                        return ("", start, MidChunkError(f"can't decode byte"))
+                    cp = byt & 0b00001111
+                    mincp, maxcp = 0x0800, 0xFFFF
+            else:
+                if byt > 0b11011111:
+                    return ("", start, MidChunkError(f"can't decode byte"))
+                cp = byt & 0b00011111
+                mincp, maxcp = 0x0080, 0x07FF
+        else:
+            cp = byt
+            mincp, maxcp = 0, 0x007F
+        if end > num_bytes:
+            return ("", start, UnexpectedEndError())
+        for idx in range(start + 1, end):
+            byt = byts[idx]
+            if 0b10_000000 <= byt <= 0b10_111111:
+                cp = (cp * 64) + (byts[idx] - 0b10_000000)
+            else:
+                return ("", start, MidChunkError(f"can't decode byte"))
+        if mincp <= cp <= maxcp:
+            return (chr(cp), end, None)
+        else:
+            return ("", start, MidChunkError(f"invalid start byte"))
+
+
+def getregentry() -> codecs.CodecInfo:
+    return Utf8StemEncoder.getregentry()

crosshair/libimpl/encodings_ch_test.py

@@ -0,0 +1,83 @@
+import codecs
+import sys
+from io import BytesIO
+
+import pytest  # type: ignore
+
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.options import AnalysisOptionSet
+from crosshair.test_util import ResultComparison, compare_results
+
+_ERROR_HANDLERS = ["strict", "replace", "ignore"]
+
+# crosshair: max_iterations=20
+
+
+def check_encode_ascii(string: str, errors: str) -> ResultComparison:
+    """
+    pre: errors in _ERROR_HANDLERS
+    post: _
+    """
+    return compare_results(lambda s, e: s.encode("ascii", e), string, errors)
+
+
+def check_encode_latin1(string: str, errors: str) -> ResultComparison:
+    """
+    pre: errors in _ERROR_HANDLERS
+    post: _
+    """
+    return compare_results(lambda s, e: s.encode("latin1", e), string, errors)
+
+
+def check_encode_utf8(string: str, errors: str) -> ResultComparison:
+    """
+    pre: errors in _ERROR_HANDLERS
+    post: _
+    """
+    return compare_results(lambda s, e: s.encode("utf8", e), string, errors)
+
+
+def check_decode_ascii(bytestring: bytes, errors: str) -> ResultComparison:
+    """
+    pre: errors in _ERROR_HANDLERS
+    post: _
+    """
+    return compare_results(lambda b, e: b.decode("ascii", e), bytestring, errors)
+
+
+def check_decode_latin1(bytestring: bytes, errors: str) -> ResultComparison:
+    """
+    pre: errors in _ERROR_HANDLERS
+    post: _
+    """
+    return compare_results(lambda b, e: b.decode("latin1", e), bytestring, errors)
+
+
+def check_decode_utf8(bytestring: bytes, errors: str) -> ResultComparison:
+    """
+    pre: errors in _ERROR_HANDLERS
+    post: _
+    """
+    # crosshair: max_iterations=200
+    return compare_results(lambda b, e: b.decode("utf8", e), bytestring, errors)
+
+
+# TODO add handling for BytesIO(SymbolicBytes())
+# def check_stream_decode_utf8(bytestring: bytes, errors: str) -> ResultComparison:
+#     """
+#     pre: errors in _ERROR_HANDLERS
+#     post: _
+#     """
+#     def read_stream(b, e):
+#         return codecs.getreader("utf8")(BytesIO(b), e).read()
+#     return compare_results(read_stream, bytestring, errors)
+
+
+# This is the only real test definition.
+# It runs crosshair on each of the "check" functions defined above.
+@pytest.mark.parametrize("fn_name", [fn for fn in dir() if fn.startswith("check_")])
+def test_builtin(fn_name: str) -> None:
+    this_module = sys.modules[__name__]
+    messages = run_checkables(analyze_function(getattr(this_module, fn_name)))
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []

crosshair/libimpl/fractionlib.py

@@ -0,0 +1,16 @@
+from fractions import Fraction
+
+from crosshair.core import SymbolicFactory, register_type
+from crosshair.statespace import force_true
+from crosshair.tracers import ResumedTracing
+
+
+def _make_fraction(factory: SymbolicFactory):
+    n, d = factory(int, "_numerator"), factory(int, "_denominator")
+    with ResumedTracing():
+        force_true(d > 0)
+        return Fraction(n, d)
+
+
+def make_registrations() -> None:
+    register_type(Fraction, _make_fraction)