cleanups

* switch ruff config to extend-select and enable UP rules
* make mypy --strict pass for src

Author: RonnyPfannschmidt

src/pluggy/_callers.py

@@ -4,28 +4,38 @@
 
 from __future__ import annotations
 
-from typing import cast
-from typing import Generator
-from typing import Mapping
-from typing import NoReturn
-from typing import Sequence
-from typing import Tuple
-from typing import Union
 import warnings
 
 from ._hooks import HookImpl
+from ._result import _raise_wrapfail
 from ._result import HookCallError
 from ._result import Result
-from ._warnings import PluggyTeardownRaisedWarning
-
 
-# Need to distinguish between old- and new-style hook wrappers.
-# Wrapping with a tuple is the fastest type-safe way I found to do it.
-Teardown = Union[
-    Tuple[Generator[None, Result[object], None], HookImpl],
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import cast
+    from typing import Generator
+    from typing import Mapping
+    from typing import NoReturn
+    from typing import Sequence
+    from typing import Tuple
+    from typing import Union
+
+
+    # Need to distinguish between old- and new-style hook wrappers.
+    # Wrapping with a tuple is the fastest type-safe way I found to do it.
+    Teardown = Union[
+        Tuple[Generator[None, Result[object], None], HookImpl],
     Generator[None, object, object],
 ]
 
+from ._hooks import HookImpl
+from ._result import HookCallError
+from ._result import Result
+from ._warnings import PluggyTeardownRaisedWarning
+
+
+
 
 def _raise_wrapfail(
     wrap_controller: (

src/pluggy/_hooks.py

@@ -4,76 +4,87 @@
 
 from __future__ import annotations
 
-import inspect
 import sys
-from types import ModuleType
-from typing import AbstractSet
-from typing import Any
-from typing import Callable
-from typing import Final
-from typing import final
-from typing import Generator
-from typing import List
-from typing import Mapping
-from typing import Optional
-from typing import overload
-from typing import Sequence
-from typing import Tuple
-from typing import TYPE_CHECKING
-from typing import TypedDict
-from typing import TypeVar
-from typing import Union
 import warnings
 
-from ._result import Result
+_Plugin = object
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from types import ModuleType
+    from typing import AbstractSet
+    from typing import Any
+    from typing import Callable
+    from typing import Final
+    from typing import final
+    from typing import Generator
+    from typing import List
+    from typing import Mapping
+    from typing import Optional
+    from typing import overload
+    from typing import Sequence
+    from typing import Tuple
+    from typing import TYPE_CHECKING
+    from typing import TypedDict
+    from typing import TypeVar
+    from typing import Union
+
+    from ._result import Result
+
+
+    _T = TypeVar("_T")
+    _F = TypeVar("_F", bound=Callable[..., object])
+    _Namespace = Union[ModuleType, type]
+    _HookExec = Callable[
+        [str, Sequence["HookImpl"], Mapping[str, object], bool],
+        Union[object, List[object]],
+    ]
+    _HookImplFunction = Callable[..., Union[_T, Generator[None, Result[_T], None]]]
+    _CallHistory = List[Tuple[Mapping[str, object], Optional[Callable[[Any], None]]]]
+
+
+    class HookspecOpts(TypedDict):
+        """Options for a hook specification."""
+
+        #: Whether the hook is :ref:`first result only <firstresult>`.
+        firstresult: bool
+        #: Whether the hook is :ref:`historic <historic>`.
+        historic: bool
+        #: Whether the hook :ref:`warns when implemented <warn_on_impl>`.
+        warn_on_impl: Warning | None
+        #: Whether the hook warns when :ref:`certain arguments are requested
+        #: <warn_on_impl>`.
+        #:
+        #: .. versionadded:: 1.5
+        warn_on_impl_args: Mapping[str, Warning] | None
+
+
+    class HookimplOpts(TypedDict):
+        """Options for a hook implementation."""
+
+        #: Whether the hook implementation is a :ref:`wrapper <hookwrapper>`.
+        wrapper: bool
+        #: Whether the hook implementation is an :ref:`old-style wrapper
+        #: <old_style_hookwrappers>`.
+        hookwrapper: bool
+        #: Whether validation against a hook specification is :ref:`optional
+        #: <optionalhook>`.
+        optionalhook: bool
+        #: Whether to try to order this hook implementation :ref:`first
+        #: <callorder>`.
+        tryfirst: bool
+        #: Whether to try to order this hook implementation :ref:`last
+        #: <callorder>`.
+        trylast: bool
+        #: The name of the hook specification to match, see :ref:`specname`.
+        specname: str | None
+
+else:
+    def final(func: _F) -> _F:
+        return func
+    overload = final
 
 
-_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]],
-]
-_HookImplFunction = Callable[..., Union[_T, Generator[None, Result[_T], None]]]
-
-
-class HookspecOpts(TypedDict):
-    """Options for a hook specification."""
-
-    #: Whether the hook is :ref:`first result only <firstresult>`.
-    firstresult: bool
-    #: Whether the hook is :ref:`historic <historic>`.
-    historic: bool
-    #: Whether the hook :ref:`warns when implemented <warn_on_impl>`.
-    warn_on_impl: Warning | None
-    #: Whether the hook warns when :ref:`certain arguments are requested
-    #: <warn_on_impl>`.
-    #:
-    #: .. versionadded:: 1.5
-    warn_on_impl_args: Mapping[str, Warning] | None
-
-
-class HookimplOpts(TypedDict):
-    """Options for a hook implementation."""
-
-    #: Whether the hook implementation is a :ref:`wrapper <hookwrapper>`.
-    wrapper: bool
-    #: Whether the hook implementation is an :ref:`old-style wrapper
-    #: <old_style_hookwrappers>`.
-    hookwrapper: bool
-    #: Whether validation against a hook specification is :ref:`optional
-    #: <optionalhook>`.
-    optionalhook: bool
-    #: Whether to try to order this hook implementation :ref:`first
-    #: <callorder>`.
-    tryfirst: bool
-    #: Whether to try to order this hook implementation :ref:`last
-    #: <callorder>`.
-    trylast: bool
-    #: The name of the hook specification to match, see :ref:`specname`.
-    specname: str | None
 
 
 @final
