pytest-revealtype-injector 0.1.0__tar.gz

pytest_revealtype_injector-0.1.0/.gitignore

@@ -0,0 +1,119 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.pytest_cache/
+cover/
+
+# Django stuff:
+*.log
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# ruff formatter
+.ruff_cache/
+
+# Local utility scripts
+/*.py
+
+# Editor / IDE
+*~
+*.bak
+.*.sw?
+.vscode/
+.idea/

pytest_revealtype_injector-0.1.0/COPYING

@@ -0,0 +1,6 @@
+pytest-revealtype-injector is released under MIT license (see COPYING.mit).
+
+Original source code comes from part of types-lxml project, which is
+release under Apache-2.0 license. But as the sole author of all source
+code inside this repository, it is at my own discretion to follow pytest
+license because this project is taking shape as a pytest plugin.

pytest_revealtype_injector-0.1.0/COPYING.mit

@@ -0,0 +1,19 @@
+Copyright (c) 2023-2024 Abel Cheung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_revealtype_injector-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.3
+Name: pytest-revealtype-injector
+Version: 0.1.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>
+License: MIT
+Keywords: annotation,dynamic-typing,pytest,reveal_type,static-typing,stub,stubs,type-checking,types,typing
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: mypy>=1.11.2
+Requires-Dist: pyright~=1.1
+Requires-Dist: pytest>=7.0
+Requires-Dist: typeguard~=4.3
+Description-Content-Type: text/markdown
+
+`pytest-revealtype-injector` is a `pytest` plugin for replacing [`reveal_type()`](https://docs.python.org/3/library/typing.html#typing.reveal_type) calls inside test functions as something more sophisticated. It does the following tasks in parallel:
+
+- Launch external static type checkers (`pyright` and `mypy`) and store `reveal_type` results.
+- Use [`typeguard`](https://github.com/agronholm/typeguard) to verify the aforementioned static type checker result _really_ matches runtime code result.
+
+## Usage
+
+In short: install this plugin, create test functions which calls `reveal_type()` with variable or function return result, done.
+
+### The longer story
+
+This plugin would be automatically enabled when launching `pytest`.
+
+For using `reveal_type()` inside tests, there is no boiler plate code involved. Import `reveal_type` normally, like:
+
+```python
+from typing import reveal_type
+```
+
+Just importing `typing` module is fine too (or import `typing_extensions` for Python 3.10, because `reveal_type()` is only available officially since 3.11):
+
+```python
+import typing
+
+def test_something():
+    x: str = 1  # type: ignore  # pyright: ignore
+    typing.reveal_type(x)  # typeguard fails here
+```
+
+Since this plugin scans for `reveal_type()` for replacement under carpet, even `import ... as ...` syntax works too:
+
+```python
+import typing as typ  # or...
+from typing import reveal_type as rt
+```
+
+### Limitations
+
+But there are 2 caveats.
+
+1. This plugin only searches for global import in test files, so local import inside test function doesn't work. That means following code doesn't utilize this plugin at all:
+
+```python
+def test_something():
+    from typing import reveal_type
+    x = 1
+    reveal_type(x)  # calls vanilla reveal_type()
+```
+
+2. `reveal_type()` calls have to stay in a single line, without anything else. This limitation comes from using [`eval` mode in AST parsing](https://docs.python.org/3/library/ast.html#ast.Expression).
+
+## History
+
+This pytest plugin starts its life as part of testsuite related utilities within [`types-lxml`](https://github.com/abelcheung/types-lxml). As `lxml` is a `cython` project and probably never incorporate inline python annotation in future, there is need to compare runtime result to static type checker output for discrepancy. As time goes by, it starts to make sense to manage as an independent project.

pytest_revealtype_injector-0.1.0/README.md

@@ -0,0 +1,54 @@
+`pytest-revealtype-injector` is a `pytest` plugin for replacing [`reveal_type()`](https://docs.python.org/3/library/typing.html#typing.reveal_type) calls inside test functions as something more sophisticated. It does the following tasks in parallel:
+
+- Launch external static type checkers (`pyright` and `mypy`) and store `reveal_type` results.
+- Use [`typeguard`](https://github.com/agronholm/typeguard) to verify the aforementioned static type checker result _really_ matches runtime code result.
+
+## Usage
+
+In short: install this plugin, create test functions which calls `reveal_type()` with variable or function return result, done.
+
+### The longer story
+
+This plugin would be automatically enabled when launching `pytest`.
+
+For using `reveal_type()` inside tests, there is no boiler plate code involved. Import `reveal_type` normally, like:
+
+```python
+from typing import reveal_type
+```
+
+Just importing `typing` module is fine too (or import `typing_extensions` for Python 3.10, because `reveal_type()` is only available officially since 3.11):
+
+```python
+import typing
+
+def test_something():
+    x: str = 1  # type: ignore  # pyright: ignore
+    typing.reveal_type(x)  # typeguard fails here
+```
+
+Since this plugin scans for `reveal_type()` for replacement under carpet, even `import ... as ...` syntax works too:
+
+```python
+import typing as typ  # or...
+from typing import reveal_type as rt
+```
+
+### Limitations
+
+But there are 2 caveats.
+
+1. This plugin only searches for global import in test files, so local import inside test function doesn't work. That means following code doesn't utilize this plugin at all:
+
+```python
+def test_something():
+    from typing import reveal_type
+    x = 1
+    reveal_type(x)  # calls vanilla reveal_type()
+```
+
+2. `reveal_type()` calls have to stay in a single line, without anything else. This limitation comes from using [`eval` mode in AST parsing](https://docs.python.org/3/library/ast.html#ast.Expression).
+
+## History
+
+This pytest plugin starts its life as part of testsuite related utilities within [`types-lxml`](https://github.com/abelcheung/types-lxml). As `lxml` is a `cython` project and probably never incorporate inline python annotation in future, there is need to compare runtime result to static type checker output for discrepancy. As time goes by, it starts to make sense to manage as an independent project.

pytest_revealtype_injector-0.1.0/pyproject.toml

@@ -0,0 +1,132 @@
+#:schema https://json.schemastore.org/pyproject.json
+
+[build-system]
+requires = ['hatchling']
+build-backend = 'hatchling.build'
+
+[project]
+name = 'pytest-revealtype-injector'
+dynamic = ['version']
+description = """Pytest plugin for replacing reveal_type() calls inside
+test functions with static and runtime type checking result comparison,
+for confirming type annotation validity."""
+readme = 'README.md'
+requires-python = '>=3.10'
+license = {text = 'MIT'}
+dependencies = [
+    'mypy >= 1.11.2',
+    'pyright ~= 1.1',
+    'pytest >= 7.0',
+    'typeguard ~= 4.3'
+]
+keywords = [
+    'pytest',
+    'typing',
+    'types',
+    'stub',
+    'stubs',
+    'static-typing',
+    'dynamic-typing',
+    'type-checking',
+    'annotation',
+    'reveal_type',
+]
+authors = [
+    { name = 'Abel Cheung', email = 'abelcheung@gmail.com' }
+]
+classifiers = [
+    'Development Status :: 4 - Beta',
+    'Programming Language :: Python',
+    'Intended Audience :: Developers',
+    'Framework :: Pytest',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3 :: Only',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'License :: OSI Approved :: MIT License',
+    'Topic :: Software Development :: Testing',
+    'Typing :: Typed',
+]
+
+[project.urls]
+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'
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    '**/.*',
+    'CHANGELOG.md',
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pytest_revealtype_injector"]
+
+[tool.pyright]
+typeCheckingMode = 'strict'
+enableTypeIgnoreComments = false
+deprecateTypingAliases = true
+
+[tool.mypy]
+mypy_path = "$MYPY_CONFIG_FILE_DIR/src"
+packages = "pytest_revealtype_injector"
+strict = true
+
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.format]
+preview = true
+
+[tool.ruff.lint]
+select = [
+    'E',
+    'F',
+    'I',
+]
+task-tags = [
+    "BUG",
+    "DEBUG",
+    "FIX",
+    "FIXME",
+    "HACK",
+    "IDEA",
+    "NOTE",
+    "OPTIMIZE",
+    "REVIEW",
+    "TODO",
+    "UGLY",
+    "XXX",
+]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = [
+    "--tb=short",
+    "--import-mode=importlib",
+]
+markers = [
+    "slow: marks tests as slow",
+]
+testpaths = [
+    "tests",
+]
+
+# We only use version determination logic from python-semantic-release,
+# and never does any permanent change with it
+[tool.semantic_release]
+version_variables = ['src/pytest_revealtype_injector/__init__.py:__version__']
+major_on_zero = false  # switch on for 1.0.0
+

