Centralize hook configuration extraction in ProjectSpec

Move hook configuration extraction methods from HookspecMarker and HookimplMarker
to ProjectSpec to provide a unified API for accessing hook configurations.

Changes:
- Add ProjectSpec.get_hookspec_config() and get_hookimpl_config() methods
- Remove HookspecMarker._get_hookconfig() and HookimplMarker.get_hookconfig()
- Update PluginManager to use ProjectSpec methods for configuration extraction
- Use getattr with default None instead of exception handling for better performance
- Update tests to use the new ProjectSpec-based API

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

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

Author: RonnyPfannschmidt

src/pluggy/_hooks.py

@@ -296,17 +296,6 @@ def setattr_hookspec_opts(func: _F) -> _F:
         else:
             return setattr_hookspec_opts
 
-    def _get_hookconfig(self, func: Callable[..., object]) -> HookspecConfiguration:
-        """Extract hook specification configuration from a decorated function.
-
-        :param func: A function decorated with this HookspecMarker
-        :return: HookspecConfiguration object containing the hook specification options
-        :raises AttributeError: If the function is not decorated with this marker
-        """
-        attr_name = self.project_name + "_spec"
-        config: HookspecConfiguration = getattr(func, attr_name)
-        return config
-
 
 @final
 class HookimplMarker:
@@ -433,17 +422,6 @@ def setattr_hookimpl_opts(func: _F) -> _F:
         else:
             return setattr_hookimpl_opts(function)
 
-    def get_hookconfig(self, func: Callable[..., object]) -> HookimplConfiguration:
-        """Extract hook implementation configuration from a decorated function.
-
-        :param func: A function decorated with this HookimplMarker
-        :return: HookimplConfiguration object containing the hook implementation options
-        :raises AttributeError: If the function is not decorated with this marker
-        """
-        attr_name = self.project_name + "_impl"
-        config: HookimplConfiguration = getattr(func, attr_name)
-        return config
-
 
 _PYPY = hasattr(sys, "pypy_version_info")
 

src/pluggy/_manager.py

