Deprecate __multicall__

pluggy.py → pluggy/__init__.py

@@ -1,23 +1,17 @@
-import sys
 import inspect
 import warnings
+from .callers import _MultiCall, HookCallError, _raise_wrapfail, _Result
 
 __version__ = '0.5.0'
 
 __all__ = ["PluginManager", "PluginValidationError", "HookCallError",
  "HookspecMarker", "HookimplMarker"]
 
-_py3 = sys.version_info > (3, 0)
-
 
 class PluginValidationError(Exception):
  """ plugin failed validation. """
 
 
-class HookCallError(Exception):
- """ Hook was called wrongly. """
-
-
 class HookspecMarker(object):
  """ Decorator helper class for marking functions as hook specifications.
 
@@ -86,7 +80,7 @@ def __call__(self, function=None, hookwrapper=False, optionalhook=False,
  If hookwrapper is True the hook implementations needs to execute exactly
  one "yield". The code before the yield is run early before any non-hookwrapper
  function is run. The code after the yield is run after all non-hookwrapper
- function have run. The yield receives an ``_CallOutcome`` object representing
+ function have run. The yield receives a ``_Result`` object representing
  the exception or result outcome of the inner calls (including other hookwrapper
  calls).
 
@@ -172,23 +166,17 @@ def get(self, name):
  return self.__class__(self.root, self.tags + (name,))
 
 
-def _raise_wrapfail(wrap_controller, msg):
- co = wrap_controller.gi_code
- raise RuntimeError("wrap_controller at %r %s:%d %s" %
- (co.co_name, co.co_filename, co.co_firstlineno, msg))
-
-
 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 _CallOutcome to the yield point. The generator then needs
+ 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 = _CallOutcome(func)
+ call_outcome = _Result.from_call(func)
  try:
  wrap_controller.send(call_outcome)
  _raise_wrapfail(wrap_controller, "has second yield")
@@ -197,39 +185,6 @@ def _wrapped_call(wrap_controller, func):
  return call_outcome.get_result()
 
 
-class _CallOutcome(object):
- """ Outcome of a function call, either an exception or a proper result.
- Calling the ``get_result`` method will return the result or reraise
- the exception raised when the function was called. """
- excinfo = None
-
- def __init__(self, func):
- try:
- self.result = func()
- except BaseException:
- self.excinfo = sys.exc_info()
-
- def force_result(self, result):
- self.result = result
- self.excinfo = None
-
- def get_result(self):
- if self.excinfo is None:
- return self.result
- else:
- ex = self.excinfo
- if _py3:
- raise ex[1].with_traceback(ex[2])
- _reraise(*ex) # noqa
-
-
-if not _py3:
- exec("""
-def _reraise(cls, val, tb):
- raise cls, val, tb
-""")
-
-
 class _TracedHookExecution(object):
  def __init__(self, pluginmanager, before, after):
  self.pluginmanager = pluginmanager
@@ -241,7 +196,7 @@ def __init__(self, pluginmanager, before, after):
 
  def __call__(self, hook, hook_impls, kwargs):
  self.before(hook.name, hook_impls, kwargs)
- outcome = _CallOutcome(lambda: self.oldcall(hook, hook_impls, kwargs))
+ outcome = _Result.from_call(lambda: self.oldcall(hook, hook_impls, kwargs))
  self.after(outcome, hook.name, hook_impls, kwargs)
  return outcome.get_result()
 
@@ -275,7 +230,7 @@ def __init__(self, project_name, implprefix=None):
  self.hook = _HookRelay(self.trace.root.get("hook"))
  self._implprefix = implprefix
  self._inner_hookexec = lambda hook, methods, kwargs: \
- _MultiCall(
+ hook.multicall(
  methods, kwargs, specopts=hook.spec_opts, hook=hook
  ).execute()
 
@@ -490,7 +445,7 @@ def add_hookcall_monitoring(self, before, after):
  of HookImpl instances and the keyword arguments for the hook call.
 
  ``after(outcome, hook_name, hook_impls, kwargs)`` receives the
- same arguments as ``before`` but also a :py:class:`_CallOutcome`` object
+ same arguments as ``before`` but also a :py:class:`_Result`` object
  which represents the result of the overall hook call.
  """
  return _TracedHookExecution(self, before, after).undo
@@ -530,7 +485,7 @@ def subset_hook_caller(self, name, remove_plugins):
  return orig
 
 
-class _MultiCall(object):
+class _LegacyMultiCall(object):
  """ execute a call into multiple python functions/methods. """
 
  # XXX note that the __multicall__ argument is supported only
@@ -647,6 +602,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
  if specmodule_or_class is not None:
  assert spec_opts is not None
  self.set_specification(specmodule_or_class, spec_opts)
@@ -697,6 +653,14 @@ def _add_hookimpl(self, hookimpl):
  i -= 1
  methods.insert(i + 1, hookimpl)
 
