Refactor legacy setuptools compatibility into _compat module

- Create src/pluggy/_compat.py for legacy pkg_resources compatibility
- Move DistFacade from _manager.py to _compat.py
- Update PluginManager to use stdlib Distribution internally
- Add new list_plugin_distributions() method returning unwrapped Distribution objects
- Update list_plugin_distinfo() to wrap with DistFacade for backward compatibility
- Update test import to use _compat module

This separates legacy setuptools API emulation from modern importlib.metadata usage,
while maintaining full backward compatibility.

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

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

Author: RonnyPfannschmidt

src/pluggy/_compat.py

@@ -0,0 +1,44 @@
+"""
+Compatibility layer for legacy setuptools/pkg_resources API.
+
+This module provides backward compatibility wrappers around modern
+importlib.metadata, allowing gradual migration away from setuptools.
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+from typing import Any
+
+
+class DistFacade:
+    """Facade providing pkg_resources.Distribution-like interface.
+
+    This class wraps importlib.metadata.Distribution to provide a
+    compatibility layer for code expecting the legacy pkg_resources API.
+    The primary difference is the ``project_name`` attribute which
+    pkg_resources provided but importlib.metadata.Distribution does not.
+    """
+
+    __slots__ = ("_dist",)
+
+    def __init__(self, dist: importlib.metadata.Distribution) -> None:
+        self._dist = dist
+
+    @property
+    def project_name(self) -> str:
+        """Get the project name (for pkg_resources compatibility).
+
+        This is equivalent to dist.metadata["name"] but matches the
+        pkg_resources.Distribution.project_name attribute.
+        """
+        name: str = self.metadata["name"]
+        return name
+
+    def __getattr__(self, attr: str) -> Any:
+        """Delegate all other attributes to the wrapped Distribution."""
+        return getattr(self._dist, attr)
+
+    def __dir__(self) -> list[str]:
+        """List available attributes including facade additions."""
+        return sorted(dir(self._dist) + ["_dist", "project_name"])

src/pluggy/_manager.py

@@ -15,6 +15,7 @@
 
 from . import _tracing
 from ._callers import _multicall
+from ._compat import DistFacade
 from ._hooks import _HookImplFunction
 from ._hooks import _Namespace
 from ._hooks import _Plugin
@@ -29,7 +30,6 @@
 
 
 if TYPE_CHECKING:
-    # importtlib.metadata import is slow, defer it.
     import importlib.metadata
 
 
@@ -62,24 +62,6 @@ def __init__(self, plugin: _Plugin, message: str) -> None:
         self.plugin = plugin
 
 
-class DistFacade:
-    """Emulate a pkg_resources Distribution"""
-
-    def __init__(self, dist: importlib.metadata.Distribution) -> None:
-        self._dist = dist
-
-    @property
-    def project_name(self) -> str:
-        name: str = self.metadata["name"]
-        return name
-
-    def __getattr__(self, attr: str, default: Any | None = None) -> Any:
-        return getattr(self._dist, attr, default)
-
-    def __dir__(self) -> list[str]:
-        return sorted(dir(self._dist) + ["_dist", "project_name"])
-
-
 class PluginManager:
     """Core class which manages registration of plugin objects and 1:N hook
     calling.
@@ -101,7 +83,9 @@ def __init__(self, project_name: str) -> None:
         #: The project name.
         self.project_name: Final = project_name
         self._name2plugin: Final[dict[str, _Plugin]] = {}
-        self._plugin_distinfo: Final[list[tuple[_Plugin, DistFacade]]] = []
+        self._plugin_distinfo: Final[
+            list[tuple[_Plugin, importlib.metadata.Distribution]]
+        ] = []
         #: The "hook relay", used to call a hook on all registered plugins.
         #: See :ref:`calling`.
         self.hook: Final = HookRelay()
@@ -418,13 +402,33 @@ def load_setuptools_entrypoints(self, group: str, name: str | None = None) -> in
                     continue
                 plugin = ep.load()
                 self.register(plugin, name=ep.name)
-                self._plugin_distinfo.append((plugin, DistFacade(dist)))
+                self._plugin_distinfo.append((plugin, dist))
                 count += 1
         return count
 
     def list_plugin_distinfo(self) -> list[tuple[_Plugin, DistFacade]]:
         """Return a list of (plugin, distinfo) pairs for all
-        setuptools-registered plugins."""
+        setuptools-registered plugins.
+
+        .. note::
+            The distinfo objects are wrapped with :class:`~pluggy._compat.DistFacade`
+            for backward compatibility with the legacy pkg_resources API.
+            Use the modern :meth:`list_plugin_distributions` method to get
+            unwrapped :class:`importlib.metadata.Distribution` objects.
+        """
+        return [(plugin, DistFacade(dist)) for plugin, dist in self._plugin_distinfo]
+
+    def list_plugin_distributions(
+        self,
+    ) -> list[tuple[_Plugin, importlib.metadata.Distribution]]:
+        """Return a list of (plugin, distribution) pairs for all plugins
+        loaded via entry points.
+
+        Returns modern :class:`importlib.metadata.Distribution` objects without
+        the legacy pkg_resources compatibility layer.
+
+        .. versionadded:: 1.6
+        """
         return list(self._plugin_distinfo)
 
     def list_name_plugin(self) -> list[tuple[str, _Plugin]]:

testing/test_details.py

@@ -197,7 +197,7 @@ def myhook(self):
 
 
 def test_dist_facade_list_attributes() -> None:
-    from pluggy._manager import DistFacade
+    from pluggy._compat import DistFacade
 
     fc = DistFacade(distribution("pluggy"))
     res = dir(fc)