pytest-revealtype-injector 0.6.2__tar.gz → 0.7.0__tar.gz

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: pytest-revealtype-injector
-Version: 0.6.2
+Version: 0.7.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-Expression: MIT
-License-File: COPYING
 License-File: COPYING.mit
 Keywords: annotation,dynamic-typing,pytest,reveal_type,static-typing,stub,stubs,type-checking,types,typing
 Classifier: Development Status :: 4 - Beta
@@ -22,8 +21,8 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: pytest<9,>=7.0
-Requires-Dist: schema==0.7.7
+Requires-Dist: pytest>=7.0
+Requires-Dist: schema>=0.7.8
 Requires-Dist: typeguard>=4.3
 Requires-Dist: typing-extensions>=4.0; python_version < '3.11'
 Description-Content-Type: text/markdown
@@ -156,3 +155,6 @@ FAILED tests/runtime/test_attrib.py::TestAttrib::test_superfluous - typeguard.Ty
 ## 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.
+
+License-wise, originally it was part of `types-lxml` project, which is released under Apache-2.0 license. But as the sole author, it is at my own discretion to follow pytest
+license (which is MIT) because this project is taking shape as a pytest plugin.

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/README.md

@@ -126,3 +126,6 @@ FAILED tests/runtime/test_attrib.py::TestAttrib::test_superfluous - typeguard.Ty
 ## 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.
+
+License-wise, originally it was part of `types-lxml` project, which is released under Apache-2.0 license. But as the sole author, it is at my own discretion to follow pytest
+license (which is MIT) because this project is taking shape as a pytest plugin.

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/pyproject.toml