+ if '__multicall__' in hookimpl.argnames:
+ warnings.warn(
+ "Support for __multicall__ is now deprecated and will be"
+ "removed in an upcoming release.",
+ warnings.DeprecationWarning
+ )
+ self.multicall = _LegacyMultiCall
+
  def __repr__(self):
  return "<_HookCaller %r>" % (self.name,)
 

pluggy/callers.py

@@ -0,0 +1,118 @@
+'''
+Call loop machinery
+'''
+import sys
+
+
+_py3 = sys.version_info > (3, 0)
+
+
+if not _py3:
+ exec("""
+def _reraise(cls, val, tb):
+ raise cls, val, tb
+""")
+
+
+def _raise_wrapfail(wrap_controller, msg):
+ co = wrap_controller.gi_code
+ raise RuntimeError("wrap_controller at %r %s:%d %s" %
+ (co.co_name, co.co_filename, co.co_firstlineno, msg))
+
+
+class HookCallError(Exception):
+ """ Hook was called wrongly. """
+
+
+class _Result(object):
+ def __init__(self, result, excinfo):
+ self.result = result
+ self.excinfo = excinfo
+
+ @classmethod
+ def from_call(cls, func):
+ result = excinfo = None
+ try:
+ result = func()
+ except BaseException:
+ excinfo = sys.exc_info()
+
+ return cls(result, excinfo)
+
+ def force_result(self, result):
+ self.result = result
+ self.excinfo = None
+
+ def get_result(self):
+ if self.excinfo is None:
+ return self.result
+ else:
+ ex = self.excinfo
+ if _py3:
+ raise ex[1].with_traceback(ex[2])
+ _reraise(*ex) # noqa
+
+
+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 execute(self):
+ 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:
+ 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
+
+ if firstresult:
+ return outcome.get_result()[0]
+
+ return outcome.get_result()
+
+ 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)

setup.py

@@ -20,7 +20,7 @@
 
 def get_version():
  p = os.path.join(os.path.dirname(
- os.path.abspath(__file__)), "pluggy.py")
+ os.path.abspath(__file__)), "pluggy/__init__.py")
  with open(p) as f:
  for line in f.readlines():
  if "__version__" in line:
@@ -40,7 +40,7 @@ def main():
  author_email='holger at merlinux.eu',
  url='https://github.com/pytest-dev/pluggy',
  classifiers=classifiers,
- py_modules=['pluggy'],
+ packages=['pluggy'],
  )
 
 

testing/benchmark.py

@@ -2,18 +2,19 @@
 Benchmarking and performance tests.
 """
 import pytest
-from pluggy import _MultiCall, HookImpl, HookspecMarker, HookimplMarker
+from pluggy import (_MultiCall, _LegacyMultiCall, HookImpl, HookspecMarker,
+ HookimplMarker)
 
 hookspec = HookspecMarker("example")
 hookimpl = HookimplMarker("example")
 
 
-def MC(methods, kwargs, firstresult=False):
+def MC(methods, kwargs, callertype, firstresult=False):
  hookfuncs = []
  for method in methods:
  f = HookImpl(None, "<temp>", method, method.example_impl)
  hookfuncs.append(f)
- return _MultiCall(hookfuncs, kwargs, {"firstresult": firstresult})
+ return callertype(hookfuncs, kwargs, {"firstresult": firstresult})
 
 
 @hookimpl
@@ -42,9 +43,17 @@ def wrappers(request):
  return [wrapper for i in range(request.param)]
 
 
-def inner_exec(methods):
- return MC(methods, {'arg1': 1, 'arg2': 2, 'arg3': 3}).execute()
+@pytest.fixture(
+ 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()
 
 
-def test_hook_and_wrappers_speed(benchmark, hooks, wrappers):
- benchmark(inner_exec, hooks + wrappers)
+def test_hook_and_wrappers_speed(benchmark, hooks, wrappers, callertype):
+ benchmark(inner_exec, hooks + wrappers, callertype)

testing/test_multicall.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pluggy import _MultiCall, HookImpl, HookCallError
+from pluggy import _MultiCall, HookImpl, HookCallError, _LegacyMultiCall
 from pluggy import HookspecMarker, HookimplMarker
 
 
@@ -18,11 +18,14 @@ def test_uses_copy_of_methods():
 
 
 def MC(methods, kwargs, firstresult=False):
+ caller = _MultiCall
  hookfuncs = []
  for method in methods:
  f = HookImpl(None, "<temp>", method, method.example_impl)
  hookfuncs.append(f)
- return _MultiCall(hookfuncs, kwargs, {"firstresult": firstresult})
+ if '__multicall__' in f.argnames:
+ caller = _LegacyMultiCall
+ return caller(hookfuncs, kwargs, {"firstresult": firstresult})
 
 
 def test_call_passing():