cot-assert 0.1.0__py2.py3-none-any.whl

cot_assert/_unparse.py

@@ -0,0 +1,180 @@
+"""Expression source text for labels, identical on Python 2.7 and 3.x.
+
+``ast.unparse`` does not exist on 2.7 and its output drifts between 3.x
+releases; labels end up in prebuilt RPython constants and in test
+expectations, so they come from here on every version.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+_BINOP = {
+    "Add": ("+", 11),
+    "Sub": ("-", 11),
+    "Mult": ("*", 12),
+    "MatMult": ("@", 12),
+    "Div": ("/", 12),
+    "FloorDiv": ("//", 12),
+    "Mod": ("%", 12),
+    "Pow": ("**", 14),
+    "LShift": ("<<", 10),
+    "RShift": (">>", 10),
+    "BitOr": ("|", 7),
+    "BitXor": ("^", 8),
+    "BitAnd": ("&", 9),
+}
+_UNARY = {"Not": ("not ", 4), "Invert": ("~", 13), "USub": ("-", 13), "UAdd": ("+", 13)}
+_CMP = {
+    "Eq": "==",
+    "NotEq": "!=",
+    "Lt": "<",
+    "LtE": "<=",
+    "Gt": ">",
+    "GtE": ">=",
+    "Is": "is",
+    "IsNot": "is not",
+    "In": "in",
+    "NotIn": "not in",
+}
+_BOOL = {"And": ("and", 3), "Or": ("or", 2)}
+_ATOM = 16
+
+
+def cmpop(op):
+    return _CMP[type(op).__name__]
+
+
+def binop(op):
+    return _BINOP[type(op).__name__][0]
+
+
+def unaryop(op):
+    return _UNARY[type(op).__name__][0]
+
+
+def unparse(node):
+    return _unparse(node)[0]
+
+
+def _wrap(node, minimum):
+    text, prec = _unparse(node)
+    if prec < minimum:
+        return "(" + text + ")"
+    return text
+
+
+def _unparse(node):
+    kind = type(node).__name__
+    if kind == "Name":
+        return node.id, _ATOM
+    if kind in ("Constant", "NameConstant"):
+        if node.value is Ellipsis:
+            return "...", _ATOM
+        return repr(node.value), _ATOM
+    if kind == "Num":
+        return repr(node.n), _ATOM
+    if kind in ("Str", "Bytes"):
+        return repr(node.s), _ATOM
+    if kind == "Attribute":
+        return _wrap(node.value, _ATOM) + "." + node.attr, _ATOM
+    if kind == "Call":
+        return _wrap(node.func, _ATOM) + "(" + ", ".join(_call_args(node)) + ")", _ATOM
+    if kind == "Subscript":
+        return _wrap(node.value, _ATOM) + "[" + _slice(node.slice) + "]", _ATOM
+    if kind == "BinOp":
+        op, prec = _BINOP[type(node.op).__name__]
+        # ** is right associative, everything else left
+        if op == "**":
+            left, right = _wrap(node.left, prec + 1), _wrap(node.right, prec)
+        else:
+            left, right = _wrap(node.left, prec), _wrap(node.right, prec + 1)
+        return left + " " + op + " " + right, prec
+    if kind == "UnaryOp":
+        op, prec = _UNARY[type(node.op).__name__]
+        return op + _wrap(node.operand, prec), prec
+    if kind == "Compare":
+        parts = [_wrap(node.left, 6)]
+        for op, comparator in zip(node.ops, node.comparators):
+            parts.append(cmpop(op))
+            parts.append(_wrap(comparator, 6))
+        return " ".join(parts), 5
+    if kind == "BoolOp":
+        op, prec = _BOOL[type(node.op).__name__]
+        return (" " + op + " ").join(_wrap(v, prec + 1) for v in node.values), prec
+    if kind == "IfExp":
+        return (
+            _wrap(node.body, 2)
+            + " if "
+            + _wrap(node.test, 2)
+            + " else "
+            + _wrap(node.orelse, 1)
+        ), 1
+    if kind == "Lambda":
+        return "lambda: ...", 0
+    if kind == "Tuple":
+        items = [unparse(e) for e in node.elts]
+        if len(items) == 1:
+            return "(" + items[0] + ",)", _ATOM
+        return "(" + ", ".join(items) + ")", _ATOM
+    if kind == "List":
+        return "[" + ", ".join(unparse(e) for e in node.elts) + "]", _ATOM
+    if kind == "Set":
+        return "{" + ", ".join(unparse(e) for e in node.elts) + "}", _ATOM
+    if kind == "Dict":
+        items = []
+        for k, v in zip(node.keys, node.values):
+            if k is None:
+                items.append("**" + _wrap(v, _ATOM))
+            else:
+                items.append(unparse(k) + ": " + unparse(v))
+        return "{" + ", ".join(items) + "}", _ATOM
+    if kind == "Starred":
+        return "*" + _wrap(node.value, _ATOM), _ATOM
+    if kind == "Repr":
+        return "`" + unparse(node.value) + "`", _ATOM
+    if kind in ("ListComp", "SetComp", "GeneratorExp", "DictComp"):
+        return {"ListComp": "[...]", "SetComp": "{...}", "DictComp": "{...}"}.get(
+            kind, "(...)"
+        ), _ATOM
+    if kind == "NamedExpr":
+        return unparse(node.target) + " := " + _wrap(node.value, 1), 0
+    return "<%s>" % kind, _ATOM
+
+
+def _call_args(node):
+    args = [unparse(a) for a in node.args]
+    starargs = getattr(node, "starargs", None)
+    if starargs is not None:
+        args.append("*" + unparse(starargs))
+    for kw in node.keywords:
+        if kw.arg is None:
+            args.append("**" + unparse(kw.value))
+        else:
+            args.append(kw.arg + "=" + unparse(kw.value))
+    kwargs = getattr(node, "kwargs", None)
+    if kwargs is not None:
+        args.append("**" + unparse(kwargs))
+    return args
+
+
+def _slice(node):
+    kind = type(node).__name__
+    if kind == "Index":
+        return _slice(node.value)
+    if kind == "Slice":
+        text = ""
+        if node.lower is not None:
+            text += unparse(node.lower)
+        text += ":"
+        if node.upper is not None:
+            text += unparse(node.upper)
+        if node.step is not None:
+            text += ":" + unparse(node.step)
+        return text
+    if kind == "ExtSlice":
+        return ", ".join(_slice(d) for d in node.dims)
+    if kind == "Tuple" and node.elts:
+        return ", ".join(_slice(e) for e in node.elts)
+    return unparse(node)
+
+
+__all__ = ["binop", "cmpop", "unaryop", "unparse"]

cot_assert/_values.py

@@ -0,0 +1,30 @@
+"""Capturing values at the point an assert fails."""
+
+from __future__ import absolute_import, division, print_function
+
+from ._rpy import float_repr, specialize, we_are_translated
+
+
+@specialize.argtype(0)
+def value(obj):
+    """Host: the object itself. Translated: its RPython-level repr."""
+    if we_are_translated():
+        return rpy_repr(obj)
+    return obj
+
+
+@specialize.argtype(0)
+def rpy_repr(obj):
+    if obj is None:
+        return "None"
+    if isinstance(obj, bool):
+        if obj:
+            return "True"
+        return "False"
+    if isinstance(obj, int):
+        return str(obj)
+    if isinstance(obj, float):
+        return float_repr(obj)
+    if isinstance(obj, str):
+        return "'" + obj + "'"
+    return "<object>"

cot_assert/pytest_plugin.py

@@ -0,0 +1,140 @@
+"""pytest plugin: cot_assert in place of pytest's assertion rewriter.
+
+Off unless enabled with ``--cot-assert`` or ``cot_assert = true`` in the ini
+file. pytest keeps choosing which files to rewrite (test files, conftests,
+``register_assert_rewrite``) and keeps caching them; only the rewriting
+itself is swapped, and the cache name changes so neither rewriter picks up
+the other's bytecode. Works with pytest 4.6 (Python 2.7) and current pytest.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import pytest
+
+from . import _hook, _render
+from ._error import AnnotatedAssertion
+from ._rewrite import rewrite_asserts
+
+FINALIZE_MODES = ("message", "notes")
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("cot_assert")
+    group.addoption(
+        "--cot-assert",
+        action="store_true",
+        default=None,
+        help="rewrite asserts with cot_assert instead of pytest's rewriter",
+    )
+    parser.addini(
+        "cot_assert",
+        type="bool",
+        default=False,
+        help="rewrite asserts with cot_assert instead of pytest's rewriter",
+    )
+    parser.addini(
+        "cot_assert_finalize",
+        default="message",
+        help="where a failed assert's explanation goes: message or notes",
+    )
+
+
+def _enabled(config):
+    # during pytest_load_initial_conftests only the early parse has run
+    option = getattr(config.known_args_namespace, "cot_assert", None)
+    if option is not None:
+        return option
+    return config.getini("cot_assert")
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_load_initial_conftests(early_config, parser, args):
+    # before pytest imports (and rewrites) the first conftest
+    if not _enabled(early_config):
+        return
+    mode = early_config.getini("cot_assert_finalize")
+    if mode not in FINALIZE_MODES:
+        raise pytest.UsageError(
+            "cot_assert_finalize must be one of %s, not %r"
+            % (", ".join(FINALIZE_MODES), mode)
+        )
+    patch = _PytestPatch(mode)
+    patch.apply()
+    early_config.pluginmanager.register(patch, "cot_assert_active")
+    early_config.add_cleanup(patch.undo)
+
+
+class _PytestPatch(object):
+    def __init__(self, finalize_mode):
+        self.finalize_mode = finalize_mode
+        self.saved = []
+
+    def apply(self):
+        from _pytest.assertion import rewrite as pytest_rewrite
+
+        self._set(pytest_rewrite, "rewrite_asserts", _pytest_rewrite_asserts)
+        self._set(
+            pytest_rewrite,
+            "PYC_TAIL",
+            pytest_rewrite.PYC_TAIL.replace(
+                pytest_rewrite.PYC_EXT, "-" + _hook.CACHE_TAG + pytest_rewrite.PYC_EXT
+            ),
+        )
+        self.previous_formatter = _render.set_formatter(PytestFormatter())
+
+    def _set(self, obj, name, value):
+        self.saved.append((obj, name, getattr(obj, name)))
+        setattr(obj, name, value)
+
+    def undo(self):
+        while self.saved:
+            obj, name, value = self.saved.pop()
+            setattr(obj, name, value)
+        _render.set_formatter(self.previous_formatter)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(self, item, call):
+        # render while pytest's comparison hook and config are still set,
+        # before the report turns the exception into text
+        excinfo = call.excinfo
+        if excinfo is not None and isinstance(excinfo.value, AnnotatedAssertion):
+            excinfo.value.finalize(self.finalize_mode)
+        yield
+
+    def pytest_report_header(self, config):
+        return "cot_assert: rewriting asserts (finalize into %s)" % (
+            self.finalize_mode,
+        )
+
+
+def _pytest_rewrite_asserts(mod, *args, **kwargs):
+    # pytest 4.6: (mod, module_path, config); current: (mod, source, path, config)
+    rewrite_asserts(mod)
+
+
+class PytestFormatter(_render.Formatter):
+    """Formatting through pytest's own helpers, as its rewriter does."""
+
+    def saferepr(self, obj):
+        from _pytest.assertion.rewrite import _saferepr
+
+        return _saferepr(obj)
+
+    def format_assertmsg(self, obj):
+        from _pytest.assertion.rewrite import _format_assertmsg
+
+        # pytest doubles % for the %-formatting its template goes through;
+        # nothing formats this text again
+        return _format_assertmsg(obj).replace("%%", "%")
+
+    def format_explanation(self, explanation):
+        from _pytest.assertion.util import format_explanation
+
+        return format_explanation(explanation)
+
+    def reprcompare(self, op, left, right):
+        from _pytest.assertion import util
+
+        if util._reprcompare is None:
+            return None
+        return util._reprcompare(op, left, right)