@@ -16,10 +16,9 @@ license = 'MIT'
 license-files = ['COPYING*']
 dependencies = [
     'typing_extensions >= 4.0; python_version < "3.11"',
-    'pytest >=7.0,<9',
+    'pytest >=7.0',
     'typeguard >= 4.3',
-    # schema with annotation support is still unreleased
-    'schema == 0.7.7',
+    'schema >= 0.7.8',
 ]
 keywords = [
     'pytest',
@@ -74,13 +73,11 @@ packages = ["src/pytest_revealtype_injector"]
 typeCheckingMode = 'strict'
 enableTypeIgnoreComments = false
 deprecateTypingAliases = true
-reportMissingTypeStubs = false
 
 [tool.mypy]
 mypy_path = "$MYPY_CONFIG_FILE_DIR/src"
 packages = "pytest_revealtype_injector"
 strict = true
-ignore_missing_imports = true
 
 [tool.ruff]
 target-version = "py312"
@@ -128,6 +125,7 @@ pythonpath = [
 # and never does any permanent change with it
 [tool.semantic_release]
 version_variables = ['src/pytest_revealtype_injector/__init__.py:__version__']
+allow_zero_version = true  # switch off for 1.0.0
 major_on_zero = false  # switch on for 1.0.0
 
 [tool.semantic_release.changelog]

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.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.6.2"
+__version__ = "0.7.0"

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/src/pytest_revealtype_injector/adapter/__init__.py

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

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/src/pytest_revealtype_injector/adapter/mypy_.py

@@ -150,7 +150,7 @@ def _strip_unwanted_char(input: str) -> str:
             _ = ast.parse(result)
         except SyntaxError as e:
             assert e.offset is not None
-            result = result[:e.offset-1] + result[e.offset:]
+            result = result[: e.offset - 1] + result[e.offset :]
         else:
             return result
 

pytest_revealtype_injector-0.7.0/src/pytest_revealtype_injector/adapter/pyrefly_.py

@@ -0,0 +1,133 @@
+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 ForwardRef, Literal, TypedDict, cast
+
+if sys.version_info >= (3, 11):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+import schema as s
+
+from ..log import get_logger
+from ..models import (
+    BareNameCollector,
+    FilePos,
+    TypeCheckerAdapter,
+    TypeCheckerError,
+    VarType,
+)
+
+_logger = get_logger()
+
+
+class _PyreflyDiagItem(TypedDict):
+    line: int
+    column: int
+    stop_line: int
+    stop_column: int
+    path: str
+    code: int
+    name: str
+    description: str
+    concise_description: str
+    severity: Literal["error", "warn", "info"]
+
+
+class NameCollector(BareNameCollector):
+    type_checker = "pyrefly"
+
+    # Pyrefly renders local class as Attribute nodes. Override to
+    # only use bare names.
+    def visit_Attribute(self, node: ast.Attribute) -> ast.expr:
+        self.modified = True
+        # TODO should have been more robust by checking if node.value
+        # resolves to a pytest function or method
+        return ast.Name(id=node.attr, ctx=node.ctx)
+
+class PyreflyAdapter(TypeCheckerAdapter):
+    id = "pyrefly"
+    _executable = "pyrefly"
+    _type_mesg_re = re.compile(r'revealed type: (?P<type>.+)')
+    _namecollector_class = NameCollector
+    _schema = s.Schema({
+        "line": int,
+        "column": int,
+        "stop_line": int,   
+        "stop_column": int,
+        "path": str,
+        "code": int,
+        "name": str,
+        "description": str,
+        "concise_description": str,
+        "severity": s.Or(s.Schema("error"), s.Schema("warn"), s.Schema("info")),
+    })
+
+    def run_typechecker_on(self, paths: Iterable[pathlib.Path]) -> None:
+        cmd: list[str] = []
+        if shutil.which(self._executable) is not None:
+            cmd.append(self._executable)
+        else:
+            raise FileNotFoundError(f"{self._executable} is required to run test suite")
+
+        cmd.extend(["check", "--output-format", "json"])
+        if True:  # TODO Needs to detect python version from project
+            cmd.extend(["--python-version", "3.11"])
+        cmd.extend(str(p) for p in paths)
+
+        _logger.debug(f"({self.id}) Run command: {cmd}")
+        proc = subprocess.run(cmd, capture_output=True)
+        # Return code: 1=normal error, 2=facebook reserved, 3=internal error
+        # Pyrefly unconditionally outputs error count to stderr regardless
+        # of exit status
+        if proc.returncode > 0:
+            raise TypeCheckerError(
+                "{} error with exit code {}: {}".format(self.id, proc.returncode, proc.stderr.decode()), None, None)
+
+        try:
+            report = json.loads(proc.stdout)
+        except Exception as e:
+            raise TypeCheckerError(f"Failed to parse pyrefly JSON output: {e}", None, None) from e
+
+        assert isinstance(report, dict) and "errors" in report
+        items = cast(list[_PyreflyDiagItem], report["errors"])
+
+        _logger.info(
+            "({}) Return code = {}, diagnostic count = {}.{}".format(
+                self.id,
+                proc.returncode,
+                len(items),
+                " pytest -vv shows all items." if self.log_verbosity < 2 else "",
+            )
+        )
+
+        for item in items:
+            diag = cast(_PyreflyDiagItem, self._schema.validate(item))
+            if self.log_verbosity >= 2:
+                _logger.debug(f"({self.id}) {diag}")
+
+            if diag["name"] != "reveal-type":
+                continue
+            if (m := self._type_mesg_re.fullmatch(diag["description"])) is None:
+                raise TypeCheckerError(
+                    f"({self.id}) unexpected reveal-type message: {diag['description']}",
+                    diag["path"],
+                    diag["line"],
+                )
+
+            filename = pathlib.Path(diag["path"]).name
+            lineno = diag["line"]
+            pos = FilePos(filename, lineno)
+            self.typechecker_result[pos] = VarType(None, ForwardRef(m["type"]))
+
+
+def generate_adapter() -> TypeCheckerAdapter:
+    return PyreflyAdapter()

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/src/pytest_revealtype_injector/adapter/pyright_.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import ast
 import json
 import pathlib
 import re
@@ -13,7 +12,6 @@ from collections.abc import (
 from typing import (
     ForwardRef,
     Literal,
-    TypeVar,
     cast,
 )
 
@@ -26,8 +24,8 @@ import schema as s
 
 from ..log import get_logger
 from ..models import (
+    BareNameCollector,
     FilePos,
-    NameCollectorBase,
     TypeCheckerAdapter,
     TypeCheckerError,
     VarType,
@@ -54,33 +52,8 @@ class _PyrightDiagItem(TypedDict):
     rule: NotRequired[str]
 
 
-class NameCollector(NameCollectorBase):
+class NameCollector(BareNameCollector):
     type_checker = "pyright"
-    # Pre-register common used bare names from typing
-    collected = NameCollectorBase.collected | {
-        k: v
-        for k, v in NameCollectorBase.collected["typing"].__dict__.items()
-        if k[0].isupper() and not isinstance(v, TypeVar)
-    }
-
-    # 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 not hasattr(self.collected[m], name):
-                    continue
-                obj = getattr(self.collected[m], name)
-                self.collected[name] = obj
-                _logger.debug(
-                    f"{self.type_checker} NameCollector resolved '{name}' as {obj}"
-                )
-                return node
-            raise
-        return node
 
 
 class PyrightAdapter(TypeCheckerAdapter):

pytest_revealtype_injector-0.7.0/src/pytest_revealtype_injector/adapter/ty_.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+from collections.abc import Iterable
+from typing import cast
+
+import schema as s
+
+from ..log import get_logger
+from ..models import (
+    BareNameCollector,
+    FilePos,
+    TypeCheckerAdapter,
+    TypeCheckerError,
+    VarType,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+if sys.version_info >= (3, 14):
+    from annotationlib import ForwardRef
+else:
+    from typing import ForwardRef
+
+_logger = get_logger()
+
+
+class _TyDiagPosition(TypedDict):
+    line: int
+    column: int
+
+
+class _TyDiagRange(TypedDict):
+    begin: _TyDiagPosition
+    end: _TyDiagPosition
+
+
+class _TyDiagLocation(TypedDict):
+    path: str
+    positions: _TyDiagRange
+
+
+class _TyDiagItem(TypedDict):
+    check_name: str
+    description: str
+    severity: str
+    fingerprint: str
+    location: _TyDiagLocation
+
+
+class NameCollector(BareNameCollector):
+    type_checker = "ty"
+
+
+class TyAdapter(TypeCheckerAdapter):
+    id = "ty"
+    _executable = "ty"
+    _type_mesg_re = re.compile(r'Revealed type: `(?P<type>.+?)`')
+    _namecollector_class = BareNameCollector
+    _schema = s.Schema({
+        "check_name": str,
+        "description": str,
+        "severity": s.Or(
+            s.Schema("info"),
+            s.Schema("minor"),
+            s.Schema("major"),
+        ),
+        "fingerprint": str,
+        "location": {
+            "path": str,
+            "positions": {
+                "begin": {"line": int, "column": int},
+                "end"  : {"line": int, "column": int},
+            }
+        },
+    })
+
+    def run_typechecker_on(self, paths: Iterable[pathlib.Path]) -> None:
+        if shutil.which(self._executable) is None:
+            raise FileNotFoundError(f"{self._executable} is required to run test suite")
+
+        cmd = [
+            self._executable,
+            "check",
+            "--no-progress",
+            "--output-format",
+            "gitlab",
+        ]
+        cmd.extend(str(p) for p in paths)
+
+        if self.config_file is not None:
+            cmd.extend(["--config-file", str(self.config_file)])
+
+        _logger.debug(f"({self.id}) Run command: {cmd}")
+        proc = subprocess.run(cmd, capture_output=True)
+        if proc.returncode == 101:  # internal error
+            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),
+                " pytest -vv shows all items." if self.log_verbosity < 2 else "",
+            )
+        )
+
+        for item in report:
+            diag = cast(_TyDiagItem, self._schema.validate(item))
+            if self.log_verbosity >= 2:
+                _logger.debug(f"({self.id}) {diag}")
+            if diag["severity"] != ("major" if proc.returncode else "info"):
+                continue
+            match proc.returncode:
+                case 1 | 2:
+                    filename, lineno = (
+                        pathlib.Path(diag["location"]["path"]).name,
+                        diag["location"]["positions"]["begin"]["line"],
+                    )
+                    raise TypeCheckerError(
+                        "{} error with exit code {}: {}".format(
+                            self.id,
+                            proc.returncode,
+                            diag["description"],
+                        ),
+                        filename,
+                        lineno,
+                        diag["check_name"],
+                    )
+                case 0:
+                    pass
+                case _:  # Some future error code
+                    raise TypeCheckerError(
+                        "Unknown {} error with exit code {}: {}".format(
+                            self.id,
+                            proc.returncode,
+                            proc.stderr.decode(),
+                        ),
+                        None,
+                        None,
+                    )
+
+            filename, lineno = (
+                pathlib.Path(diag["location"]["path"]).name,
+                diag["location"]["positions"]["begin"]["line"],
+            )            
+            if (m := self._type_mesg_re.search(diag["description"])) is None:
+                continue
+            pos = FilePos(filename, lineno)
+            self.typechecker_result[pos] = VarType(None, ForwardRef(m["type"]))
+
+def generate_adapter() -> TypeCheckerAdapter:
+    return TyAdapter()

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/src/pytest_revealtype_injector/hooks.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import functools
 import inspect
+from collections.abc import Iterator
 from typing import cast
 
 import pytest
@@ -14,7 +15,8 @@ _logger = log.get_logger()
 adapter_stash_key: pytest.StashKey[set[TypeCheckerAdapter]]
 
 
-def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
+@pytest.hookimpl(wrapper=True)
+def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> Iterator[None]:
     assert pyfuncitem.module is not None
     adp_stash = pyfuncitem.config.stash[adapter_stash_key]
 
@@ -23,7 +25,9 @@ def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
     if mark:
         disabled_adapters = {a.id for a in adp_stash if a.id in mark.args}
         for a in disabled_adapters:
-            _logger.info(f"{a} adapter disabled by 'notypechecker' marker")
+            _logger.info(
+                f"{a} adapter disabled by 'notypechecker' marker in {pyfuncitem.name} test"
+            )
         adapters = {a for a in adp_stash if a.id not in disabled_adapters}
     else:
         adapters = {a for a in adp_stash}
@@ -31,39 +35,47 @@ def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
     if not adapters:
         pytest.fail("All type checkers have been disabled.")
 
-    # Replace reveal_type() with our own function
-    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" or item.__module__ not in {
-                "typing",
-                "typing_extensions",
-            }:
+    # Monkeypatch reveal_type() with our own function, to guarantee
+    # each test func can receive different adapters
+    with pytest.MonkeyPatch.context() as mp:
+        for name in dir(pyfuncitem.module):
+            if name.startswith("__") or name.startswith("@py"):
                 continue
-            injected = functools.partial(
-                revealtype_injector,
-                adapters=adapters,
-                rt_funcname=name,
-            )
-            setattr(pyfuncitem.module, name, injected)
-            _logger.info(f"Replaced {name}() from global import with {injected}")
-            break
 
-        elif inspect.ismodule(item):
-            if item.__name__ not in {"typing", "typing_extensions"}:
-                continue
-            assert hasattr(item, "reveal_type")
-            injected = functools.partial(
-                revealtype_injector,
-                adapters=adapters,
-                rt_funcname=f"{name}.reveal_type",
-            )
-            setattr(item, "reveal_type", injected)
-            _logger.info(f"Replaced {name}.reveal_type() with {injected}")
-            break
+            item = getattr(pyfuncitem.module, name)
+            if inspect.isfunction(item):
+                if item.__name__ != "reveal_type" or item.__module__ not in {
+                    "typing",
+                    "typing_extensions",
+                }:
+                    continue
+                injected = functools.partial(
+                    revealtype_injector,
+                    adapters=adapters,
+                    rt_funcname=name,
+                )
+                mp.setattr(pyfuncitem.module, name, injected)
+                _logger.info(
+                    f"Replaced {name}() from global import with {injected} in {pyfuncitem.name} test"
+                )
+                break
+
+            elif inspect.ismodule(item):
+                if item.__name__ not in {"typing", "typing_extensions"}:
+                    continue
+                assert hasattr(item, "reveal_type")
+                injected = functools.partial(
+                    revealtype_injector,
+                    adapters=adapters,
+                    rt_funcname=f"{name}.reveal_type",
+                )
+                mp.setattr(item, "reveal_type", injected)
+                _logger.info(
+                    f"Replaced {name}.reveal_type() with {injected} in {pyfuncitem.name} test"
+                )
+                break
+
+        return cast(None, (yield))  # type: ignore[redundant-cast]
 
 
 def pytest_collection_finish(session: pytest.Session) -> None:

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/src/pytest_revealtype_injector/main.py

@@ -136,7 +136,7 @@ def revealtype_injector(
         walker = adp.create_collector(globalns, localns)
         try:
             evaluated = eval(ref.__forward_arg__, globalns, localns | walker.collected)
-        except (TypeError, NameError):
+        except (TypeError, NameError, AttributeError):
             old_ast = ast.parse(ref.__forward_arg__, mode="eval")
             new_ast = walker.visit(old_ast)
             if walker.modified:

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/src/pytest_revealtype_injector/models.py

@@ -11,6 +11,7 @@ from typing import (
     ClassVar,
     ForwardRef,
     NamedTuple,
+    TypeVar,
     cast,
 )
 
@@ -98,6 +99,32 @@ class NameCollectorBase(ast.NodeTransformer):
             return node
 
 
+# Some type checkers always produce bare names only,
+# so we can skip Attribute nodes entirely
+class BareNameCollector(NameCollectorBase):
+    type_checker = ""
+    # Pre-register common used bare names from typing
+    collected = NameCollectorBase.collected | {
+        k: v
+        for k, v in NameCollectorBase.collected["typing"].__dict__.items()
+        if k[0].isupper() and not isinstance(v, TypeVar)
+    }
+
+    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 not hasattr(self.collected[m], name):
+                    continue
+                obj = getattr(self.collected[m], name)
+                self.collected[name] = obj
+                return node
+            raise
+        return node
+
+
 class TypeCheckerAdapter:
     # Subclasses need to specify default values for below
     id: ClassVar[str]

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/tests/test_marker.py

@@ -79,7 +79,7 @@ class TestClassMarker:
     else:
         from typing_extensions import reveal_type
 
-    # @pytest.mark.notypechecker('pyright', 'basedpyright')
+    # @pytest.mark.notypechecker('pyright', 'basedpyright', 'ty')
     class TestFoo:
         def test_foo(self) -> None:
             MYPY = False

{pytest_revealtype_injector-0.6.2 → pytest_revealtype_injector-0.7.0}/tests/test_options.py

@@ -60,7 +60,7 @@ class TestDisableTypeChecker:
             """
         )
         content_masked = self.content_fail.format(
-            "pyright: ignore[reportAssignmentType]",
+            "pyright: ignore[reportAssignmentType]  # ty: ignore[invalid-assignment]  # pyrefly: ignore[bad-assignment]",
         )
         pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
             content_masked

pytest_revealtype_injector-0.6.2/COPYING

@@ -1,6 +0,0 @@
-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.