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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-revealtype-injector
-Version: 0.2.3
+Version: 0.3.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,12 @@ 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
 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.3.0}/pyproject.toml

@@ -16,9 +16,10 @@ license = 'MIT'
 license-files = ['COPYING*']
 dependencies = [
     '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 +59,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 +90,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.3.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.3.0"

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

@@ -0,0 +1,21 @@
+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.3.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.3.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,15 +172,31 @@ 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(
@@ -180,7 +205,7 @@ class _MypyAdapter(TypeCheckerAdapter):
                     diag["file"],
                     diag["line"],
                 )
-            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 +215,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 +233,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.3.0}/src/pytest_revealtype_injector/adapter/pyright_.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import ast
 import json
 import pathlib
@@ -8,7 +10,6 @@ from collections.abc import (
     Iterable,
 )
 from typing import (
-    Any,
     ForwardRef,
     Literal,
     TypedDict,
@@ -16,7 +17,6 @@ from typing import (
     cast,
 )
 
-import pytest
 import schema as s
 
 from ..log import get_logger
@@ -48,7 +48,8 @@ class _PyrightDiagItem(TypedDict):
     range: _PyrightDiagRange
 
 
-class _NameCollector(NameCollectorBase):
+class NameCollector(NameCollectorBase):
+    type_checker = "pyright"
     # Pre-register common used bare names from typing
     collected = NameCollectorBase.collected | {
         k: v
@@ -68,18 +69,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 +96,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
@@ -124,42 +140,11 @@ class _PyrightAdapter(TypeCheckerAdapter):
             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:
+            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.3.0/src/pytest_revealtype_injector/hooks.py

@@ -0,0 +1,92 @@
+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}")
+            raise e
+        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.3.0}/src/pytest_revealtype_injector/log.py

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

{pytest_revealtype_injector-0.2.3 → pytest_revealtype_injector-0.3.0}/src/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-0.2.3 → pytest_revealtype_injector-0.3.0}/src/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
@@ -47,12 +50,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 +91,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.3.0/tests/conftest.py

@@ -0,0 +1,7 @@
+pytest_plugins = ["pytester"]
+
+# Tests in this folder are fragile. If return type is taken away from function
+# (the "-> None" part), mypy will not complain about the type hint under
+# non-strict mode. Instead, it infers a blanket type of "Any" for "x", which
+# nullifies typeguard checking (no TypeCheckError raised). A crude guard against
+# this situation is implemented inside revealtype_injector.

pytest_revealtype_injector-0.3.0/tests/test_import.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import pytest
+
+
+class TestImport:
+    def test_basic(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.basedpyright]
+            reportUnreachable = false
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            """
+            import sys
+            import pytest
+            from typeguard import TypeCheckError
+
+            if sys.version_info >= (3, 11):
+                from typing import reveal_type
+            else:
+                from typing_extensions import reveal_type
+
+            def test_inferred() -> None:
+                x = 1
+                reveal_type(x)
+
+            def test_bad_inline_hint() -> None:
+                x: str = 1  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+                with pytest.raises(TypeCheckError, match='is not an instance of str'):
+                    reveal_type(x)
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)
+
+    def test_import_as(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.basedpyright]
+            reportUnreachable = false
+            reportUnusedCallResult = false
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            """
+            import sys
+            import pytest
+            from typeguard import TypeCheckError
+
+            if sys.version_info >= (3, 11):
+                from typing import reveal_type as rt
+            else:
+                from typing_extensions import reveal_type as rt
+
+            def test_inferred() -> None:
+                x = 1
+                rt(x)
+
+            def test_bad_inline_hint() -> None:
+                x: str = 1  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+                with pytest.raises(TypeCheckError, match='is not an instance of str'):
+                    rt(x)
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)
+
+    def test_import_module_as(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.basedpyright]
+            reportUnreachable = false
+            reportUnusedCallResult = false
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            """
+            import sys
+            import pytest
+            from typeguard import TypeCheckError
+
+            if sys.version_info >= (3, 11):
+                import typing as t
+            else:
+                import typing_extensions as t
+
+            def test_inferred() -> None:
+                x = 1
+                t.reveal_type(x)
+
+            def test_bad_inline_hint() -> None:
+                x: str = 1  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+                with pytest.raises(TypeCheckError, match='is not an instance of str'):
+                    t.reveal_type(x)
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)

pytest_revealtype_injector-0.3.0/tests/test_options.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import inspect
+
+import pytest
+
+
+class TestDisableTypeChecker:
+    content_fail = inspect.cleandoc(
+        """
+        import sys
+        import pytest
+        from typeguard import TypeCheckError
+
+        if sys.version_info >= (3, 11):
+            from typing import reveal_type
+        else:
+            from typing_extensions import reveal_type
+
+        def test_bad_inline_hint() -> None:
+            x: str = 1  # {}
+            with pytest.raises(TypeCheckError, match='is not an instance of str'):
+                reveal_type(x)
+        """
+    )
+
+    def _gen_pytest_opts(self, adapter: list[str]) -> list[str]:
+        result = [f"--revealtype-disable-adapter={a}" for a in adapter]
+        result.extend(["--tb=short", "-vv"])
+        return result
+
+    def test_disable_mypy_fail(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.pyright]
+            typeCheckingMode = 'strict'
+            enableTypeIgnoreComments = false
+            reportUnreachable = false
+            reportUnusedCallResult = false
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            self.content_fail
+        )
+        opts = self._gen_pytest_opts(["mypy"])
+        result = pytester.runpytest(*opts)
+        assert result.ret == pytest.ExitCode.INTERNAL_ERROR
+        result.assert_outcomes(passed=0, failed=0)
+
+    def test_disable_mypy_pass(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.pyright]
+            typeCheckingMode = 'strict'
+            enableTypeIgnoreComments = false
+            reportUnreachable = false
+            reportUnusedCallResult = false
+            """
+        )
+        content_masked = self.content_fail.format(
+            "pyright: ignore[reportAssignmentType]",
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            content_masked
+        )
+        opts = self._gen_pytest_opts(["mypy"])
+        result = pytester.runpytest(*opts)
+        assert result.ret == pytest.ExitCode.OK
+        result.assert_outcomes(passed=1, failed=0)
+
+    def test_enable_mypy_only(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.mypy]
+            strict = true
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            self.content_fail
+        )
+        opts = self._gen_pytest_opts(["basedpyright", "pyright"])
+        result = pytester.runpytest(*opts)
+        assert result.ret == pytest.ExitCode.INTERNAL_ERROR
+        result.assert_outcomes(passed=0, failed=0)
+
+        content_masked = self.content_fail.format("type: ignore[assignment]")
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            content_masked
+        )
+        result = pytester.runpytest(*opts)
+        assert result.ret == pytest.ExitCode.OK
+        result.assert_outcomes(passed=1, failed=0)

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

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-from ..models import TypeCheckerAdapter
-from . import 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]:
-    return {
-        pyright_.adapter,
-        mypy_.adapter,
-    }