pytest_revealtype_injector-0.1.0/src/pytest_revealtype_injector/__init__.py

@@ -0,0 +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.1.0"

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

@@ -0,0 +1,13 @@
+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.1.0/src/pytest_revealtype_injector/adapter/mypy_.py

@@ -0,0 +1,217 @@
+import ast
+import importlib
+import json
+import logging
+import pathlib
+import re
+from collections.abc import (
+    Iterable,
+)
+from typing import (
+    Any,
+    ForwardRef,
+    Literal,
+    TypedDict,
+    cast,
+)
+
+import mypy.api
+import pytest
+
+from ..models import (
+    FilePos,
+    NameCollectorBase,
+    TypeCheckerAdapter,
+    TypeCheckerError,
+    VarType,
+)
+
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.INFO)
+
+
+class _MypyDiagObj(TypedDict):
+    file: str
+    line: int
+    column: int
+    message: str
+    hint: str | None
+    code: str
+    severity: Literal["note", "warning", "error"]
+
+
+class _NameCollector(NameCollectorBase):
+    def visit_Attribute(self, node: ast.Attribute) -> ast.expr:
+        prefix = ast.unparse(node.value)
+        name = node.attr
+
+        setattr(node.value, "is_parent", True)
+        if not hasattr(node, "is_parent"):  # Outmost attribute node
+            try:
+                _ = importlib.import_module(prefix)
+            except ModuleNotFoundError:
+                # Mypy resolve names according to external stub if
+                # available. For example, _ElementTree is determined
+                # as lxml.etree._element._ElementTree, which doesn't
+                # exist in runtime. Try to resolve bare names
+                # instead, which rely on runtime tests importing
+                # them properly before resolving.
+                try:
+                    eval(name, self._globalns, self._localns | self.collected)
+                except NameError as e:
+                    raise NameError(f'Cannot resolve "{prefix}" or "{name}"') from e
+                else:
+                    self.modified = True
+                    return ast.Name(id=name, ctx=node.ctx)
+
+        _ = self.visit(node.value)
+
+        if resolved := getattr(self.collected[prefix], name, False):
+            self.collected[ast.unparse(node)] = resolved
+            return node
+
+        # For class defined in local scope, mypy just prepends test
+        # module name to class name. Of course concerned class does
+        # not exist directly under test module. Use bare name here.
+        try:
+            eval(name, self._globalns, self._localns | self.collected)
+        except NameError:
+            raise
+        else:
+            self.modified = True
+            return ast.Name(id=name, ctx=node.ctx)
+
+    # Mypy usually dumps full inferred type with module name,
+    # but with a few exceptions (like tuple, Union).
+    # visit_Attribute can ultimately recurse into visit_Name
+    # as well
+    def visit_Name(self, node: ast.Name) -> ast.Name:
+        name = node.id
+        try:
+            eval(name, self._globalns, self._localns | self.collected)
+        except NameError:
+            pass
+        else:
+            return node
+
+        try:
+            mod = importlib.import_module(name)
+        except ModuleNotFoundError:
+            pass
+        else:
+            self.collected[name] = mod
+            return node
+
+        if hasattr(self.collected["typing"], name):
+            self.collected[name] = getattr(self.collected["typing"], name)
+            return node
+
+        raise NameError(f'Cannot resolve "{name}"')
+
+    # For class defined inside local function scope, mypy outputs
+    # something like "test_elem_class_lookup.FooClass@97".
+    # 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):
+    id = "mypy"
+    typechecker_result = {}
+    _type_mesg_re = re.compile(r'^Revealed type is "(?P<type>.+?)"$')
+
+    @classmethod
+    def run_typechecker_on(cls, 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 = ""
+            mypy_args.append(f"--config-file={cfg_str}")
+
+        mypy_args.extend(str(p) for p in paths)
+
+        stdout, stderr, returncode = mypy.api.run(mypy_args)
+
+        # fatal error, before evaluation happens
+        # mypy prints text output to stderr, not json
+        if stderr:
+            raise TypeCheckerError(stderr, None, None)
+
+        # So-called mypy json output is merely a line-by-line
+        # transformation of plain text output into json object
+        for line in stdout.splitlines():
+            # TODO Mypy json schema validation
+            diag = cast(_MypyDiagObj, json.loads(line))
+            filename = pathlib.Path(diag["file"]).name
+            pos = FilePos(filename, diag["line"])
+            if diag["severity"] != "note":
+                raise TypeCheckerError(
+                    "Mypy {} with exit code {}: {}".format(
+                        diag["severity"], returncode, diag["message"]
+                    ),
+                    diag["file"],
+                    diag["line"],
+                )
+            if (m := cls._type_mesg_re.match(diag["message"])) is None:
+                continue
+            # Mypy can insert extra character into expression so that it
+            # becomes invalid and unparsable. 0.9x days there
+            # was '*', and now '?' (and '=' for typeddict too).
+            # Try stripping those character and pray we get something
+            # usable for evaluation
+            expression = m["type"].translate({ord(c): None for c in "*?="})
+            # Unlike pyright, mypy output doesn't contain variable name
+            cls.typechecker_result[pos] = VarType(None, ForwardRef(expression))
+
+    @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:
+        # Mypy doesn't have a default config file
+        if (path_str := config.option.revealtype_mypy_config) is None:
+            _logger.info("Using default mypy configuration")
+            return
+
+        # 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",
+        )
+
+
+adapter = _MypyAdapter()

