pytest-revealtype-injector 0.2.3__tar.gz → 0.4.0__tar.gz

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-revealtype-injector
-Version: 0.2.3
+Version: 0.4.0
 Summary: Pytest plugin for replacing reveal_type() calls inside test functions with static and runtime type checking result comparison, for confirming type annotation validity.
 Project-URL: homepage, https://github.com/abelcheung/pytest-revealtype-injector
 Author-email: Abel Cheung <abelcheung@gmail.com>
@@ -21,11 +21,13 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: basedpyright>=1.0
 Requires-Dist: mypy>=1.11.2
-Requires-Dist: pyright~=1.1
-Requires-Dist: pytest>=7.0
+Requires-Dist: pyright>=1.1
+Requires-Dist: pytest<9,>=7.0
 Requires-Dist: schema==0.7.7
-Requires-Dist: typeguard~=4.3
+Requires-Dist: typeguard>=4.3
+Requires-Dist: typing-extensions>=4.0; python_version < '3.11'
 Description-Content-Type: text/markdown
 
 ![PyPI - Version](https://img.shields.io/pypi/v/pytest-revealtype-injector)

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.4.0}/pyproject.toml

@@ -15,10 +15,12 @@ requires-python = '>=3.10'
 license = 'MIT'
 license-files = ['COPYING*']
 dependencies = [
+    'typing_extensions >= 4.0; python_version < "3.11"',
     'mypy >= 1.11.2',
-    'pyright ~= 1.1',
-    'pytest >= 7.0',
-    'typeguard ~= 4.3',
+    'pyright >= 1.1',
+    'basedpyright >= 1.0',
+    'pytest >=7.0,<9',
+    'typeguard >= 4.3',
     # schema with annotation support is still unreleased
     'schema == 0.7.7',
 ]
@@ -58,9 +60,6 @@ homepage = 'https://github.com/abelcheung/pytest-revealtype-injector'
 [project.entry-points.pytest11]
 pytest-revealtype-injector = "pytest_revealtype_injector.plugin"
 
-[tool.flit.module]
-name = 'pytest_revealtype_injector'
-
 [tool.hatch.version]
 path = 'src/pytest_revealtype_injector/__init__.py'
 
@@ -92,10 +91,9 @@ target-version = "py312"
 preview = true
 
 [tool.ruff.lint]
-select = [
-    'E',
-    'F',
-    'I',
+select = ['E', 'F', 'I']
+ignore = [
+    "E501",
 ]
 task-tags = [
     "BUG",

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.4.0}/src/pytest_revealtype_injector/__init__.py

@@ -1,3 +1,3 @@
 """Pytest plugin for replacing reveal_type() calls inside test functions with static and runtime type checking result comparison, for confirming type annotation validity."""  # noqa: E501
 
-__version__ = "0.2.3"
+__version__ = "0.4.0"

pytest_revealtype_injector-0.4.0/src/pytest_revealtype_injector/adapter/__init__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from ..models import TypeCheckerAdapter
+from . import basedpyright_, mypy_, pyright_
+
+
+# Hardcode will do for now, it's not like we're going to have more
+# adapters soon. Pyre and PyType are not there yet.
+def generate() -> set[TypeCheckerAdapter]:
+    return {
+        basedpyright_.generate_adapter(),
+        pyright_.generate_adapter(),
+        mypy_.generate_adapter(),
+    }
+
+
+def get_adapter_classes() -> list[type[TypeCheckerAdapter]]:
+    return [
+        basedpyright_.BasedPyrightAdapter,
+        pyright_.PyrightAdapter,
+        mypy_.MypyAdapter,
+    ]

pytest_revealtype_injector-0.4.0/src/pytest_revealtype_injector/adapter/basedpyright_.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from ..log import get_logger
+from ..models import TypeCheckerAdapter
+from . import pyright_
+
+_logger = get_logger()
+
+
+class NameCollector(pyright_.NameCollector):
+    type_checker = "basedpyright"
+
+
+class BasedPyrightAdapter(pyright_.PyrightAdapter):
+    id = "basedpyright"
+    _executable = "basedpyright"
+    _namecollector_class = NameCollector
+
+
+def generate_adapter() -> TypeCheckerAdapter:
+    return BasedPyrightAdapter()

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.4.0}/src/pytest_revealtype_injector/adapter/mypy_.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import ast
 import importlib
 import json