@@ -197,14 +197,10 @@ def _parse_hookimpl(
         if not inspect.isroutine(method):
             return None
 
-        try:
-            # Get hook implementation configuration directly
-            impl_attr = getattr(method, self.project_name + "_impl", None)
-        except Exception:  # pragma: no cover
-            impl_attr = None
-
-        if isinstance(impl_attr, HookimplConfiguration):
-            return impl_attr
+        # Get hook implementation configuration using ProjectSpec
+        impl_config = self._project_spec.get_hookimpl_config(method)
+        if impl_config is not None:
+            return impl_config
 
         # Fall back to legacy parse_hookimpl_opts for compatibility
         # (e.g. pytest override)
@@ -231,14 +227,10 @@ def _parse_hookspec(
         if not inspect.isroutine(method):
             return None
 
-        try:
-            # Get hook specification configuration directly
-            spec_attr = getattr(method, self.project_name + "_spec", None)
-        except Exception:  # pragma: no cover
-            spec_attr = None
-
-        if isinstance(spec_attr, HookspecConfiguration):
-            return spec_attr
+        # Get hook specification configuration using ProjectSpec
+        spec_config = self._project_spec.get_hookspec_config(method)
+        if spec_config is not None:
+            return spec_config
 
         # Fall back to legacy parse_hookspec_opts for compatibility
         legacy_opts = self.parse_hookspec_opts(module_or_class, name)

src/pluggy/_project.py

@@ -4,11 +4,14 @@
 
 from __future__ import annotations
 
+from typing import Callable
 from typing import Final
 from typing import TYPE_CHECKING
 
 
 if TYPE_CHECKING:
+    from ._hooks import HookimplConfiguration
+    from ._hooks import HookspecConfiguration
     from ._manager import PluginManager
 
 
@@ -56,5 +59,31 @@ def create_plugin_manager(self) -> PluginManager:
         """
         return self._plugin_manager_cls(self)
 
+    def get_hookspec_config(
+        self, func: Callable[..., object]
+    ) -> HookspecConfiguration | None:
+        """Extract hook specification configuration from a decorated function.
+
+        :param func: A function that may be decorated with this project's
+            hookspec marker
+        :return: HookspecConfiguration object if found, None if not decorated
+            with this project's hookspec marker
+        """
+        attr_name = self.project_name + "_spec"
+        return getattr(func, attr_name, None)
+
+    def get_hookimpl_config(
+        self, func: Callable[..., object]
+    ) -> HookimplConfiguration | None:
+        """Extract hook implementation configuration from a decorated function.
+
+        :param func: A function that may be decorated with this project's
+            hookimpl marker
+        :return: HookimplConfiguration object if found, None if not decorated
+            with this project's hookimpl marker
+        """
+        attr_name = self.project_name + "_impl"
+        return getattr(func, attr_name, None)
+
     def __repr__(self) -> str:
         return f"ProjectSpec(project_name={self.project_name!r})"

testing/test_hookcaller.py

@@ -5,17 +5,17 @@
 
 import pytest
 
-from pluggy import HookimplMarker
 from pluggy import HookspecConfiguration
-from pluggy import HookspecMarker
 from pluggy import PluginManager
 from pluggy import PluginValidationError
+from pluggy import ProjectSpec
 from pluggy._hooks import HookCaller
 from pluggy._hooks import HookImpl
 
 
-hookspec = HookspecMarker("example")
-hookimpl = HookimplMarker("example")
+project_spec = ProjectSpec("example")
+hookspec = project_spec.hookspec
+hookimpl = project_spec.hookimpl
 
 
 @pytest.fixture
@@ -50,12 +50,14 @@ def wrap(func: FuncT) -> FuncT:
                 hookwrapper=hookwrapper,
                 wrapper=wrapper,
             )(func)
+            config = project_spec.get_hookimpl_config(func)
+            assert config is not None  # Test functions should be decorated
             self.hc._add_hookimpl(
                 HookImpl(
                     None,
                     "<temp>",
                     func,
-                    hookimpl.get_hookconfig(func),
+                    config,
                 ),
             )
             return func
@@ -549,15 +551,16 @@ def test_hookspec_configuration() -> None:
 
 
 def test_hookspec_marker_config_extraction() -> None:
-    """Test that HookspecMarker creates and extracts HookspecConfiguration correctly."""
-    marker = HookspecMarker("test")
+    """Test that ProjectSpec can extract HookspecConfiguration correctly."""
+    test_project_spec = ProjectSpec("test")
+    marker = test_project_spec.hookspec
 
     @marker(firstresult=True, historic=False)
     def test_hook(arg1: str) -> str:
         return arg1
 
-    # Test private config extraction method
-    config = marker._get_hookconfig(test_hook)
+    # Test config extraction method via ProjectSpec
+    config = test_project_spec.get_hookspec_config(test_hook)
     assert isinstance(config, HookspecConfiguration)
     assert config.firstresult is True
     assert config.historic is False

testing/test_multicall.py

@@ -6,14 +6,14 @@
 import pytest
 
 from pluggy import HookCallError
-from pluggy import HookimplMarker
-from pluggy import HookspecMarker
+from pluggy import ProjectSpec
 from pluggy._callers import _multicall
 from pluggy._hooks import HookImpl
 
 
-hookspec = HookspecMarker("example")
-hookimpl = HookimplMarker("example")
+project_spec = ProjectSpec("example")
+hookspec = project_spec.hookspec
+hookimpl = project_spec.hookimpl
 
 
 def MC(
@@ -24,7 +24,9 @@ def MC(
     caller = _multicall
     hookfuncs = []
     for method in methods:
-        f = HookImpl(None, "<temp>", method, hookimpl.get_hookconfig(method))
+        config = project_spec.get_hookimpl_config(method)
+        assert config is not None  # Test functions should be decorated
+        f = HookImpl(None, "<temp>", method, config)
         hookfuncs.append(f)
     return caller("foo", hookfuncs, kwargs, firstresult)
 

testing/test_project_spec.py

@@ -143,7 +143,7 @@ def test_hook_impl() -> None:
 
 
 def test_project_spec_with_get_hookconfig() -> None:
-    """Test that ProjectSpec works with HookimplMarker.get_hookconfig()."""
+    """Test that ProjectSpec works with get_hookimpl_config()."""
     project = ProjectSpec("testproject")
     hookimpl = project.hookimpl
 
@@ -152,9 +152,10 @@ def test_project_spec_with_get_hookconfig() -> None:
     def my_hook_impl() -> None:
         pass
 
-    # Get the configuration
-    config = hookimpl.get_hookconfig(my_hook_impl)
+    # Get the configuration using ProjectSpec
+    config = project.get_hookimpl_config(my_hook_impl)
 
+    assert config is not None
     assert config.tryfirst is True
     assert config.optionalhook is True
     assert config.wrapper is False