pytest_revealtype_injector-0.1.0/src/pytest_revealtype_injector/adapter/pyright_.py

@@ -0,0 +1,124 @@
+import ast
+import json
+import logging
+import pathlib
+import re
+import shutil
+import subprocess
+from collections.abc import (
+    Iterable,
+)
+from typing import (
+    Any,
+    ForwardRef,
+)
+
+import pytest
+
+from ..models import (
+    FilePos,
+    NameCollectorBase,
+    TypeCheckerAdapter,
+    TypeCheckerError,
+    VarType,
+)
+
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.INFO)
+
+
+class _NameCollector(NameCollectorBase):
+    # Pyright inferred type results always contain bare names only,
+    # so don't need to bother with visit_Attribute()
+    def visit_Name(self, node: ast.Name) -> ast.Name:
+        name = node.id
+        try:
+            eval(name, self._globalns, self._localns | self.collected)
+        except NameError:
+            for m in ("typing", "typing_extensions"):
+                if hasattr(self.collected[m], name):
+                    self.collected[name] = getattr(self.collected[m], name)
+                    return node
+            raise
+        return node
+
+
+class _PyrightAdapter(TypeCheckerAdapter):
+    id = "pyright"
+    typechecker_result = {}
+    _type_mesg_re = re.compile('^Type of "(?P<var>.+?)" is "(?P<type>.+?)"$')
+
+    @classmethod
+    def run_typechecker_on(cls, paths: Iterable[pathlib.Path]) -> None:
+        cmd: list[str] = []
+        if shutil.which("pyright") is not None:
+            cmd.append("pyright")
+        elif shutil.which("npx") is not None:
+            cmd.extend(["npx", "pyright"])
+        else:
+            raise FileNotFoundError("Pyright is required to run test suite")
+
+        cmd.append("--outputjson")
+        if cls.config_file is not None:
+            cmd.extend(["--project", str(cls.config_file)])
+        cmd.extend(str(p) for p in paths)
+
+        proc = subprocess.run(cmd, capture_output=True)
+        if len(proc.stderr):
+            raise TypeCheckerError(proc.stderr.decode(), None, None)
+
+        # TODO Pyright json schema validation
+        report = json.loads(proc.stdout)
+        if proc.returncode:
+            for diag in report["generalDiagnostics"]:
+                if diag["severity"] != "error":
+                    continue
+                # Pyright report lineno is 0-based,
+                # OTOH python frame lineno is 1-based
+                lineno = diag["range"]["start"]["line"] + 1
+                filename = pathlib.Path(diag["file"]).name
+                raise TypeCheckerError(diag["message"], filename, lineno)
+        for diag in report["generalDiagnostics"]:
+            if diag["severity"] != "information":
+                continue
+            lineno = diag["range"]["start"]["line"] + 1
+            filename = pathlib.Path(diag["file"]).name
+            if (m := cls._type_mesg_re.match(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",
+        )
+
+
+adapter = _PyrightAdapter()

pytest_revealtype_injector-0.1.0/src/pytest_revealtype_injector/hooks.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import inspect
+import logging
+
+import pytest
+
+from . import adapter
+from .main import revealtype_injector
+
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.INFO)
+
+
+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:
+    # 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.1.0/src/pytest_revealtype_injector/main.py

