pytest-revealtype-injector 0.4.1__tar.gz → 0.5.1__tar.gz

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-revealtype-injector
-Version: 0.4.1
+Version: 0.5.1
 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>
@@ -37,7 +37,7 @@ 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.
+- Launch external static type checkers (`basesdpyright`, `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
@@ -54,7 +54,17 @@ For using `reveal_type()` inside tests, there is no boiler plate code involved.
 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):
+If you care about compatibility with older pythons, use:
+
+```python
+import sys
+if sys.version >= (3, 11):
+    from typing import reveal_type
+else:
+    from typing_extensions import reveal_type
+```
+
+Just importing `typing` (or `typing_extensions`) module is fine too:
 
 ```python
 import typing
@@ -64,7 +74,7 @@ def test_something():
     typing.reveal_type(x)  # typeguard fails here
 ```
 
-Since this plugin scans for `reveal_type()` for replacement under carpet, even `import ... as ...` syntax works too:
+Since this plugin scans for `reveal_type()` for replacement under carpet, even `import ... as ...` syntax works:
 
 ```python
 import typing as typ  # or...
@@ -84,7 +94,12 @@ def test_something():
     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).
+2. `reveal_type()` calls have to stay within a single line, although you can use `reveal_type` result in assertion or other purpose:
+
+```python
+x = "1"
+assert reveal_type(str(int(x))) == x
+```
 
 ## Logging
 

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.1}/README.md

@@ -5,7 +5,7 @@
 
 `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.
+- Launch external static type checkers (`basesdpyright`, `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
@@ -22,7 +22,17 @@ For using `reveal_type()` inside tests, there is no boiler plate code involved.
 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):
+If you care about compatibility with older pythons, use:
+
+```python
+import sys
+if sys.version >= (3, 11):
+    from typing import reveal_type
+else:
+    from typing_extensions import reveal_type
+```
+
+Just importing `typing` (or `typing_extensions`) module is fine too:
 
 ```python
 import typing
@@ -32,7 +42,7 @@ def test_something():
     typing.reveal_type(x)  # typeguard fails here
 ```
 
-Since this plugin scans for `reveal_type()` for replacement under carpet, even `import ... as ...` syntax works too:
+Since this plugin scans for `reveal_type()` for replacement under carpet, even `import ... as ...` syntax works:
 
 ```python
 import typing as typ  # or...
@@ -52,7 +62,12 @@ def test_something():
     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).
+2. `reveal_type()` calls have to stay within a single line, although you can use `reveal_type` result in assertion or other purpose:
+
+```python
+x = "1"
+assert reveal_type(str(int(x))) == x
+```
 
 ## Logging
 

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.1}/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.4.1"
+__version__ = "0.5.1"

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.1}/src/pytest_revealtype_injector/hooks.py

@@ -17,7 +17,6 @@ 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"):
@@ -25,31 +24,46 @@ def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
 
         item = getattr(pyfuncitem.module, name)
         if inspect.isfunction(item):
-            if item.__name__ == "reveal_type" and item.__module__ in {
+            if item.__name__ != "reveal_type" or item.__module__ not in {
                 "typing",
                 "typing_extensions",
             }:
-                setattr(pyfuncitem.module, name, injected)
-                _logger.info(f"Replaced {name}() from global import with {injected}")
                 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
 
-        if inspect.ismodule(item):
+        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}")
-            continue
+            break
 
 
 def pytest_collection_finish(session: pytest.Session) -> None:
     files = {i.path for i in session.items}
+    if not files:
+        return
     for adp in session.config.stash[adapter_stash_key]:
         try:
             adp.run_typechecker_on(files)
         except Exception as e:
             _logger.error(f"({adp.id}) {e}")
-            pytest.exit(f"({type(e).__name__}) " + str(e), pytest.ExitCode.INTERNAL_ERROR)
+            pytest.exit(
+                f"({type(e).__name__}) " + str(e), pytest.ExitCode.INTERNAL_ERROR
+            )
         else:
             _logger.info(f"({adp.id}) Type checker ran successfully")
 

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.1}/src/pytest_revealtype_injector/main.py

@@ -27,41 +27,50 @@ _logger = log.get_logger()
 
 
 class RevealTypeExtractor(ast.NodeVisitor):
-    target = None
+    def __init__(self, funcname: str | None = None) -> None:
+        self._rt_funcname = funcname  # normally "reveal_type"
+        self.target: ast.expr | None = 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
+        # If we don't know how reveal_type is called, just assume
+        # it is the outmost call.
+        if not self._rt_funcname:
+            self.target = node.args[0]
+            return node
+        if ast.unparse(node.func).strip() == self._rt_funcname:
+            self.target = node.args[0]
+        else:
+            self.generic_visit(node)
 
 
-def _get_var_name(frame: inspect.Traceback) -> str | None:
+def _get_var_name(frame: inspect.Traceback, rt_funcname: str) -> str | None:
     filename = pathlib.Path(frame.filename)
     if not filename.exists():
         _logger.warning(
             f"Stack frame points to file '{filename}' "
             "which doesn't exist on local system."
         )
+    # TODO is it possible to have multiline reveal_type()?
     ctxt, idx = frame.code_context, frame.index
     assert ctxt is not None
     assert idx is not None
     code = ctxt[idx].strip()
 
-    walker = RevealTypeExtractor()
-    # TODO Use 'exec' mode which results in more complex AST but doesn't impose
+    walker = RevealTypeExtractor(rt_funcname)
+    # 'exec' mode 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"))
+    walker.visit(ast.parse(code, mode="exec"))
     assert walker.target is not None
     result = ast.get_source_segment(code, walker.target)
     _logger.debug(f"Extraction OK: {code=}, {result=}")
     return result
 
 
-def revealtype_injector(var: _T, adapters: set[TypeCheckerAdapter]) -> _T:
+def revealtype_injector(
+    var: _T,
+    adapters: set[TypeCheckerAdapter],
+    rt_funcname: str,
+) -> _T:
     """Replacement of `reveal_type()` that matches static and runtime type
     checking result
 
@@ -99,7 +108,7 @@ def revealtype_injector(var: _T, adapters: set[TypeCheckerAdapter]) -> _T:
     # 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)
+    var_name = _get_var_name(caller, rt_funcname)
     pos = FilePos(pathlib.Path(caller.filename).name, caller.lineno)
 
     globalns = caller_frame.f_globals

pytest_revealtype_injector-0.5.1/tests/test_ast_mode.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import pytest
+
+
+class TestAstExecMode:
+    def test_return_result(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
+
+            if sys.version_info >= (3, 11):
+                from typing import reveal_type
+            else:
+                from typing_extensions import reveal_type
+
+            def test_result_int() -> None:
+                x = 1
+                assert reveal_type(x) == 0 + 1
+
+            def test_result_str() -> None:
+                x = "foo"
+                if hasattr(x, "lower"):
+                    assert reveal_type(x.lower()) is not None
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)
+
+    def test_nested_call(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
+
+            if sys.version_info >= (3, 11):
+                from typing import reveal_type as rt
+            else:
+                from typing_extensions import reveal_type as rt
+
+            def test_inner_call() -> None:
+                x = 42
+                assert int(rt(str(x).upper())) == x
+
+            def test_outer_call() -> None:
+                x = "42"
+                assert rt(str(int(x)).upper()) == x
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)