Move Final annotations to class level and add type annotations to __slots__ classes

This change improves type safety and code organization by:
- Moving all Final annotations from constructors to class level for consistency
- Adding proper type annotations to all __slots__ classes
- Simplifying constructor assignments by removing redundant type annotations

Classes updated:
- HistoricHookCaller: 5 Final attributes moved to class level
- NormalHookCaller: 4 Final attributes moved to class level
- HookImpl: 11 Final attributes moved to class level
- HookspecMarker: _project_spec moved to class level with Final
- HookimplMarker: _project_spec moved to class level with Final
- HookspecConfiguration: 4 Final attributes moved to class level
- HookimplConfiguration: 6 Final attributes moved to class level
- HookRelay: Added __dict__ type annotation
- SubsetHookCaller: Added type annotations for _orig and _remove_plugins
- HookSpec: Added type annotations for all 8 attributes
- Result: Added type annotations for all 3 attributes

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: RonnyPfannschmidt

src/pluggy/_hook_callers.py

@@ -93,6 +93,7 @@ class HookRelay:
     of registered plugins."""
 
     __slots__ = ("__dict__",)
+    __dict__: dict[str, HookCaller]
 
     def __init__(self) -> None:
         """:meta private:"""
@@ -123,6 +124,11 @@ class HistoricHookCaller:
         "_hookimpls",
         "_call_history",
     )
+    name: Final[str]
+    spec: Final[HookSpec]
+    _hookexec: Final[_HookExec]
+    _hookimpls: Final[list[HookImpl]]
+    _call_history: Final[_CallHistory]
 
     def __init__(
         self,
@@ -134,13 +140,13 @@ def __init__(
         """:meta private:"""
         assert spec_config.historic, "HistoricHookCaller requires historic=True"
         #: Name of the hook getting called.
-        self.name: Final = name
-        self._hookexec: Final = hook_execute
+        self.name = name
+        self._hookexec = hook_execute
         # The hookimpls list for historic hooks (no wrappers supported)
-        self._hookimpls: Final[list[HookImpl]] = []
-        self._call_history: Final[_CallHistory] = []
+        self._hookimpls = []
+        self._call_history = []
         # TODO: Document, or make private.
-        self.spec: Final = HookSpec(specmodule_or_class, name, spec_config)
+        self.spec = HookSpec(specmodule_or_class, name, spec_config)
 
     def has_spec(self) -> bool:
         return True  # HistoricHookCaller always has a spec
@@ -258,6 +264,10 @@ class NormalHookCaller:
         "_hookexec",
         "_hookimpls",
     )
+    name: Final[str]
+    spec: HookSpec | None
+    _hookexec: Final[_HookExec]
+    _hookimpls: Final[list[HookImpl]]
 
     def __init__(
         self,
@@ -268,16 +278,16 @@ def __init__(
     ) -> None:
         """:meta private:"""
         #: Name of the hook getting called.
-        self.name: Final = name
-        self._hookexec: Final = hook_execute
+        self.name = name
+        self._hookexec = hook_execute
         # The hookimpls list. The caller iterates it *in reverse*. Format:
         # 1. trylast nonwrappers
         # 2. nonwrappers
         # 3. tryfirst nonwrappers
         # 4. trylast wrappers
         # 5. wrappers
         # 6. tryfirst wrappers
-        self._hookimpls: Final[list[HookImpl]] = []
+        self._hookimpls = []
         # TODO: Document, or make private.
         self.spec: HookSpec | None = None
         if specmodule_or_class is not None:
@@ -440,6 +450,8 @@ class SubsetHookCaller:
         "_orig",
         "_remove_plugins",
     )
+    _orig: HookCaller
+    _remove_plugins: Set[_Plugin]
 
     def __init__(self, orig: HookCaller, remove_plugins: Set[_Plugin]) -> None:
         self._orig = orig
@@ -579,6 +591,17 @@ class HookImpl:
         "trylast",
         "hookimpl_config",
     )
+    function: Final[_HookImplFunction[object]]
+    argnames: Final[tuple[str, ...]]
+    kwargnames: Final[tuple[str, ...]]
+    plugin: Final[_Plugin]
+    plugin_name: Final[str]
+    wrapper: Final[bool]
+    hookwrapper: Final[bool]
+    optionalhook: Final[bool]
+    tryfirst: Final[bool]
+    trylast: Final[bool]
+    hookimpl_config: Final[HookimplConfiguration]
 
     def __init__(
         self,
@@ -589,33 +612,33 @@ def __init__(
     ) -> None:
         """:meta private:"""
         #: The hook implementation function.
-        self.function: Final = function
+        self.function = function
         argnames, kwargnames = varnames(self.function)
         #: The positional parameter names of ``function```.
-        self.argnames: Final = argnames
+        self.argnames = argnames
         #: The keyword parameter names of ``function```.
-        self.kwargnames: Final = kwargnames
+        self.kwargnames = kwargnames
         #: The plugin which defined this hook implementation.
-        self.plugin: Final = plugin
+        self.plugin = plugin
         #: The :class:`HookimplConfiguration` used to configure this hook
         #: implementation.
-        self.hookimpl_config: Final = hook_impl_config
+        self.hookimpl_config = hook_impl_config
         #: The name of the plugin which defined this hook implementation.
-        self.plugin_name: Final = plugin_name
+        self.plugin_name = plugin_name
         #: Whether the hook implementation is a :ref:`wrapper <hookwrapper>`.
-        self.wrapper: Final = hook_impl_config.wrapper
+        self.wrapper = hook_impl_config.wrapper
         #: Whether the hook implementation is an :ref:`old-style wrapper
         #: <old_style_hookwrappers>`.
-        self.hookwrapper: Final = hook_impl_config.hookwrapper
+        self.hookwrapper = hook_impl_config.hookwrapper
         #: Whether validation against a hook specification is :ref:`optional
         #: <optionalhook>`.
-        self.optionalhook: Final = hook_impl_config.optionalhook
+        self.optionalhook = hook_impl_config.optionalhook
         #: Whether to try to order this hook implementation :ref:`first
         #: <callorder>`.
-        self.tryfirst: Final = hook_impl_config.tryfirst
+        self.tryfirst = hook_impl_config.tryfirst
         #: Whether to try to order this hook implementation :ref:`last
         #: <callorder>`.
-        self.trylast: Final = hook_impl_config.trylast
+        self.trylast = hook_impl_config.trylast
 
     def __repr__(self) -> str:
         return f"<HookImpl plugin_name={self.plugin_name!r}, plugin={self.plugin!r}>"

src/pluggy/_hook_config.py

@@ -81,6 +81,10 @@ class HookspecConfiguration:
         "warn_on_impl",
         "warn_on_impl_args",
     )
+    firstresult: Final[bool]
+    historic: Final[bool]
+    warn_on_impl: Final[Warning | None]
+    warn_on_impl_args: Final[Mapping[str, Warning] | None]
 
     def __init__(
         self,
@@ -104,14 +108,14 @@ def __init__(
         if historic and firstresult:
             raise ValueError("cannot have a historic firstresult hook")
         #: Whether the hook is :ref:`first result only <firstresult>`.
-        self.firstresult: Final = firstresult
+        self.firstresult = firstresult
         #: Whether the hook is :ref:`historic <historic>`.
-        self.historic: Final = historic
+        self.historic = historic
         #: Whether the hook :ref:`warns when implemented <warn_on_impl>`.
-        self.warn_on_impl: Final = warn_on_impl
+        self.warn_on_impl = warn_on_impl
         #: Whether the hook warns when :ref:`certain arguments are requested
         #: <warn_on_impl>`.
-        self.warn_on_impl_args: Final = warn_on_impl_args
+        self.warn_on_impl_args = warn_on_impl_args
 
     def __repr__(self) -> str:
         attrs = []
@@ -139,6 +143,12 @@ class HookimplConfiguration:
         "trylast",
         "specname",
     )
+    wrapper: Final[bool]
+    hookwrapper: Final[bool]
+    optionalhook: Final[bool]
+    tryfirst: Final[bool]
+    trylast: Final[bool]
+    specname: Final[str | None]
 
     def __init__(
         self,
@@ -169,21 +179,21 @@ def __init__(
             The name of the hook specification to match, see :ref:`specname`.
         """
         #: Whether the hook implementation is a :ref:`wrapper <hookwrapper>`.