cot_assert-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.5
+Name: cot-assert
+Version: 0.1.0
+Summary: assertion rewriting with a structured AssertionError, for Python 2.7, 3.x and RPython
+Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
+License-Expression: MPL-2.0
+License-File: LICENSE
+Keywords: assert,pytest,rpython
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*,!=3.8.*,>=2.7
+Description-Content-Type: text/markdown
+
+# cot-assert
+
+Assertion rewriting that raises a structured `AnnotatedAssertion`, for Python
+2.7, Python 3.9+ and RPython. Intended as a drop-in replacement for pytest's
+assertion rewriting on current pytest and on pytest 4.6.
+
+Pre-alpha.
+
+```
+pip install cot-assert
+```
+
+One universal wheel serves Python 2.7 (pip 20 and later, CPython or PyPy)
+and Python 3.9 and later. It has no dependencies.
+
+## With pytest
+
+Installing the package registers a pytest plugin that stays off until
+enabled:
+
+```ini
+[pytest]
+cot_assert = true
+# where a failed assert's explanation goes: message (default) or notes
+cot_assert_finalize = message
+```
+
+or `pytest --cot-assert`. On Python 2.7, where it runs from source, load it
+with `-p cot_assert.pytest_plugin`.
+
+pytest still decides which modules are rewritten (test files, conftests,
+`pytest.register_assert_rewrite`) and caches them under a separate name;
+cot_assert does the rewriting, and failures render through pytest's own
+comparison hooks. Failures show as `AnnotatedAssertion` instead of
+`AssertionError`. `--assert=plain` turns rewriting off for both.
+
+## Without pytest
+
+```python
+import cot_assert
+
+cot_assert.install(["mypackage", "test_*"])
+```
+
+rewrites modules imported afterwards whose name matches.