@@ -7,7 +9,6 @@ from collections.abc import (
     Iterable,
 )
 from typing import (
-    Any,
     ForwardRef,
     Literal,
     TypedDict,
@@ -15,7 +16,6 @@ from typing import (
 )
 
 import mypy.api
-import pytest
 import schema as s
 
 from ..log import get_logger
@@ -40,7 +40,9 @@ class _MypyDiagObj(TypedDict):
     severity: Literal["note", "warning", "error"]
 
 
-class _NameCollector(NameCollectorBase):
+class NameCollector(NameCollectorBase):
+    type_checker = "mypy"
+
     def visit_Attribute(self, node: ast.Attribute) -> ast.expr:
         prefix = ast.unparse(node.value)
         name = node.attr
@@ -69,7 +71,9 @@ class _NameCollector(NameCollectorBase):
         if resolved := getattr(self.collected[prefix], name, False):
             code = ast.unparse(node)
             self.collected[code] = resolved
-            _logger.debug(f"Mypy NameCollector resolved '{code}' as {resolved}")
+            _logger.debug(
+                f"{self.type_checker} NameCollector resolved '{code}' as {resolved}"
+            )
             return node
 
         # For class defined in local scope, mypy just prepends test
@@ -102,13 +106,17 @@ class _NameCollector(NameCollectorBase):
             pass
         else:
             self.collected[name] = mod
-            _logger.debug(f"Mypy NameCollector resolved '{name}' as {mod}")
+            _logger.debug(
+                f"{self.type_checker} NameCollector resolved '{name}' as {mod}"
+            )
             return node
 
         if hasattr(self.collected["typing"], name):
             obj = getattr(self.collected["typing"], name)
             self.collected[name] = obj
-            _logger.debug(f"Mypy NameCollector resolved '{name}' as {obj}")
+            _logger.debug(
+                f"{self.type_checker} NameCollector resolved '{name}' as {obj}"
+            )
             return node
 
         raise NameError(f'Cannot resolve "{name}"')
@@ -118,17 +126,17 @@ class _NameCollector(NameCollectorBase):
     # Return only the left operand after processing.
     def visit_BinOp(self, node: ast.BinOp) -> ast.expr:
         if isinstance(node.op, ast.MatMult) and isinstance(node.right, ast.Constant):
-            # Mypy disallows returning Any
             return cast("ast.expr", self.visit(node.left))
         # For expression that haven't been accounted for, just don't
         # process and allow name resolution to fail
         return node
 
 
-class _MypyAdapter(TypeCheckerAdapter):
+class MypyAdapter(TypeCheckerAdapter):
     id = "mypy"
-    typechecker_result = {}
-    _type_mesg_re = re.compile(r'^Revealed type is "(?P<type>.+?)"$')
+    _executable = ""  # unused, calls mypy.api.run() here
+    _type_mesg_re = re.compile(r'Revealed type is "(?P<type>.+?)"')
+    _namecollector_class = NameCollector
     _schema = s.Schema({
         "file": str,
         "line": int,
@@ -143,19 +151,20 @@ class _MypyAdapter(TypeCheckerAdapter):
         ),
     })
 
-    @classmethod
-    def run_typechecker_on(cls, paths: Iterable[pathlib.Path]) -> None:
+    def run_typechecker_on(self, paths: Iterable[pathlib.Path]) -> None:
         mypy_args = [
             "--output=json",
         ]