pytest_revealtype_injector-0.2.3/src/pytest_revealtype_injector/hooks.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import inspect
-
-import pytest
-
-from . import adapter, log
-from .main import revealtype_injector
-
-_logger = log.get_logger()
-
-
-def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
-    assert pyfuncitem.module is not None
-    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, revealtype_injector)
-                _logger.info(
-                    f"Replaced {name}() from global import with {revealtype_injector}"
-                )
-                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}")
-            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:
-            adp.run_typechecker_on(files)
-
-
-def pytest_addoption(parser: pytest.Parser) -> None:
-    group = parser.getgroup(
-        "revealtype-injector",
-        description="Type checker related options for revealtype-injector",
-    )
-    adapters = adapter.discovery()
-    choices = tuple(adp.id for adp in adapters)
-    group.addoption(
-        "--revealtype-disable-adapter",
-        type=str,
-        choices=choices,
-        default=None,
-        help="Disable this type checker when using revealtype-injector plugin",
-    )
-    for adp in adapters:
-        adp.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)

pytest_revealtype_injector-0.2.3/tests/conftest.py

@@ -1 +0,0 @@
-pytest_plugins = ["pytester"]

pytest_revealtype_injector-0.2.3/tests/test_basic.py

@@ -1,91 +0,0 @@
-import pytest
-
-
-def test_basic(pytester: pytest.Pytester) -> None:
-    pytester.makeconftest(
-        "pytest_plugins = ['pytest_revealtype_injector.plugin']"
-    )
-
-    pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
-        """
-        import sys
-        import pytest
-        from typeguard import TypeCheckError
-
-        if sys.version_info >= (3, 11):
-            from typing import reveal_type
-        else:
-            from typing_extensions import reveal_type
-
-        def test_inferred():
-            x = 1
-            reveal_type(x)
-
-        def test_bad_inline_hint():
-            x: str = 1  # type: ignore  # pyright: ignore
-            with pytest.raises(TypeCheckError, match='is not an instance of str'):
-                reveal_type(x)
-        """
-    )
-    result = pytester.runpytest()
-    result.assert_outcomes(passed=2)
-
-
-def test_import_as(pytester: pytest.Pytester) -> None:
-    pytester.makeconftest(
-        "pytest_plugins = ['pytest_revealtype_injector.plugin']"
-    )
-
-    pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
-        """
-        import sys
-        import pytest
-        from typeguard import TypeCheckError
-
-        if sys.version_info >= (3, 11):
-            from typing import reveal_type as rt
-        else:
-            from typing_extensions import reveal_type as rt
-
-        def test_inferred():
-            x = 1
-            rt(x)
-
-        def test_bad_inline_hint():
-            x: str = 1  # type: ignore  # pyright: ignore
-            with pytest.raises(TypeCheckError, match='is not an instance of str'):
-                rt(x)
-        """
-    )
-    result = pytester.runpytest()
-    result.assert_outcomes(passed=2)
-
-
-def test_import_module_as(pytester: pytest.Pytester) -> None:
-    pytester.makeconftest(
-        "pytest_plugins = ['pytest_revealtype_injector.plugin']"
-    )
-
-    pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
-        """
-        import sys
-        import pytest
-        from typeguard import TypeCheckError
-
-        if sys.version_info >= (3, 11):
-            import typing as t
-        else:
-            import typing_extensions as t
-
-        def test_inferred():
-            x = 1
-            t.reveal_type(x)
-
-        def test_bad_inline_hint():
-            x: str = 1  # type: ignore  # pyright: ignore
-            with pytest.raises(TypeCheckError, match='is not an instance of str'):
-                t.reveal_type(x)
-        """
-    )
-    result = pytester.runpytest()
-    result.assert_outcomes(passed=2)