WIP: experiment with mypyc

pyproject.toml

@@ -2,6 +2,7 @@
 requires = [
   "setuptools>=65.0",
   "setuptools-scm[toml]>=8.0",
+  "mypy>=1.15",
 ]
 build-backend = "setuptools.build_meta"
 

src/pluggy/__init__.py

@@ -7,7 +7,6 @@
     "HookspecOpts",
     "HookimplOpts",
     "HookImpl",
-    "HookRelay",
     "HookspecMarker",
     "HookimplMarker",
     "Result",
@@ -18,7 +17,6 @@
 from ._hooks import HookImpl
 from ._hooks import HookimplMarker
 from ._hooks import HookimplOpts
-from ._hooks import HookRelay
 from ._hooks import HookspecMarker
 from ._hooks import HookspecOpts
 from ._manager import PluginManager

src/pluggy/_hookrelay.py

@@ -0,0 +1,27 @@
+"""
+separate module for only hookrelay as mypyc doesnt support dynamic attributes/getattr
+"""
+
+from __future__ import annotations
+
+from typing import final
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from pluggy import HookCaller
+
+
+@final
+class HookRelay:
+    """Hook holder object for performing 1:N hook calls where N is the number
+    of registered plugins."""
+
+    __slots__ = ("__dict__",)
+
+    def __init__(self) -> None:
+        """:meta private:"""
+
+    if TYPE_CHECKING:
+
+        def __getattr__(self, name: str) -> HookCaller: ...

src/pluggy/_hooks.py

@@ -17,24 +17,25 @@
 from typing import final
 from typing import Optional
 from typing import overload
-from typing import TYPE_CHECKING
 from typing import TypedDict
 from typing import TypeVar
 from typing import Union
 import warnings
 
+from ._hookrelay import HookRelay
 from ._result import Result
 
 
 _T = TypeVar("_T")
 _F = TypeVar("_F", bound=Callable[..., object])
 _Namespace = Union[ModuleType, type]
 _Plugin = object
-_HookExec = Callable[
-    [str, Sequence["HookImpl"], Mapping[str, object], bool],
-    Union[object, list[object]],
+
+type _HookExec = Callable[
+    [str, Sequence[HookImpl], Mapping[str, object], bool], Union[object, list[object]]
 ]
-_HookImplFunction = Callable[..., Union[_T, Generator[None, Result[_T], None]]]
+
+type _HookImplFunction[T] = Callable[..., Union[T, Generator[None, Result[T], None]]]
 
 
 class HookspecOpts(TypedDict):
@@ -355,21 +356,6 @@ def varnames(func: object) -> tuple[tuple[str, ...], tuple[str, ...]]:
     return args, kwargs
 
 
-@final
-class HookRelay:
-    """Hook holder object for performing 1:N hook calls where N is the number
-    of registered plugins."""
-
-    __slots__ = ("__dict__",)
-
-    def __init__(self) -> None:
-        """:meta private:"""
-
-    if TYPE_CHECKING:
-
-        def __getattr__(self, name: str) -> HookCaller: ...
-
-
 # Historical name (pluggy<=1.2), kept for backward compatibility.
 _HookRelay = HookRelay
 
@@ -388,6 +374,8 @@ class HookCaller:
         "_call_history",
     )
 
+    _call_history: _CallHistory | None
+
     def __init__(
         self,
         name: str,
@@ -407,7 +395,7 @@ def __init__(
         # 5. wrappers
         # 6. tryfirst wrappers
         self._hookimpls: Final[list[HookImpl]] = []
-        self._call_history: _CallHistory | None = None
+        self._call_history = None
         # TODO: Document, or make private.
         self.spec: HookSpec | None = None
         if specmodule_or_class is not None:

src/pluggy/_manager.py

@@ -10,18 +10,19 @@
 from typing import cast
 from typing import Final
 from typing import TYPE_CHECKING
+from typing import TypeAlias
 import warnings
 
 from . import _tracing
 from ._callers import _multicall
+from ._hookrelay import HookRelay
 from ._hooks import _HookImplFunction
 from ._hooks import _Namespace
 from ._hooks import _Plugin
 from ._hooks import _SubsetHookCaller
 from ._hooks import HookCaller
 from ._hooks import HookImpl
 from ._hooks import HookimplOpts
-from ._hooks import HookRelay
 from ._hooks import HookspecOpts
 from ._hooks import normalize_hookimpl_opts
 from ._result import Result
@@ -32,8 +33,10 @@
     import importlib.metadata
 
 
-_BeforeTrace = Callable[[str, Sequence[HookImpl], Mapping[str, Any]], None]
-_AfterTrace = Callable[[Result[Any], str, Sequence[HookImpl], Mapping[str, Any]], None]
+_BeforeTrace: TypeAlias = Callable[[str, Sequence[HookImpl], Mapping[str, Any]], None]
+_AfterTrace: TypeAlias = Callable[
+    [Result[Any], str, Sequence[HookImpl], Mapping[str, Any]], None
+]
 
 
 def _warn_for_function(warning: Warning, function: Callable[..., object]) -> None:

src/pluggy/_result.py

@@ -57,12 +57,12 @@ def exception(self) -> BaseException | None:
     def from_call(cls, func: Callable[[], ResultType]) -> Result[ResultType]:
         """:meta private:"""
         __tracebackhide__ = True
-        result = exception = None
         try:
             result = func()
         except BaseException as exc:
-            exception = exc
-        return cls(result, exception)
+            return cls(None, exc)
+        else:
+            return cls(result, None)
 
     def force_result(self, result: ResultType) -> None:
         """Force the result(s) to ``result``.