@@ -0,0 +1,140 @@
+import ast
+import inspect
+import logging
+import pathlib
+import sys
+from typing import (
+    Any,
+    ForwardRef,
+    TypeVar,
+)
+
+from typeguard import (
+    TypeCheckError,
+    TypeCheckMemo,
+    check_type_internal,
+)
+
+from . import adapter
+from .models import (
+    FilePos,
+    TypeCheckerError,
+    VarType,
+)
+
+_T = TypeVar("_T")
+
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.WARN)
+
+
+class RevealTypeExtractor(ast.NodeVisitor):
+    target = None
+
+    def visit_Call(self, node: ast.Call) -> Any:
+        # HACK node.func is not necessarily "reveal_type" as we allow
+        # "import as" syntax. We just assume the outmost call is
+        # reveal_type(), and never descend into recursive ast.Call nodes.
+        # IDEA Is it possible to retrieve the function name from
+        # pytest_pyfunc_call() hook and store it in stash somewhere?
+        self.target = node.args[0]
+        return node
+
+
+def _get_var_name(frame: inspect.Traceback) -> str | None:
+    ctxt, idx = frame.code_context, frame.index
+    assert ctxt is not None and idx is not None
+    code = ctxt[idx].strip()
+
+    walker = RevealTypeExtractor()
+    # TODO Use 'exec' mode which results in more complex AST but doesn't impose
+    # as much restriction on test code as 'eval' mode does.
+    walker.visit(ast.parse(code, mode="eval"))
+    assert walker.target is not None
+    return ast.get_source_segment(code, walker.target)
+
+
+def revealtype_injector(var: _T) -> _T:
+    """Replacement of `reveal_type()` that matches static and runtime type
+    checking result
+
+    This function is intended as a drop-in replacement of `reveal_type()` from
+    Python 3.11 or `typing_extensions` module. Under the hook, it uses
+    `typeguard` to get runtime variable type, and compare it with static type
+    checker results for coherence.
+
+    Usage
+    -----
+    No special handling is required. Just import `reveal_type` as usual in
+    pytest test functions, and it will be replaced with this function behind the
+    scene. However, since `reveal_type()` is not available in Python 3.10 or
+    earlier, you need to import it conditionally, like this:
+
+        ```python
+        if sys.version_info >= (3, 11):
+            from typing import reveal_type
+        else:
+            from typing_extensions import reveal_type
+        ```
+
+    The signature is identical to official `reveal_type()`:
+    returns input argument unchanged.
+
+    Raises
+    ------
+    `TypeCheckerError`
+        If static type checker failed to get inferred type
+        for variable
+    `typeguard.TypeCheckError`
+        If type checker result doesn't match runtime result
+    """
+    # As a wrapper of typeguard.check_type_interal(),
+    # get data from my caller, not mine
+    caller_frame = sys._getframe(1)  # pyright: ignore[reportPrivateUsage]
+    caller = inspect.getframeinfo(caller_frame)
+    var_name = _get_var_name(caller)
+    pos = FilePos(pathlib.Path(caller.filename).name, caller.lineno)
+
+    globalns = caller_frame.f_globals
+    localns = caller_frame.f_locals
+
+    for adp in adapter.discovery():
+        if not adp.enabled:
+            continue
+        try:
+            tc_result = adp.typechecker_result[pos]
+        except KeyError as e:
+            raise TypeCheckerError(
+                f"No inferred type from {adp.id}", pos.file, pos.lineno
+            ) from e
+
+        if tc_result.var:  # Only pyright has this extra protection
+            if tc_result.var != var_name:
+                raise TypeCheckerError(
+                    f'Variable name should be "{tc_result.var}", but got "{var_name}"',
+                    pos.file,
+                    pos.lineno,
+                )
+        else:
+            adp.typechecker_result[pos] = VarType(var_name, tc_result.type)
+
+        ref = tc_result.type
+        try:
+            _ = eval(ref.__forward_arg__, globalns, localns)
+        except (TypeError, NameError):
+            ref_ast = ast.parse(ref.__forward_arg__, mode="eval")
+            walker = adp.create_collector(globalns, localns)
+            new_ast = walker.visit(ref_ast)
+            if walker.modified:
+                ref = ForwardRef(ast.unparse(new_ast))
+            memo = TypeCheckMemo(globalns, localns | walker.collected)
+        else:
+            memo = TypeCheckMemo(globalns, localns)
+
+        try:
+            check_type_internal(var, ref, memo)
+        except TypeCheckError as e:
+            e.args = (f"({adp.id}) " + e.args[0],) + e.args[1:]
+            raise
+
+    return var

