pytest-revealtype-injector 0.2.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

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/adapter/__init__.py

@@ -1,13 +1,22 @@
 from __future__ import annotations
 
 from ..models import TypeCheckerAdapter
-from . import mypy_, pyright_
+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 discovery() -> set[TypeCheckerAdapter]:
+def generate() -> set[TypeCheckerAdapter]:
     return {
-        pyright_.adapter,
-        mypy_.adapter,
+        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/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/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/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/hooks.py

@@ -1,17 +1,24 @@
 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
@@ -22,26 +29,29 @@ def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
                 "typing",
                 "typing_extensions",
             }:
-                setattr(pyfuncitem.module, name, revealtype_injector)
-                _logger.info(
-                    f"Replaced {name}() from global import with {revealtype_injector}"
-                )
+                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", revealtype_injector)
-            _logger.info(f"Replaced {name}.reveal_type() with {revealtype_injector}")
+            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 adapter.discovery():
-        if adp.enabled:
+    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:
@@ -49,25 +59,32 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         "revealtype-injector",
         description="Type checker related options for revealtype-injector",
     )
-    adapters = adapter.discovery()
-    choices = tuple(adp.id for adp in adapters)
+    classes = adapter.get_adapter_classes()
     group.addoption(
         "--revealtype-disable-adapter",
         type=str,
-        choices=choices,
-        default=None,
-        help="Disable this type checker when using revealtype-injector plugin",
+        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 adp in adapters:
-        adp.add_pytest_option(group)
+    for c in classes:
+        c.add_pytest_option(group)
 
 
 def pytest_configure(config: pytest.Config) -> None:
-    _logger.setLevel(config.get_verbosity(config.VERBOSITY_TEST_CASES))
-    # Forget config stash, it can't store collection of unserialized objects
-    for adp in adapter.discovery():
-        if config.option.revealtype_disable_adapter == adp.id:
-            adp.enabled = False
-            _logger.info(f"Disable {adp.id} adapter based on command line option")
-        else:
-            adp.set_config_file(config)
+    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/log.py

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

pytest_revealtype_injector/main.py

@@ -14,15 +14,15 @@ from typeguard import (
     check_type_internal,
 )
 
-from . import adapter, log
+from . import log
 from .models import (
     FilePos,
+    TypeCheckerAdapter,
     TypeCheckerError,
     VarType,
 )
 
 _T = TypeVar("_T")
-
 _logger = log.get_logger()
 
 
@@ -61,7 +61,7 @@ def _get_var_name(frame: inspect.Traceback) -> str | None:
     return result
 
 
-def revealtype_injector(var: _T) -> _T:
+def revealtype_injector(var: _T, adapters: set[TypeCheckerAdapter]) -> _T:
     """Replacement of `reveal_type()` that matches static and runtime type
     checking result
 
@@ -105,9 +105,7 @@ def revealtype_injector(var: _T) -> _T:
     globalns = caller_frame.f_globals
     localns = caller_frame.f_locals
 
-    for adp in adapter.discovery():
-        if not adp.enabled:
-            continue
+    for adp in adapters:
         try:
             tc_result = adp.typechecker_result[pos]
         except KeyError as e:
@@ -128,12 +126,26 @@ def revealtype_injector(var: _T) -> _T:
         ref = tc_result.type
         walker = adp.create_collector(globalns, localns)
         try:
-            _ = eval(ref.__forward_arg__, globalns, localns | walker.collected)
+            evaluated = eval(ref.__forward_arg__, globalns, localns | walker.collected)
         except (TypeError, NameError):
-            ref_ast = ast.parse(ref.__forward_arg__, mode="eval")
-            new_ast = walker.visit(ref_ast)
+            old_ast = ast.parse(ref.__forward_arg__, mode="eval")
+            new_ast = walker.visit(old_ast)
             if walker.modified:
                 ref = ForwardRef(ast.unparse(new_ast))
+            evaluated = eval(ref.__forward_arg__, globalns, localns | walker.collected)
+
+        # HACK Mainly serves as a guard against mypy's behavior of blanket
+        # inferring to Any when it can't determine the type under non-strict
+        # mode. This behavior causes typeguard to remain silent, since Any is
+        # compatible with everything. This has a side effect of disallowing
+        # use of reveal_type() on data truly of Any type.
+        if evaluated is Any:
+            raise TypeCheckerError(
+                f"Inferred type of '{var_name}' is Any, which "
+                "defeats the purpose of type checking",
+                pos.file,
+                pos.lineno,
+            )
         memo = TypeCheckMemo(globalns, localns | walker.collected)
 
         try:

pytest_revealtype_injector/models.py

@@ -15,8 +15,11 @@ from typing import (
 )
 
 import pytest
+from _pytest.config import Notset
 from schema import Schema
 
+from .log import get_logger
+
 
 class FilePos(NamedTuple):
     file: str
@@ -30,16 +33,24 @@ class VarType(NamedTuple):
 
 class TypeCheckerError(Exception):
     # Can be None when type checker dies before any code evaluation
-    def __init__(self, message: str, filename: str | None, lineno: int | None) -> None:
+    def __init__(
+        self,
+        message: str,
+        filename: str | None,
+        lineno: int | None,
+        rule: str | None = None,
+    ) -> None:
         super().__init__(message)
         self._filename = filename
         self._lineno = lineno
+        self._rule = rule
 
     def __str__(self) -> str:
         if self._filename:
-            return '"{}"{}: {}'.format(
+            return '"{}"{}{}: {}'.format(
                 self._filename,
                 " line " + str(self._lineno) if self._lineno else "",
+                ', violating "' + self._rule + '" rule' if self._rule else "",
                 self.args[0],
             )
         else:
@@ -47,12 +58,14 @@ class TypeCheckerError(Exception):
 
 
 class NameCollectorBase(ast.NodeTransformer):
+    type_checker: ClassVar[str]
     # typing_extensions guaranteed to be present,
     # as a dependency of typeguard
     collected: dict[str, Any] = {
         m: importlib.import_module(m)
         for m in ("builtins", "typing", "typing_extensions")
     }
+
     def __init__(
         self,
         globalns: dict[str, Any],
@@ -86,26 +99,69 @@ class NameCollectorBase(ast.NodeTransformer):
 
 
 class TypeCheckerAdapter:
-    enabled: bool = True
-    config_file: ClassVar[pathlib.Path | None] = None
     # Subclasses need to specify default values for below
     id: ClassVar[str]
-    # {('file.py', 10): ('var_name', 'list[str]'), ...}
-    typechecker_result: ClassVar[dict[FilePos, VarType]]
+    _executable: ClassVar[str]
     _type_mesg_re: ClassVar[re.Pattern[str]]
     _schema: ClassVar[Schema]
+    _namecollector_class: ClassVar[type[NameCollectorBase]]
+
+    def __init__(self) -> None:
+        # {('file.py', 10): ('var_name', 'list[str]'), ...}
+        self.typechecker_result: dict[FilePos, VarType] = {}
+        self._logger = get_logger()
+        # logger level is already set by pytest_configure()
+        # this only affects how much debug message is shown
+        self.log_verbosity: int = 1
+        self.enabled: bool = True
+        self.config_file: pathlib.Path | None = None
 
     @classmethod
+    def longopt_for_config(cls) -> str:
+        return f"--revealtype-{cls.id}-config"
+
     @abc.abstractmethod
-    def run_typechecker_on(cls, paths: Iterable[pathlib.Path]) -> None: ...
-    @classmethod
-    @abc.abstractmethod
+    def run_typechecker_on(self, paths: Iterable[pathlib.Path]) -> None: ...
+
     def create_collector(
-        cls, globalns: dict[str, Any], localns: dict[str, Any]
-    ) -> NameCollectorBase: ...
+        self, globalns: dict[str, Any], localns: dict[str, Any]
+    ) -> NameCollectorBase:
+        return self._namecollector_class(globalns, localns)
+
+    def preprocess_config_file(self, path_str: str) -> bool:
+        """Optional preprocessing of configuration file"""
+        return False
+
+    def set_config_file(self, config: pytest.Config) -> None:
+        path_str = config.getoption(self.longopt_for_config())
+        # pytest addoption() should have set default value
+        # to None even when option is not specified
+        assert not isinstance(path_str, Notset)
+
+        if path_str is None:
+            self._logger.info(f"({self.id}) Using default configuration")
+            return
+
+        if self.preprocess_config_file(path_str):
+            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")
+
+        self._logger.info(f"({self.id}) Using config file at {result}")
+        self.config_file = result
+
     @classmethod
-    @abc.abstractmethod
-    def set_config_file(cls, config: pytest.Config) -> None: ...
-    @staticmethod
-    @abc.abstractmethod
-    def add_pytest_option(group: pytest.OptionGroup) -> None: ...
+    def add_pytest_option(cls, group: pytest.OptionGroup) -> None:
+        group.addoption(
+            cls.longopt_for_config(),
+            type=str,
+            default=None,
+            metavar="RELATIVE_PATH",
+            help=f"{cls.id} configuration file, path is relative to pytest "
+            f"rootdir. If unspecified, use {cls.id} default behavior",
+        )

{pytest_revealtype_injector-0.2.3.dist-info → pytest_revealtype_injector-0.4.0.dist-info}/METADATA

@@ -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.4.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pytest_revealtype_injector/__init__.py,sha256=hHWlJeHmCZawdklN1L2-t_-JGINlVjJ1fK6c2z5jzrA,211
+pytest_revealtype_injector/hooks.py,sha256=yOwey95EtwuImcveGXn5DaKhCgJ2cgFR16sLbJuXMwo,3169
+pytest_revealtype_injector/log.py,sha256=Ptd3yp1H1GlUum6BAwHc9cdyeGmaY8XYf0jp6qJmG4M,418
+pytest_revealtype_injector/main.py,sha256=nRh2uk64nsn9Y3PdGYew-Bhpfl0HZxmIur39RWpMNCk,5434
+pytest_revealtype_injector/models.py,sha256=VhjpVbbJE3ZtTPAtkJ8hZtl6sg070A875PgaTybxCO4,5170
+pytest_revealtype_injector/plugin.py,sha256=fkI6yF0dFVba0jEikIrsRp1NUQd2ohWLq4x2lSvFyH0,211
+pytest_revealtype_injector/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_revealtype_injector/adapter/__init__.py,sha256=FRVB1eUrXaMzdQG0wRdIEKhx2dzGdyJcHDBb3eTTeOY,602
+pytest_revealtype_injector/adapter/basedpyright_.py,sha256=8LX7GmJmg4OZ3LKO5WoQ7Ocub6Lxi3HTStIorMApzUA,466
+pytest_revealtype_injector/adapter/mypy_.py,sha256=J9duK2hFo7lZMB_Lz8ccntqZerBFCQBhw--jqkGsUeE,8808
+pytest_revealtype_injector/adapter/pyright_.py,sha256=V0BE6sUJURtwXp_W5vP3EmIdXTL6pB8Yewq-L_YgCb0,5121
+pytest_revealtype_injector-0.4.0.dist-info/METADATA,sha256=rUmQ1UPMdTfkCXP7q8_OuU01NMAjLAXMUAnx-pqnL3E,5619
+pytest_revealtype_injector-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pytest_revealtype_injector-0.4.0.dist-info/entry_points.txt,sha256=UfOm7y3WQnOoGV1mgTMb42MI6iBRPIl88FJiAOnt6SY,74
+pytest_revealtype_injector-0.4.0.dist-info/licenses/COPYING,sha256=LSYUX8PcSMvHCkhM5oi07eOrSLV89qdEJ-FVZmbcpNE,355
+pytest_revealtype_injector-0.4.0.dist-info/licenses/COPYING.mit,sha256=IzYEFDIOECyuupg_B3O9FvgjnU9i4JtambpbleoYHdQ,1060
+pytest_revealtype_injector-0.4.0.dist-info/RECORD,,

pytest_revealtype_injector-0.2.3.dist-info/RECORD

@@ -1,16 +0,0 @@
-pytest_revealtype_injector/__init__.py,sha256=I8FXkeB3TED-tbJ3KWZ60nazA1c8pSsF_10q0NGof-I,211
-pytest_revealtype_injector/hooks.py,sha256=cj1iXJJrVtqylXvvdLfjZ61HGBt5wsGBUe-iAgu9WiU,2434
-pytest_revealtype_injector/log.py,sha256=U9IvsoZzhFQcdFmVtuSmt2OTYxxFuIP5o321dyE4hiA,417
-pytest_revealtype_injector/main.py,sha256=ZNb_hDeuEIWDC_eSCLmXXfGCarHF1lsXIOE_BWL-940,4731
-pytest_revealtype_injector/models.py,sha256=FKYznMaNP9a4_AUN3vMdRQBvQUkbdCYTYjDccgdrV6w,3238
-pytest_revealtype_injector/plugin.py,sha256=fkI6yF0dFVba0jEikIrsRp1NUQd2ohWLq4x2lSvFyH0,211
-pytest_revealtype_injector/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytest_revealtype_injector/adapter/__init__.py,sha256=wQg3Ply0Xrfe9US_lzgqRgKFE89ZBvDFti6_77X_NKk,339
-pytest_revealtype_injector/adapter/mypy_.py,sha256=q-stxOY2bffTAm2SoHiCAb7VA_f9jXc4UxlyimXV-RY,8840
-pytest_revealtype_injector/adapter/pyright_.py,sha256=Um_HiYDehffci2l9DYXvOfxHNEVuKQsQ9MOsO5mXal4,5126
-pytest_revealtype_injector-0.2.3.dist-info/METADATA,sha256=zrqkK8CDEbkQi2yI1rCnRAf41QAsPkgNIx-dV9UzBvU,5520
-pytest_revealtype_injector-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pytest_revealtype_injector-0.2.3.dist-info/entry_points.txt,sha256=UfOm7y3WQnOoGV1mgTMb42MI6iBRPIl88FJiAOnt6SY,74
-pytest_revealtype_injector-0.2.3.dist-info/licenses/COPYING,sha256=LSYUX8PcSMvHCkhM5oi07eOrSLV89qdEJ-FVZmbcpNE,355
-pytest_revealtype_injector-0.2.3.dist-info/licenses/COPYING.mit,sha256=IzYEFDIOECyuupg_B3O9FvgjnU9i4JtambpbleoYHdQ,1060
-pytest_revealtype_injector-0.2.3.dist-info/RECORD,,