Multicall to func

pluggy/__init__.py

@@ -1,6 +1,6 @@
 import inspect
 import warnings
-from .callers import _MultiCall, HookCallError, _raise_wrapfail, _Result
+from .callers import _multicall, HookCallError, _Result, _legacymulticall
 
 __version__ = '0.5.3.dev'
 
@@ -166,25 +166,6 @@ def get(self, name):
         return self.__class__(self.root, self.tags + (name,))
 
 
-def _wrapped_call(wrap_controller, func):
-    """ Wrap calling to a function with a generator which needs to yield
-    exactly once.  The yield point will trigger calling the wrapped function
-    and return its ``_Result`` to the yield point.  The generator then needs
-    to finish (raise StopIteration) in order for the wrapped call to complete.
-    """
-    try:
-        next(wrap_controller)   # first yield
-    except StopIteration:
-        _raise_wrapfail(wrap_controller, "did not yield")
-    call_outcome = _Result.from_call(func)
-    try:
-        wrap_controller.send(call_outcome)
-        _raise_wrapfail(wrap_controller, "has second yield")
-    except StopIteration:
-        pass
-    return call_outcome.get_result()
-
-
 class _TracedHookExecution(object):
     def __init__(self, pluginmanager, before, after):
         self.pluginmanager = pluginmanager
@@ -232,7 +213,7 @@ def __init__(self, project_name, implprefix=None):
         self._inner_hookexec = lambda hook, methods, kwargs: \
             hook.multicall(
                 methods, kwargs, specopts=hook.spec_opts, hook=hook
-            ).execute()
+            )
 
     def _hookexec(self, hook, methods, kwargs):
         # called from all hookcaller instances.
@@ -485,54 +466,6 @@ def subset_hook_caller(self, name, remove_plugins):
         return orig
 
 
-class _LegacyMultiCall(object):
-    """ execute a call into multiple python functions/methods. """
-
-    # XXX note that the __multicall__ argument is supported only
-    # for pytest compatibility reasons.  It was never officially
-    # supported there and is explicitely deprecated since 2.8
-    # so we can remove it soon, allowing to avoid the below recursion
-    # in execute() and simplify/speed up the execute loop.
-
-    def __init__(self, hook_impls, kwargs, specopts={}, hook=None):
-        self.hook = hook
-        self.hook_impls = hook_impls
-        self.caller_kwargs = kwargs  # come from _HookCaller.__call__()
-        self.caller_kwargs["__multicall__"] = self
-        self.specopts = hook.spec_opts if hook else specopts
-
-    def execute(self):
-        caller_kwargs = self.caller_kwargs
-        self.results = results = []
-        firstresult = self.specopts.get("firstresult")
-
-        while self.hook_impls:
-            hook_impl = self.hook_impls.pop()
-            try:
-                args = [caller_kwargs[argname] for argname in hook_impl.argnames]
-            except KeyError:
-                for argname in hook_impl.argnames:
-                    if argname not in caller_kwargs:
-                        raise HookCallError(
-                            "hook call must provide argument %r" % (argname,))
-            if hook_impl.hookwrapper:
-                return _wrapped_call(hook_impl.function(*args), self.execute)
-            res = hook_impl.function(*args)
-            if res is not None:
-                if firstresult:
-                    return res
-                results.append(res)
-
-        if not firstresult:
-            return results
-
-    def __repr__(self):
-        status = "%d meths" % (len(self.hook_impls),)
-        if hasattr(self, "results"):
-            status = ("%d results, " % len(self.results)) + status
-        return "<_MultiCall %s, kwargs=%r>" % (status, self.caller_kwargs)
-
-
 def varnames(func):
     """Return tuple of positional and keywrord argument names for a function,
     method, class or callable.
@@ -602,7 +535,7 @@ def __init__(self, name, hook_execute, specmodule_or_class=None, spec_opts=None)
         self._hookexec = hook_execute
         self.argnames = None
         self.kwargnames = None
-        self.multicall = _MultiCall
+        self.multicall = _multicall
         if specmodule_or_class is not None:
             assert spec_opts is not None
             self.set_specification(specmodule_or_class, spec_opts)
@@ -659,7 +592,7 @@ def _add_hookimpl(self, hookimpl):
                 "removed in an upcoming release.",
                 DeprecationWarning
             )
-            self.multicall = _LegacyMultiCall
+            self.multicall = _legacymulticall
 
     def __repr__(self):
         return "<_HookCaller %r>" % (self.name,)

pluggy/callers.py

@@ -77,67 +77,128 @@ def get_result(self):
             _reraise(*ex)  # noqa
 
 
-class _MultiCall(object):
-    """Execute a call into multiple python functions/methods.
+def _wrapped_call(wrap_controller, func):
+    """ Wrap calling to a function with a generator which needs to yield
+    exactly once.  The yield point will trigger calling the wrapped function
+    and return its ``_Result`` to the yield point.  The generator then needs
+    to finish (raise StopIteration) in order for the wrapped call to complete.
     """