-        if cls.config_file is not None:
-            cfg_str = str(cls.config_file)
-            if cfg_str == ".":  # see set_config_file() below
-                cfg_str = ""
+        if self.config_file is not None:
+            if self.config_file == pathlib.Path():
+                cfg_str = ""  # see preprocess_config_file() below
+            else:
+                cfg_str = str(self.config_file)
             mypy_args.append(f"--config-file={cfg_str}")
 
         mypy_args.extend(str(p) for p in paths)
 
+        _logger.debug(f"({self.id}) api.run(): {mypy_args}")
         stdout, stderr, returncode = mypy.api.run(mypy_args)
 
         # fatal error, before evaluation happens
@@ -163,24 +172,41 @@ class _MypyAdapter(TypeCheckerAdapter):
         if stderr:
             raise TypeCheckerError(stderr, None, None)
 
+        lines = stdout.splitlines()
+        _logger.info(
+            "({}) Return code = {}, diagnostic count = {}.{}".format(
+                self.id,
+                returncode,
+                len(lines),
+                " pytest -vv shows all items." if self.log_verbosity < 2 else "",
+            )
+        )
+
         # So-called mypy json output is merely a line-by-line
         # transformation of plain text output into json object
-        for line in stdout.splitlines():
+        for line in lines:
             if len(line) <= 2 or line[0] != "{":
                 continue
+            if self.log_verbosity >= 2:
+                _logger.debug(f"({self.id}) {line}")
             obj = json.loads(line)
-            diag = cast(_MypyDiagObj, cls._schema.validate(obj))
+            diag = cast(_MypyDiagObj, self._schema.validate(obj))
             filename = pathlib.Path(diag["file"]).name
             pos = FilePos(filename, diag["line"])
+            # HACK: Never trust return code from mypy. During early 1.11.x
+            # versions, mypy always return 1 for JSON output even when
+            # there's no error. Later on mypy command line has fixed this,
+            # but not mypy.api.run(), as of 1.13.
             if diag["severity"] != "note":
                 raise TypeCheckerError(
-                    "Mypy {} with exit code {}: {}".format(
-                        diag["severity"], returncode, diag["message"]
+                    "{} {} with exit code {}: {}".format(
+                        self.id, diag["severity"], returncode, diag["message"]
                     ),
                     diag["file"],
                     diag["line"],
+                    diag["code"],
                 )
-            if (m := cls._type_mesg_re.match(diag["message"])) is None:
+            if (m := self._type_mesg_re.fullmatch(diag["message"])) is None:
                 continue
             # Mypy can insert extra character into expression so that it
             # becomes invalid and unparsable. 0.9x days there
@@ -190,14 +216,14 @@ class _MypyAdapter(TypeCheckerAdapter):
             expression = m["type"].translate({ord(c): None for c in "*?="})
             try:
                 # Unlike pyright, mypy output doesn't contain variable name
-                cls.typechecker_result[pos] = VarType(None, ForwardRef(expression))
+                self.typechecker_result[pos] = VarType(None, ForwardRef(expression))
             except SyntaxError as e:
                 if (
                     m := re.fullmatch(r"<Deleted '(?P<var>.+)'>", expression)
                 ) is not None:
                     raise TypeCheckerError(
                         "{} does not support reusing deleted variable '{}'".format(
-                            cls.id, m["var"]
+                            self.id, m["var"]
                         ),
                         diag["file"],
                         diag["line"],
@@ -208,46 +234,17 @@ class _MypyAdapter(TypeCheckerAdapter):
                     diag["line"],
                 ) from e
 
-    @classmethod
-    def create_collector(
-        cls, globalns: dict[str, Any], localns: dict[str, Any]
-    ) -> _NameCollector:
-        return _NameCollector(globalns, localns)
-
-    @classmethod
-    def set_config_file(cls, config: pytest.Config) -> None:
-        if (path_str := config.option.revealtype_mypy_config) is None:
-            _logger.info("Using default mypy configuration")
-            return
-
+    def preprocess_config_file(self, path_str: str) -> bool:
+        if path_str:
+            return False
         # HACK: when path_str is empty string, use no config file
         # ('mypy --config-file=')
-        # Take advantage of pathlib.Path() behavior that empty string
-        # is treated as current directory, which is not a valid
-        # config file name, while satisfying typing constraint
-        if not path_str:
-            cls.config_file = pathlib.Path()
-            return
-
-        relpath = pathlib.Path(path_str)
-        if relpath.is_absolute():
-            raise ValueError(f"Path '{path_str}' must be relative to pytest rootdir")
-        result = (config.rootpath / relpath).resolve()
-        if not result.exists():
-            raise FileNotFoundError(f"Path '{result}' not found")
-
-        _logger.info(f"Using mypy configuration file at {result}")
-        cls.config_file = result
-
-    @staticmethod
-    def add_pytest_option(group: pytest.OptionGroup) -> None:
-        group.addoption(
-            "--revealtype-mypy-config",
-            type=str,
-            default=None,
-            help="Mypy configuration file, path is relative to pytest rootdir. "
-            "If unspecified, use mypy default behavior",
-        )
+        # The special value is for satisfying typing constraint;
+        # it will be treated specially in run_typechecker_on()
+        self.config_file = pathlib.Path()
+        self._logger.info(f"({self.id}) Config file usage forbidden")
+        return True
 
 
-adapter = _MypyAdapter()
+def generate_adapter() -> TypeCheckerAdapter:
+    return MypyAdapter()

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.4.0}/src/pytest_revealtype_injector/adapter/pyright_.py

