faster baseline import

src/pluggy/__init__.py

@@ -25,13 +25,25 @@
 from ._hooks import HookCaller
 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
 from ._manager import PluginValidationError
 from ._result import HookCallError
 from ._result import Result
 from ._warnings import PluggyTeardownRaisedWarning
 from ._warnings import PluggyWarning
+
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+ from ._types import HookimplOpts
+ from ._types import HookspecOpts
+else:
+
+ def __getattr__(name: str) -> object:
+ if name.endswith("Opts"):
+ from . import _types
+
+ return getattr(_types, name)
+ raise AttributeError(name)

src/pluggy/_callers.py

@@ -4,13 +4,6 @@
 
 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
@@ -19,12 +12,26 @@
 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],
- Generator[None, object, object],
-]
+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],
+ ]
+else:
+
+ def cast(t, v):
+ return v
 
 
 def _raise_wrapfail(
@@ -84,7 +91,7 @@
  # If this cast is not valid, a type error is raised below,
  # which is the desired response.
  res = hook_impl.function(*args)
- wrapper_gen = cast(Generator[None, Result[object], None], res)
+ wrapper_gen = cast("Generator[None, Result[object], None]", res)
  next(wrapper_gen) # first yield
  teardowns.append((wrapper_gen, hook_impl))
  except StopIteration:
@@ -94,7 +101,7 @@
  # If this cast is not valid, a type error is raised below,
  # which is the desired response.
  res = hook_impl.function(*args)
- function_gen = cast(Generator[None, object, object], res)
+ function_gen = cast("Generator[None, object, object]", res)
  next(function_gen) # first yield
  teardowns.append(function_gen)
  except StopIteration:

src/pluggy/_hooks.py

@@ -4,76 +4,51 @@
 
 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
 
-
-_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
+
+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 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]]]]
+
+ from ._types import HookimplOpts
+ from ._types import HookspecOpts
+else:
+
+ def final(func: _F) -> _F:
+ return func
+
+ overload = final
 
 
 @final
@@ -299,6 +274,8 @@
  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__
@@ -376,9 +353,6 @@
 _HookRelay = HookRelay
 
 
-_CallHistory = List[Tuple[Mapping[str, object], Optional[Callable[[Any], None]]]]
-
-
 class HookCaller:
  """A caller of all registered implementations of a hook specification."""
 

src/pluggy/_importlib_metadata.py

@@ -0,0 +1,69 @@
+"""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