+    try:
+        next(wrap_controller)   # first yield
+    except StopIteration:
+        _raise_wrapfail(wrap_controller, "did not yield")
+    call_outcome = _Result.from_call(func)
+    try:
+        wrap_controller.send(call_outcome)
+        _raise_wrapfail(wrap_controller, "has second yield")
+    except StopIteration:
+        pass
+    return call_outcome.get_result()
+
+
+class _LegacyMultiCall(object):
+    """ execute a call into multiple python functions/methods. """
+
+    # XXX note that the __multicall__ argument is supported only
+    # for pytest compatibility reasons.  It was never officially
+    # supported there and is explicitely deprecated since 2.8
+    # so we can remove it soon, allowing to avoid the below recursion
+    # in execute() and simplify/speed up the execute loop.
+
     def __init__(self, hook_impls, kwargs, specopts={}, hook=None):
         self.hook = hook
         self.hook_impls = hook_impls
         self.caller_kwargs = kwargs  # come from _HookCaller.__call__()
+        self.caller_kwargs["__multicall__"] = self
         self.specopts = hook.spec_opts if hook else specopts
 
     def execute(self):
-        __tracebackhide__ = True
         caller_kwargs = self.caller_kwargs
         self.results = results = []
         firstresult = self.specopts.get("firstresult")
-        excinfo = None
-        try:  # run impl and wrapper setup functions in a loop
-            teardowns = []
-            try:
-                for hook_impl in reversed(self.hook_impls):
-                    try:
-                        args = [caller_kwargs[argname] for argname in hook_impl.argnames]
-                        # args = operator.itemgetter(hookimpl.argnames)(caller_kwargs)
-                    except KeyError:
-                        for argname in hook_impl.argnames:
-                            if argname not in caller_kwargs:
-                                raise HookCallError(
-                                    "hook call must provide argument %r" % (argname,))
-
-                    if hook_impl.hookwrapper:
-                        try:
-                            gen = hook_impl.function(*args)
-                            next(gen)   # first yield
-                            teardowns.append(gen)
-                        except StopIteration:
-                            _raise_wrapfail(gen, "did not yield")
-                    else:
-                        res = hook_impl.function(*args)
-                        if res is not None:
-                            results.append(res)
-                            if firstresult:  # halt further impl calls
-                                break
-            except BaseException:
-                excinfo = sys.exc_info()
-        finally:
-            if firstresult:  # first result hooks return a single value
-                outcome = _Result(results[0] if results else None, excinfo)
-            else:
-                outcome = _Result(results, excinfo)
-
-            # run all wrapper post-yield blocks
-            for gen in reversed(teardowns):
-                try:
-                    gen.send(outcome)
-                    _raise_wrapfail(gen, "has second yield")
-                except StopIteration:
-                    pass
 