cot_assert-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+cot_assert/__init__.py,sha256=cEb8TqnJ1XTtAFuAAxnDq7fpFX7MZ_cr16q0Sudbrik,582
+cot_assert/_entry.py,sha256=x-a-3vo6uRDgK27X7EcPIKNyvt50viHuG1HNeE2G6xE,983
+cot_assert/_error.py,sha256=L_Y52SFTPjWvwxPnIUZI-dKyD1725XPBWZ5M0YwDOkc,5425
+cot_assert/_hook.py,sha256=JVA6A7_bHMQpQ_zUJoQyzmcXD6aota-9rmsc-1GJToc,7332
+cot_assert/_llexc.py,sha256=VftW_Ktg-tXs5qXoR2SA04RVfGilRsQEwsbHqKRphFI,2582
+cot_assert/_render.py,sha256=8C1wUUVlj9XRber8zxDIN3T1BivhQVr4WGZxnRIitks,9682
+cot_assert/_rewrite.py,sha256=g1n0kWm6sbXJXldwp5jYi0YzypILBLBwDbst_NAQq6s,17613
+cot_assert/_rpy.py,sha256=NC3d5VMqUgrg-nJTdPPPIPPaZquKPRUmcd8wWWB1VN8,957
+cot_assert/_runtime.py,sha256=3_BimWc_RfkVZCwIUGTOc2ndfQawkUcWEFpUbekhE-o,334
+cot_assert/_unparse.py,sha256=Yq1oGl07BQ3HcleCpx_920PU6vPoZP183iPUe29Dmgo,5541
+cot_assert/_values.py,sha256=IMmaZUoE_ioyuFZQU_H4qo55QgAGGL2l1A_fU9ovzu8,742
+cot_assert/pytest_plugin.py,sha256=v4xGIxgkjUHgR7SYIXlwHGGo9PJnx0WAeRrf8syutLM,4637
+cot_assert-0.1.0.dist-info/METADATA,sha256=SSLQsZ0ZnZXoTZRn131SRuoo5A2M2kbRSw6dfw221CI,2312
+cot_assert-0.1.0.dist-info/WHEEL,sha256=DnXx7cBEyVTTMvhePCuz2Now68IkDfyaQ4wNff8GnEk,105
+cot_assert-0.1.0.dist-info/entry_points.txt,sha256=cyZBmXtGq7G82iJQy0Mhmqrq3gui0OkDetFeObZrXaM,49
+cot_assert-0.1.0.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+cot_assert-0.1.0.dist-info/RECORD,,

cot_assert-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

cot_assert-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+cot_assert = cot_assert.pytest_plugin