pytest_revealtype_injector-0.1.0/src/pytest_revealtype_injector/models.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import abc
+import ast
+import importlib
+import pathlib
+import re
+from collections.abc import Iterable
+from typing import (
+    Any,
+    ClassVar,
+    ForwardRef,
+    NamedTuple,
+    cast,
+)
+
+import pytest
+
+
+class FilePos(NamedTuple):
+    file: str
+    lineno: int
+
+
+class VarType(NamedTuple):
+    var: str | None
+    type: ForwardRef
+
+
+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:
+        super().__init__(message)
+        self._filename = filename
+        self._lineno = lineno
+
+    def __str__(self) -> str:
+        if self._filename:
+            return '"{}"{}: {}'.format(
+                self._filename,
+                " line " + str(self._lineno) if self._lineno else "",
+                self.args[0],
+            )
+        else:
+            return str(self.args[0])
+
+
+class NameCollectorBase(ast.NodeTransformer):
+    def __init__(
+        self,
+        globalns: dict[str, Any],
+        localns: dict[str, Any],
+    ) -> None:
+        super().__init__()
+        self._globalns = globalns
+        self._localns = localns
+        self.modified: bool = False
+        # typing_extensions guaranteed to be present,
+        # as a dependency of typeguard
+        self.collected: dict[str, Any] = {
+            m: importlib.import_module(m)
+            for m in ("builtins", "typing", "typing_extensions")
+        }
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.expr:
+        node.value = cast("ast.expr", self.visit(node.value))
+        node.slice = cast("ast.expr", self.visit(node.slice))
+
+        # When type reference is a stub-only specialized class
+        # which don't have runtime support (e.g. lxml classes have
+        # no __class_getitem__), concede by verifying
+        # non-subscripted type.
+        try:
+            eval(ast.unparse(node), self._globalns, self._localns | self.collected)
+        except TypeError as e:
+            if "is not subscriptable" not in e.args[0]:
+                raise
+            # TODO Insert node.value dependent hook for extra
+            # verification of subscript type
+            self.modified = True
+            return node.value
+        else:
+            return node
+
+
+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]]
+    _type_mesg_re: ClassVar[re.Pattern[str]]
+
+    @classmethod
+    @abc.abstractmethod
+    def run_typechecker_on(cls, paths: Iterable[pathlib.Path]) -> None: ...
+    @classmethod
+    @abc.abstractmethod
+    def create_collector(
+        cls, globalns: dict[str, Any], localns: dict[str, Any]
+    ) -> NameCollectorBase: ...
+    @classmethod
+    @abc.abstractmethod
+    def set_config_file(cls, config: pytest.Config) -> None: ...
+    @staticmethod
+    @abc.abstractmethod
+    def add_pytest_option(group: pytest.OptionGroup) -> None: ...

pytest_revealtype_injector-0.1.0/src/pytest_revealtype_injector/plugin.py

@@ -0,0 +1,6 @@
+from .hooks import (
+    pytest_addoption as pytest_addoption,
+    pytest_collection_finish as pytest_collection_finish,
+    pytest_configure as pytest_configure,
+    pytest_pyfunc_call as pytest_pyfunc_call,
+)