Convert _MultiCall into a function

Avoids a class with a single method `execute()` at the expense of
dropping the `__repr__()` support. This should make cython-izing that
much simpler.

Resolves #84

Author: Tyler Goodlet

pluggy/__init__.py

@@ -1,6 +1,6 @@
 import inspect
 import warnings
-from .callers import _MultiCall, HookCallError, _Result, _LegacyMultiCall
+from .callers import _multicall, HookCallError, _Result, _legacymulticall
 
 __version__ = '0.5.3.dev'
 
@@ -213,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.
@@ -535,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)
@@ -592,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

@@ -144,67 +144,61 @@ def __repr__(self):
         return "<_MultiCall %s, kwargs=%r>" % (status, self.caller_kwargs)
 
 
-class _MultiCall(object):
-    """Execute a call into multiple python functions/methods.
-    """
-    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.specopts = hook.spec_opts if hook else specopts
+def _legacymulticall(hook_impls, caller_kwargs, specopts={}, hook=None):
+    return _LegacyMultiCall(
+        hook_impls, caller_kwargs, specopts=specopts, hook=hook).execute()
 
-    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):
+
+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:
-                    gen.send(outcome)
-                    _raise_wrapfail(gen, "has second yield")
-                except StopIteration:
-                    pass
+                    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)
 
-            return outcome.get_result()
+        # run all wrapper post-yield blocks
+        for gen in reversed(teardowns):
+            try:
+                gen.send(outcome)
+                _raise_wrapfail(gen, "has second yield")
+            except StopIteration:
+                pass
 
-    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)
+        return outcome.get_result()