-        self.wrapper: Final = wrapper
+        self.wrapper = wrapper
         #: Whether the hook implementation is an :ref:`old-style wrapper
         #: <old_style_hookwrappers>`.
-        self.hookwrapper: Final = hookwrapper
+        self.hookwrapper = hookwrapper
         #: Whether validation against a hook specification is :ref:`optional
         #: <optionalhook>`.
-        self.optionalhook: Final = optionalhook
+        self.optionalhook = optionalhook
         #: Whether to try to order this hook implementation :ref:`first
         #: <callorder>`.
-        self.tryfirst: Final = tryfirst
+        self.tryfirst = tryfirst
         #: Whether to try to order this hook implementation :ref:`last
         #: <callorder>`.
-        self.trylast: Final = trylast
+        self.trylast = trylast
         #: The name of the hook specification to match, see :ref:`specname`.
-        self.specname: Final = specname
+        self.specname = specname
 
     def __repr__(self) -> str:
         attrs = []

src/pluggy/_hook_markers.py

@@ -100,9 +100,10 @@ class HookspecMarker:
     """
 
     __slots__ = ("_project_spec",)
+    _project_spec: Final[_project.ProjectSpec]
 
     def __init__(self, project_name_or_spec: str | _project.ProjectSpec) -> None:
-        self._project_spec: Final = (
+        self._project_spec = (
             _project.ProjectSpec(project_name_or_spec)
             if isinstance(project_name_or_spec, str)
             else project_name_or_spec
@@ -194,9 +195,10 @@ class HookimplMarker:
     """
 
     __slots__ = ("_project_spec",)
+    _project_spec: Final[_project.ProjectSpec]
 
     def __init__(self, project_name_or_spec: str | _project.ProjectSpec) -> None:
-        self._project_spec: Final = (
+        self._project_spec = (
             _project.ProjectSpec(project_name_or_spec)
             if isinstance(project_name_or_spec, str)
             else project_name_or_spec
@@ -322,6 +324,14 @@ class HookSpec:
         "warn_on_impl",
         "warn_on_impl_args",
     )
+    namespace: _Namespace
+    function: Callable[..., object]
+    name: str
+    argnames: tuple[str, ...]
+    kwargnames: tuple[str, ...]
+    config: HookspecConfiguration
+    warn_on_impl: Warning | None
+    warn_on_impl_args: Mapping[str, Warning] | None
 
     def __init__(
         self, namespace: _Namespace, name: str, config: HookspecConfiguration

src/pluggy/_result.py

@@ -27,6 +27,9 @@ class Result(Generic[ResultType]):
     <hookwrappers>`."""
 
     __slots__ = ("_result", "_exception", "_traceback")
+    _result: ResultType | None
+    _exception: BaseException | None
+    _traceback: TracebackType | None
 
     def __init__(
         self,