@@ -299,6 +310,8 @@ def varnames(func: object) -> tuple[tuple[str, ...], tuple[str, ...]]:
     In case of a class, its ``__init__`` method is considered.
     For methods the ``self`` parameter is not included.
     """
+    import inspect
+
     if inspect.isclass(func):
         try:
             func = func.__init__

src/pluggy/_importlib_metadata.py

@@ -0,0 +1,68 @@
+"""this module contains importlib_metadata usage and importing
+
+it's deferred to avoid import-time dependency on importlib_metadata
+
+.. code-block:: console
+
+   python -X importtime -c 'import pluggy' 2> import0.log
+   tuna import0.log
+
+
+"""
+from __future__ import annotations
+
+import importlib.metadata
+from typing import Any
+
+from . import _manager
+
+
+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: object | None = None) -> Any:
+        return getattr(self._dist, attr, default)
+
+    def __dir__(self) -> list[str]:
+        return sorted(dir(self._dist) + ["_dist", "project_name"])
+
+
+def load_importlib_entrypoints(
+    manager: _manager.PluginManager,
+    group: str,
+    name: str | None = None,
+) -> int:
+    """Load modules from querying the specified setuptools ``group``.
+
+    :param group:
+        Entry point group to load plugins.
+    :param name:
+        If given, loads only plugins with the given ``name``.
+
+    :return:
+        The number of plugins loaded by this call.
+    """
+    count = 0
+    for dist in list(importlib.metadata.distributions()):
+        for ep in dist.entry_points:
+            if (
+                ep.group != group
+                or (name is not None and ep.name != name)
+                # already registered
+                or manager.get_plugin(ep.name)
+                or manager.is_blocked(ep.name)
+            ):
+                continue
+            plugin = ep.load()
+            manager.register(plugin, name=ep.name)
+            manager._plugin_dist_metadata.append((plugin, dist))
+            count += 1
+    return count