-            return outcome.get_result()
+        while self.hook_impls:
+            hook_impl = self.hook_impls.pop()
+            try:
+                args = [caller_kwargs[argname] for argname in hook_impl.argnames]
+            except KeyError:
+                for argname in hook_impl.argnames:
+                    if argname not in caller_kwargs:
+                        raise HookCallError(
+                            "hook call must provide argument %r" % (argname,))
+            if hook_impl.hookwrapper:
+                return _wrapped_call(hook_impl.function(*args), self.execute)
+            res = hook_impl.function(*args)
+            if res is not None:
+                if firstresult:
+                    return res
+                results.append(res)
+
+        if not firstresult:
+            return results
 
     def __repr__(self):
         status = "%d meths" % (len(self.hook_impls),)
         if hasattr(self, "results"):
             status = ("%d results, " % len(self.results)) + status
         return "<_MultiCall %s, kwargs=%r>" % (status, self.caller_kwargs)
+
+
+def _legacymulticall(hook_impls, caller_kwargs, specopts={}, hook=None):
+    return _LegacyMultiCall(
+        hook_impls, caller_kwargs, specopts=specopts, hook=hook).execute()
+
+
+def _multicall(hook_impls, caller_kwargs, specopts={}, hook=None):
+    """Execute a call into multiple python functions/methods and return the
+    result(s).
+
+    ``caller_kwargs`` comes from _HookCaller.__call__().
+    """
+    __tracebackhide__ = True
+    specopts = hook.spec_opts if hook else specopts
+    results = []
+    firstresult = specopts.get("firstresult")
+    excinfo = None
+    try:  # run impl and wrapper setup functions in a loop
+        teardowns = []
+        try:
+            for hook_impl in reversed(hook_impls):
+                try:
+                    args = [caller_kwargs[argname] for argname in hook_impl.argnames]
+                except KeyError:
+                    for argname in hook_impl.argnames:
+                        if argname not in caller_kwargs:
+                            raise HookCallError(
+                                "hook call must provide argument %r" % (argname,))
+
+                if hook_impl.hookwrapper:
+                    try:
+                        gen = hook_impl.function(*args)
+                        next(gen)   # first yield
+                        teardowns.append(gen)
+                    except StopIteration:
+                        _raise_wrapfail(gen, "did not yield")
+                else:
+                    res = hook_impl.function(*args)
+                    if res is not None:
+                        results.append(res)
+                        if firstresult:  # halt further impl calls
+                            break
+        except BaseException:
+            excinfo = sys.exc_info()
+    finally:
+        if firstresult:  # first result hooks return a single value
+            outcome = _Result(results[0] if results else None, excinfo)
+        else:
+            outcome = _Result(results, excinfo)
+
+        # run all wrapper post-yield blocks
+        for gen in reversed(teardowns):
+            try:
+                gen.send(outcome)
+                _raise_wrapfail(gen, "has second yield")
+            except StopIteration:
+                pass
+
+        return outcome.get_result()

testing/benchmark.py

@@ -2,7 +2,7 @@
 Benchmarking and performance tests.
 """
 import pytest
-from pluggy import (_MultiCall, _LegacyMultiCall, HookImpl, HookspecMarker,
+from pluggy import (_multicall, _legacymulticall, HookImpl, HookspecMarker,
                     HookimplMarker)
 
 hookspec = HookspecMarker("example")
@@ -28,31 +28,31 @@ def wrapper(arg1, arg2, arg3):
 
 
 @pytest.fixture(
-    params=[0, 1, 10, 100],
+    params=[10, 100],
     ids="hooks={}".format,
 )
 def hooks(request):
     return [hook for i in range(request.param)]
 
 
 @pytest.fixture(
-    params=[0, 1, 10, 100],
+    params=[10, 100],
     ids="wrappers={}".format,
 )
 def wrappers(request):
     return [wrapper for i in range(request.param)]
 
 
 @pytest.fixture(
-    params=[_MultiCall, _LegacyMultiCall],
+    params=[_multicall, _legacymulticall],
     ids=lambda item: item.__name__
 )
 def callertype(request):
     return request.param
 
 
 def inner_exec(methods, callertype):
-    return MC(methods, {'arg1': 1, 'arg2': 2, 'arg3': 3}, callertype).execute()
+    return MC(methods, {'arg1': 1, 'arg2': 2, 'arg3': 3}, callertype)
 
 
 def test_hook_and_wrappers_speed(benchmark, hooks, wrappers, callertype):