@@ -1,22 +1,27 @@
+from __future__ import annotations
+
 import ast
 import json
 import pathlib
 import re
 import shutil
 import subprocess
+import sys
 from collections.abc import (
     Iterable,
 )
 from typing import (
-    Any,
     ForwardRef,
     Literal,
-    TypedDict,
     TypeVar,
     cast,
 )
 
-import pytest
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict
+else:
+    from typing_extensions import NotRequired, TypedDict
+
 import schema as s
 
 from ..log import get_logger
@@ -46,9 +51,10 @@ class _PyrightDiagItem(TypedDict):
     severity: Literal["information", "warning", "error"]
     message: str
     range: _PyrightDiagRange
+    rule: NotRequired[str]
 
-
-class _NameCollector(NameCollectorBase):
+class NameCollector(NameCollectorBase):
+    type_checker = "pyright"
     # Pre-register common used bare names from typing
     collected = NameCollectorBase.collected | {
         k: v
@@ -68,18 +74,21 @@ class _NameCollector(NameCollectorBase):
                     continue
                 obj = getattr(self.collected[m], name)
                 self.collected[name] = obj
-                _logger.debug(f"Pyright NameCollector resolved '{name}' as {obj}")
+                _logger.debug(
+                    f"{self.type_checker} NameCollector resolved '{name}' as {obj}"
+                )
                 return node
             raise
         return node
 
 
-class _PyrightAdapter(TypeCheckerAdapter):
+class PyrightAdapter(TypeCheckerAdapter):
     id = "pyright"
-    typechecker_result = {}
-    _type_mesg_re = re.compile('^Type of "(?P<var>.+?)" is "(?P<type>.+?)"$')
-    # We only care about diagnostic messages that contain type information.
-    # Metadata not specified here.
+    _executable = "pyright"
+    _type_mesg_re = re.compile('Type of "(?P<var>.+?)" is "(?P<type>.+?)"')
+    _namecollector_class = NameCollector
+    # We only care about diagnostic messages that contain type information, that
+    # is, items under "generalDiagnostics" key. Metadata not validated here.
     _schema = s.Schema({
         "file": str,
         "severity": s.Or(
@@ -92,30 +101,42 @@ class _PyrightAdapter(TypeCheckerAdapter):
             "start": {"line": int, "character": int},
             "end": {"line": int, "character": int},
         },
+        s.Optional("rule"): str,
     })
 
-    @classmethod
-    def run_typechecker_on(cls, paths: Iterable[pathlib.Path]) -> None:
+    def run_typechecker_on(self, paths: Iterable[pathlib.Path]) -> None:
         cmd: list[str] = []
-        if shutil.which("pyright") is not None:
-            cmd.append("pyright")
+        if shutil.which(self._executable) is not None:
+            cmd.append(self._executable)
         elif shutil.which("npx") is not None:
-            cmd.extend(["npx", "pyright"])
+            cmd.extend(["npx", self._executable])
         else:
-            raise FileNotFoundError("Pyright is required to run test suite")
+            raise FileNotFoundError(f"{self._executable} is required to run test suite")
 
         cmd.append("--outputjson")
-        if cls.config_file is not None:
-            cmd.extend(["--project", str(cls.config_file)])
+        if self.config_file is not None:
+            cmd.extend(["--project", str(self.config_file)])
         cmd.extend(str(p) for p in paths)
 
+        _logger.debug(f"({self.id}) Run command: {cmd}")
         proc = subprocess.run(cmd, capture_output=True)
         if len(proc.stderr):
             raise TypeCheckerError(proc.stderr.decode(), None, None)
 
         report = json.loads(proc.stdout)
+        _logger.info(
+            "({}) Return code = {}, diagnostic count = {}.{}".format(
+                self.id,
+                proc.returncode,
+                len(report["generalDiagnostics"]),
+                " pytest -vv shows all items." if self.log_verbosity < 2 else "",
+            )
+        )
+
         for item in report["generalDiagnostics"]:
-            diag = cast(_PyrightDiagItem, cls._schema.validate(item))
+            diag = cast(_PyrightDiagItem, self._schema.validate(item))
+            if self.log_verbosity >= 2:
+                _logger.debug(f"({self.id}) {diag}")
             if diag["severity"] != ("error" if proc.returncode else "information"):
                 continue
             # Pyright report lineno is 0-based, while
@@ -123,43 +144,20 @@ class _PyrightAdapter(TypeCheckerAdapter):
             lineno = diag["range"]["start"]["line"] + 1
             filename = pathlib.Path(diag["file"]).name
             if proc.returncode:
-                raise TypeCheckerError(diag["message"], filename, lineno)
-            if (m := cls._type_mesg_re.match(diag["message"])) is None:
+                assert "rule" in diag
+                raise TypeCheckerError(
+                    "{} {} with exit code {}: {}".format(
+                        self.id, diag["severity"], proc.returncode, diag["message"]
+                    ),
+                    filename,
+                    lineno,
+                    diag["rule"],
+                )
+            if (m := self._type_mesg_re.fullmatch(diag["message"])) is None:
                 continue
             pos = FilePos(filename, lineno)
-            cls.typechecker_result[pos] = VarType(m["var"], ForwardRef(m["type"]))
-
-    @classmethod
-    def create_collector(
-        cls, globalns: dict[str, Any], localns: dict[str, Any]
-    ) -> _NameCollector:
-        return _NameCollector(globalns, localns)
-
-    @classmethod
-    def set_config_file(cls, config: pytest.Config) -> None:
-        if (path_str := config.option.revealtype_pyright_config) is None:
-            _logger.info("Using default pyright configuration")
-            return
-
-        relpath = pathlib.Path(path_str)
-        if relpath.is_absolute():
-            raise ValueError(f"Path '{path_str}' must be relative to pytest rootdir")
-        result = (config.rootpath / relpath).resolve()
-        if not result.exists():
-            raise FileNotFoundError(f"Path '{result}' not found")
-
-        _logger.info(f"Using pyright configuration file at {result}")
-        cls.config_file = result
-
-    @staticmethod
-    def add_pytest_option(group: pytest.OptionGroup) -> None:
-        group.addoption(
-            "--revealtype-pyright-config",
-            type=str,
-            default=None,
-            help="Pyright configuration file, path is relative to pytest rootdir. "
-            "If unspecified, use pyright default behavior",
-        )
+            self.typechecker_result[pos] = VarType(m["var"], ForwardRef(m["type"]))
 
 
-adapter = _PyrightAdapter()
+def generate_adapter() -> TypeCheckerAdapter:
+    return PyrightAdapter()

pytest_revealtype_injector-0.4.0/src/pytest_revealtype_injector/hooks.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import functools
+import inspect
+from typing import cast
+
+import pytest
+
+from . import adapter, log
+from .main import revealtype_injector
+from .models import TypeCheckerAdapter
+
+_logger = log.get_logger()
+adapter_stash_key: pytest.StashKey[set[TypeCheckerAdapter]]
+
+
+def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
+    assert pyfuncitem.module is not None
+    adapters = pyfuncitem.config.stash[adapter_stash_key].copy()
+    injected = functools.partial(revealtype_injector, adapters=adapters)
+
+    for name in dir(pyfuncitem.module):
+        if name.startswith("__") or name.startswith("@py"):
+            continue
+
+        item = getattr(pyfuncitem.module, name)
+        if inspect.isfunction(item):
+            if item.__name__ == "reveal_type" and item.__module__ in {
+                "typing",
+                "typing_extensions",
+            }:
+                setattr(pyfuncitem.module, name, injected)
+                _logger.info(f"Replaced {name}() from global import with {injected}")
+                continue
+
+        if inspect.ismodule(item):
+            if item.__name__ not in {"typing", "typing_extensions"}:
+                continue
+            assert hasattr(item, "reveal_type")
+            setattr(item, "reveal_type", injected)
+            _logger.info(f"Replaced {name}.reveal_type() with {injected}")
+            continue
+
+
+def pytest_collection_finish(session: pytest.Session) -> None:
+    files = {i.path for i in session.items}
+    for adp in session.config.stash[adapter_stash_key]:
+        try:
+            adp.run_typechecker_on(files)
+        except Exception as e:
+            _logger.error(f"({adp.id}) {e}")
+            pytest.exit(f"({type(e).__name__}) " + str(e), pytest.ExitCode.INTERNAL_ERROR)
+        else:
+            _logger.info(f"({adp.id}) Type checker ran successfully")
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup(
+        "revealtype-injector",
+        description="Type checker related options for revealtype-injector",
+    )
+    classes = adapter.get_adapter_classes()
+    group.addoption(
+        "--revealtype-disable-adapter",
+        type=str,
+        choices=tuple(c.id for c in classes),
+        action="append",
+        default=[],
+        help="Disable specific type checker. Can be used multiple times"
+        " to disable multiple checkers",
+    )
+    for c in classes:
+        c.add_pytest_option(group)
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    global adapter_stash_key
+    adapter_stash_key = pytest.StashKey[set[TypeCheckerAdapter]]()
+    config.stash[adapter_stash_key] = set()
+    verbosity = config.get_verbosity(config.VERBOSITY_TEST_CASES)
+    log.set_verbosity(verbosity)
+    to_be_disabled = cast(list[str], config.getoption("revealtype_disable_adapter"))
+    for klass in adapter.get_adapter_classes():
+        if klass.id in to_be_disabled:
+            _logger.info(f"({klass.id}) adapter disabled with command line option")
+            continue
+        adp = klass()
+        adp.set_config_file(config)
+        adp.log_verbosity = verbosity
+        config.stash[adapter_stash_key].add(adp)

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.4.0}/src/pytest_revealtype_injector/log.py

@@ -11,6 +11,7 @@ _verbosity_map = {
     2: logging.DEBUG,
 }
 
+
 def get_logger() -> logging.Logger:
     return _logger