Promium 3.9.1__tar.gz → 3.9.2__tar.gz

{promium-3.9.1 → promium-3.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.9.1
+Version: 3.9.2
 Summary: Selenium wrapper for testing Web UI
 Author: Denis Korytkin, Nataliia Guieva, Roman Zaporozhets, Vladimir Kritov, Oleh Dykusha
 Project-URL: Home page, https://none

{promium-3.9.1 → promium-3.9.2}/Promium.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.9.1
+Version: 3.9.2
 Summary: Selenium wrapper for testing Web UI
 Author: Denis Korytkin, Nataliia Guieva, Roman Zaporozhets, Vladimir Kritov, Oleh Dykusha
 Project-URL: Home page, https://none

{promium-3.9.1 → promium-3.9.2}/Promium.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ doc/conf.py
 promium/__init__.py
 promium/_diag.py
 promium/_introspect.py
+promium/_soft_assert_rewrite.py
 promium/assertions.py
 promium/base.py
 promium/browsers.py

promium-3.9.2/promium/_introspect.py

@@ -0,0 +1,94 @@
+"""Formatting helpers for soft_assert error messages."""
+
+import difflib
+import os
+import pprint
+
+
+_NO_COLOR = bool(
+    os.environ.get("NO_COLOR")
+    or os.environ.get("PROMIUM_ASSERTION_PANEL_MONO_COLOR")
+)
+_RED = "" if _NO_COLOR else "\033[31m"
+_GREEN = "" if _NO_COLOR else "\033[32m"
+_YELLOW = "" if _NO_COLOR else "\033[1;33m"
+_BOLD = "" if _NO_COLOR else "\033[1m"
+_WHITE = "" if _NO_COLOR else "\033[1;37m"
+_RESET = "" if _NO_COLOR else "\033[0m"
+
+
+def _escape_control(s: str) -> str:
+    """Replace control characters with \\xNN escapes, keep Unicode as-is."""
+    return "".join(
+        f"\\x{ord(c):02x}" if ord(c) < 32 or ord(c) == 127 else c for c in s
+    )
+
+
+def _colorize_ndiff(left_lines: list[str], right_lines: list[str]) -> str:
+    """Return colorized ndiff output for two sequences of lines."""
+    colored = []
+    for line in difflib.ndiff(left_lines, right_lines):
+        stripped = line.rstrip("\n")
+        if line.startswith("- "):
+            colored.append(f"{_RED}{stripped}{_RESET}\n")
+        elif line.startswith("+ "):
+            colored.append(f"{_GREEN}{stripped}{_RESET}\n")
+        elif line.startswith("? "):
+            colored.append(f"{_YELLOW}{stripped}{_RESET}\n")
+        else:
+            colored.append(line)
+    return "".join(colored)
+
+
+def _repr_value(val: object) -> str:
+    """Return repr of a value, truncated to 200 chars."""
+    r = repr(val)
+    return r if len(r) <= 200 else r[:200] + "..."
+
+
+def _to_lines(obj: object) -> list[str]:
+    """Pretty-format *obj* into a list of lines ending with ``\\n``."""
+    fmt = pprint.PrettyPrinter(width=1, sort_dicts=False).pformat
+    lines = fmt(obj).splitlines(keepends=True)
+    if lines and not lines[-1].endswith("\n"):
+        lines[-1] += "\n"
+    return lines
+
+
+def format_sa_data(sa_data: tuple) -> str:
+    """Format captured ``_sa_data`` into a colorized error string."""
+    tag, _source, *rest = sa_data
+
+    if tag == "cmp":
+        op, left, right = rest
+        result = (
+            f"{_RED}{_repr_value(left)}{_RESET} "
+            f"{_BOLD}{op}{_RESET} "
+            f"{_GREEN}{_repr_value(right)}{_RESET}"
+        )
+        if (
+            op in {"==", "!="}
+            and isinstance(left, str)
+            and isinstance(right, str)
+        ):
+            esc = _escape_control
+            result += "\n" + _colorize_ndiff(
+                [esc(left) + "\n"],
+                [esc(right) + "\n"],
+            )
+        elif (
+            op in {"==", "!="}
+            and isinstance(left, (dict, list, tuple, set, frozenset))
+            and isinstance(right, (dict, list, tuple, set, frozenset))
+        ):
+            result += "\n" + _colorize_ndiff(
+                _to_lines(left),
+                _to_lines(right),
+            )
+        return result
+
+    if tag == "val":
+        (value,) = rest
+        return f"{_RED}{_repr_value(value)}{_RESET}"
+
+    return str(sa_data)

promium-3.9.2/promium/_soft_assert_rewrite.py

@@ -0,0 +1,249 @@
+"""AST rewriter for ``soft_assert`` calls.
+
+Transforms ``self.soft_assert(expr, ...)`` at **import time** so that
+sub-expressions are evaluated into temporary variables *before* the
+comparison.  The captured values are forwarded to ``soft_assert`` via
+the hidden ``_sa_data`` keyword argument, eliminating the need for
+runtime ``eval()`` and preventing double-evaluation of side-effecting
+expressions like ``list.pop()``.
+
+The rewriter is installed as an import hook via :func:`install` (called
+from ``promium.plugin.pytest_configure``).
+"""
+
+from __future__ import annotations
+import ast
+import contextlib
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    import types
+
+
+_COMPARE_OPS: dict[type, str] = {
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+    ast.Is: "is",
+    ast.IsNot: "is not",
+    ast.In: "in",
+    ast.NotIn: "not in",
+}
+
+
+class SoftAssertTransformer(ast.NodeTransformer):
+    """Rewrite ``self.soft_assert(expr, ...)`` into temp-var assignments
+    followed by a call that carries ``_sa_data`` with pre-computed values.
+    """
+
+    def __init__(self, source: str) -> None:
+        self._source = source
+        self._counter = 0
+        self.changed = False
+
+    def _tmp(self) -> str:
+        name = f"@_sa_{self._counter}"
+        self._counter += 1
+        return name
+
+    def _assign(self, name: str, value: ast.expr, donor: ast.AST) -> ast.Assign:
+        stmt = ast.Assign(
+            targets=[ast.Name(id=name, ctx=ast.Store())],
+            value=value,
+        )
+        ast.copy_location(stmt, donor)
+        ast.fix_missing_locations(stmt)
+        return stmt
+
+    def _finish(
+        self,
+        stmts: list[ast.stmt],
+        call: ast.Call,
+        new_first_arg: ast.expr,
+        sa_data: ast.Tuple,
+        donor: ast.AST,
+    ) -> list[ast.stmt]:
+        new_call = ast.Call(
+            func=call.func,
+            args=[new_first_arg, *call.args[1:]],
+            keywords=[
+                *call.keywords,
+                ast.keyword(arg="_sa_data", value=sa_data),
+            ],
+        )
+        stmt = ast.Expr(value=new_call)
+        ast.copy_location(stmt, donor)
+        ast.fix_missing_locations(stmt)
+        stmts.append(stmt)
+        return stmts
+
+    def visit_Expr(self, node: ast.Expr) -> ast.AST:
+        self.generic_visit(node)
+        call = node.value
+        if not (
+            isinstance(call, ast.Call)
+            and isinstance(call.func, ast.Attribute)
+            and call.func.attr == "soft_assert"
+            and call.args
+            and not any(kw.arg == "_sa_data" for kw in call.keywords)
+        ):
+            return node
+
+        expr_arg = call.args[0]
+        source = ast.get_source_segment(self._source, expr_arg) or ""
+        n = ast.Name
+
+        self.changed = True
+
+        if isinstance(expr_arg, ast.Compare) and len(expr_arg.ops) == 1:
+            ln, rn = self._tmp(), self._tmp()
+            stmts = [
+                self._assign(ln, expr_arg.left, node),
+                self._assign(rn, expr_arg.comparators[0], node),
+            ]
+            new_expr = ast.Compare(
+                left=n(id=ln, ctx=ast.Load()),
+                ops=list(expr_arg.ops),
+                comparators=[n(id=rn, ctx=ast.Load())],
+            )
+            op_str = _COMPARE_OPS.get(type(expr_arg.ops[0]), "??")
+            sa_data = ast.Tuple(
+                elts=[
+                    ast.Constant(value="cmp"),
+                    ast.Constant(value=source),
+                    ast.Constant(value=op_str),
+                    n(id=ln, ctx=ast.Load()),
+                    n(id=rn, ctx=ast.Load()),
+                ],
+                ctx=ast.Load(),
+            )
+        else:
+            vn = self._tmp()
+            stmts = [self._assign(vn, expr_arg, node)]
+            new_expr = n(id=vn, ctx=ast.Load())
+            sa_data = ast.Tuple(
+                elts=[
+                    ast.Constant(value="val"),
+                    ast.Constant(value=source),
+                    n(id=vn, ctx=ast.Load()),
+                ],
+                ctx=ast.Load(),
+            )
+
+        return self._finish(stmts, call, new_expr, sa_data, node)
+
+
+class _SoftAssertLoader(importlib.abc.Loader):
+    """Loader that compiles a module from AST-rewritten source."""
+
+    def __init__(self, origin: str) -> None:
+        self._origin = origin
+
+    def create_module(  # noqa: PLR6301
+        self,
+        spec: importlib.machinery.ModuleSpec,
+    ) -> None:
+        return None
+
+    def exec_module(self, module: types.ModuleType) -> None:
+        module.__file__ = self._origin
+        source = Path(self._origin).read_text("utf-8")
+
+        tree = ast.parse(source, filename=self._origin)
+        transformer = SoftAssertTransformer(source)
+        tree = transformer.visit(tree)
+
+        if transformer.changed:
+            ast.fix_missing_locations(tree)
+
+        try:
+            from _pytest.assertion.rewrite import rewrite_asserts
+
+            rewrite_asserts(tree, source.encode("utf-8"))
+        except Exception:  # noqa: BLE001
+            pass
+
+        code = compile(tree, self._origin, "exec")
+        exec(code, module.__dict__)  # noqa: S102
+
+
+class SoftAssertImportHook(importlib.abc.MetaPathFinder):
+    """Import hook that rewrites ``soft_assert`` calls in test modules."""
+
+    def __init__(self) -> None:
+        self._finding: set[str] = set()
+
+    def find_spec(
+        self,
+        name: str,
+        path: object = None,
+        target: object = None,
+    ) -> importlib.machinery.ModuleSpec | None:
+        if name in self._finding:
+            return None
+
+        parts = name.split(".")
+        last = parts[-1]
+        if not (last.startswith("test_") or last == "conftest"):
+            return None
+
+        self._finding.add(name)
+        try:
+            spec = importlib.util.find_spec(name)
+            if not (
+                spec
+                and spec.origin
+                and spec.origin.endswith(".py")
+                and Path(spec.origin).exists()
+            ):
+                return None
+
+            source = Path(spec.origin).read_text("utf-8")
+            if "soft_assert" not in source:
+                return None
+
+            new_spec = importlib.machinery.ModuleSpec(
+                name,
+                _SoftAssertLoader(spec.origin),
+                origin=spec.origin,
+                is_package=spec.submodule_search_locations is not None,
+            )
+            new_spec.has_location = True
+            if spec.submodule_search_locations is not None:
+                new_spec.submodule_search_locations = list(
+                    spec.submodule_search_locations,
+                )
+            return new_spec
+        except Exception:  # noqa: BLE001
+            return None
+        finally:
+            self._finding.discard(name)
+
+
+_hook_instance: SoftAssertImportHook | None = None
+
+
+def install() -> None:
+    """Install the import hook at the front of ``sys.meta_path``."""
+    global _hook_instance  # noqa: PLW0603
+    if _hook_instance is None:
+        _hook_instance = SoftAssertImportHook()
+        sys.meta_path.insert(0, _hook_instance)
+
+
+def uninstall() -> None:
+    """Remove the import hook from ``sys.meta_path``."""
+    global _hook_instance  # noqa: PLW0603
+    if _hook_instance is not None:
+        with contextlib.suppress(ValueError):
+            sys.meta_path.remove(_hook_instance)
+        _hook_instance = None

{promium-3.9.1 → promium-3.9.2}/promium/assertions.py

@@ -11,7 +11,7 @@ import urllib3
 from json_checker import Checker, CheckerError
 from selenium.webdriver.remote.webdriver import WebDriver as SeleniumWebDriver
 
-from promium._introspect import _RESET, _WHITE, extract_call_expression
+from promium._introspect import _RESET, _WHITE, format_sa_data
 from promium.common import upload_screenshot
 
 
@@ -161,10 +161,11 @@ class BaseSoftAssertion:
         msg: str | None = None,
         with_screen: bool = False,
         hard_assert: bool | None = None,
+        _sa_data: tuple | None = None,
     ) -> None:
         """Check that the expression is true."""
         if not expr:
-            source_expr = extract_call_expression("soft_assert")
+            source_expr = format_sa_data(_sa_data) if _sa_data else None
             parts = []
             if msg:
                 parts.append(f"{_WHITE}{msg}{_RESET}")

{promium-3.9.1 → promium-3.9.2}/promium/plugin.py

@@ -473,6 +473,10 @@ def pytest_runtest_makereport(item: pytest.Item, call: CallInfo) -> None:
 
 
 def pytest_configure(config: Config) -> None:
+    from promium._soft_assert_rewrite import install as _install_sa_hook
+
+    _install_sa_hook()
+
     os.environ["PYTHONWARNINGS"] = (
         "ignore:An HTTPS request has been made, "
         "ignore:A true SSLContext object is not available, "
@@ -489,3 +493,9 @@ def pytest_configure(config: Config) -> None:
         os.environ["CHECK_CONSOLE"] = "Enabled"
     if not getattr(config, "lastfailed_file", None):
         config.lastfailed_file = "lastfailed"
+
+
+def pytest_unconfigure(config: Config) -> None:
+    from promium._soft_assert_rewrite import uninstall as _uninstall_sa_hook
+
+    _uninstall_sa_hook()

{promium-3.9.1 → promium-3.9.2}/pyproject.toml

@@ -104,6 +104,8 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = ["ANN", "PT011", "PLC0415", "I001"]
 "promium/test_case.py" = ["I001"]  # conflict between isort and Python standard for from __future__ imports
+"promium/plugin.py" = ["PLC0415"]
+"promium/_soft_assert_rewrite.py" = ["I001", "PLC0415", "PLC2701", "N802"]
 
 [tool.ruff.lint.isort.sections]
 STDLIB = ["STDLIB"]

{promium-3.9.1 → promium-3.9.2}/setup.py

@@ -19,7 +19,7 @@ LONG_DESCRIPTION = Path("README.rst").read_text(encoding="utf-8")
 
 setup(
     name="Promium",
-    version="3.9.1",
+    version="3.9.2",
     install_requires=REQUIREMENTS,
     author=(
         "Denis Korytkin, Nataliia Guieva, "

promium-3.9.1/promium/_introspect.py

@@ -1,206 +0,0 @@
-"""AST-based expression introspection for soft_assert.
-
-Extracts the source expression from a ``soft_assert(...)`` call,
-substitutes runtime values, and returns a colorized string with
-a diff (for strings and containers) similar to pytest assertion output.
-"""
-
-import ast
-import difflib
-import inspect
-import os
-import pprint
-from pathlib import Path
-from typing import Any
-
-
-_SENTINEL = object()
-
-_COMPARE_OPS = {
-    ast.Eq: "==",
-    ast.NotEq: "!=",
-    ast.Lt: "<",
-    ast.LtE: "<=",
-    ast.Gt: ">",
-    ast.GtE: ">=",
-    ast.Is: "is",
-    ast.IsNot: "is not",
-    ast.In: "in",
-    ast.NotIn: "not in",
-}
-
-_NO_COLOR = bool(
-    os.environ.get("NO_COLOR")
-    or os.environ.get("PROMIUM_ASSERTION_PANEL_MONO_COLOR")
-)
-_RED = "" if _NO_COLOR else "\033[31m"
-_GREEN = "" if _NO_COLOR else "\033[32m"
-_YELLOW = "" if _NO_COLOR else "\033[1;33m"
-_BOLD = "" if _NO_COLOR else "\033[1m"
-_WHITE = "" if _NO_COLOR else "\033[1;37m"
-_RESET = "" if _NO_COLOR else "\033[0m"
-
-
-def _escape_control(s: str) -> str:
-    """Replace control characters with \\xNN escapes, keep Unicode as-is."""
-    return "".join(
-        f"\\x{ord(c):02x}" if ord(c) < 32 or ord(c) == 127 else c for c in s
-    )
-
-
-def _colorize_ndiff(left_lines: list[str], right_lines: list[str]) -> str:
-    """Return colorized ndiff output for two sequences of lines."""
-    colored = []
-    for line in difflib.ndiff(left_lines, right_lines):
-        stripped = line.rstrip("\n")
-        if line.startswith("- "):
-            colored.append(f"{_RED}{stripped}{_RESET}\n")
-        elif line.startswith("+ "):
-            colored.append(f"{_GREEN}{stripped}{_RESET}\n")
-        elif line.startswith("? "):
-            colored.append(f"{_YELLOW}{stripped}{_RESET}\n")
-        else:
-            colored.append(line)
-    return "".join(colored)
-
-
-def extract_call_expression(method_name: str) -> str | None:
-    """Extract the first argument source from a call to *method_name*
-    and rebuild it with runtime values substituted.
-
-    Example: ``self.soft_assert(code in var)``
-    where code='23', var=[1,2,3] → ``"'23' in [1, 2, 3]"``
-    """
-    try:
-        caller = inspect.currentframe().f_back.f_back
-        source = Path(caller.f_code.co_filename).read_text(encoding="utf-8")
-
-        for node in ast.walk(ast.parse(source)):
-            if not (
-                isinstance(node, ast.Call)
-                and isinstance(node.func, ast.Attribute)
-                and node.func.attr == method_name
-                and node.args
-                and node.lineno
-                <= caller.f_lineno
-                <= (node.end_lineno or node.lineno)
-            ):
-                continue
-
-            expr_node = node.args[0]
-            expr_source = ast.get_source_segment(source, expr_node)
-            if not expr_source:
-                return None
-
-            def _may_have_side_effect(node: ast.expr) -> bool:
-                if isinstance(node, ast.Call):
-                    return True
-                if isinstance(node, ast.Attribute):
-                    if _may_have_side_effect(node.value):
-                        return True
-                    val_src = ast.get_source_segment(source, node.value)
-                    if val_src:
-                        try:
-                            obj = eval(
-                                val_src, caller.f_globals, caller.f_locals
-                            )  # noqa: S307
-                            if isinstance(
-                                getattr(type(obj), node.attr, None),
-                                property,
-                            ):
-                                return True
-                        except Exception:
-                            pass
-                    return False
-                return any(
-                    _may_have_side_effect(child)
-                    for child in ast.iter_child_nodes(node)
-                    if isinstance(child, ast.expr)
-                )
-
-            def _try_eval(operand: ast.expr) -> Any:
-                """Return the runtime value or _SENTINEL if eval fails."""
-                if _may_have_side_effect(operand):
-                    return _SENTINEL
-                src = ast.get_source_segment(source, operand)
-                if not src:
-                    return _SENTINEL
-                try:
-                    return eval(src, caller.f_globals, caller.f_locals)  # noqa: S307
-                except Exception:
-                    return _SENTINEL
-
-            def _eval_operand(operand: ast.expr) -> str:
-                """Return repr(value) if eval succeeds, otherwise source text."""
-                val = _try_eval(operand)
-                if val is _SENTINEL:
-                    return ast.get_source_segment(source, operand) or "?"
-                r = repr(val)
-                return r if len(r) <= 200 else r[:200] + "..."
-
-            if isinstance(expr_node, ast.Compare):
-                left_repr = _eval_operand(expr_node.left)
-                parts = [f"{_RED}{left_repr}{_RESET}"]
-                for cmp_op, comp in zip(expr_node.ops, expr_node.comparators):
-                    op_str = _COMPARE_OPS.get(type(cmp_op), "??")
-                    parts.append(f"{_BOLD}{op_str}{_RESET}")
-                    parts.append(f"{_GREEN}{_eval_operand(comp)}{_RESET}")
-                result = " ".join(parts)
-
-                if len(expr_node.ops) == 1 and isinstance(
-                    expr_node.ops[0], (ast.Eq, ast.NotEq)
-                ):
-                    left_val = _try_eval(expr_node.left)
-                    right_val = _try_eval(expr_node.comparators[0])
-                    if isinstance(left_val, str) and isinstance(right_val, str):
-                        esc = _escape_control
-                        result += "\n" + _colorize_ndiff(
-                            [esc(left_val) + "\n"],
-                            [esc(right_val) + "\n"],
-                        )
-                    elif (
-                        left_val is not _SENTINEL
-                        and right_val is not _SENTINEL
-                        and isinstance(
-                            left_val,
-                            (dict, list, tuple, set, frozenset),
-                        )
-                        and isinstance(
-                            right_val,
-                            (dict, list, tuple, set, frozenset),
-                        )
-                    ):
-                        fmt = pprint.PrettyPrinter(
-                            width=1, sort_dicts=False
-                        ).pformat
-                        left_lines = fmt(left_val).splitlines(keepends=True)
-                        right_lines = fmt(right_val).splitlines(keepends=True)
-                        if left_lines and not left_lines[-1].endswith("\n"):
-                            left_lines[-1] += "\n"
-                        if right_lines and not right_lines[-1].endswith("\n"):
-                            right_lines[-1] += "\n"
-                        result += "\n" + _colorize_ndiff(left_lines, right_lines)
-                return result
-
-            if isinstance(expr_node, ast.BoolOp):
-                op_str = " and " if isinstance(expr_node.op, ast.And) else " or "
-                colored_parts = []
-                for v in expr_node.values:
-                    val = _try_eval(v)
-                    operand_str = _eval_operand(v)
-                    if val is _SENTINEL:
-                        colored_parts.append(operand_str)
-                    elif val:
-                        colored_parts.append(f"{_GREEN}{operand_str}{_RESET}")
-                    else:
-                        colored_parts.append(f"{_RED}{operand_str}{_RESET}")
-                return (f"{_BOLD}{op_str}{_RESET}").join(colored_parts)
-
-            val = _try_eval(expr_node)
-            operand_str = _eval_operand(expr_node)
-            if val is not _SENTINEL and not val:
-                return f"{_RED}{operand_str}{_RESET}"
-            return operand_str
-    except Exception:
-        pass
-    return None