.travis.yml

@@ -17,31 +17,31 @@ jobs:
     - python: '3.6'
       env: TOXENV=docs
     - python: '2.7'
-      env: TOXENV=py27-pytestrelease-coverage
+      env: TOXENV=py27-coverage
     - python: '3.4'
-      env: TOXENV=py34-pytestrelease-coverage
+      env: TOXENV=py34-coverage
     - python: '3.5'
-      env: TOXENV=py35-pytestrelease-coverage
+      env: TOXENV=py35-coverage
     - python: '3.6'
-      env: TOXENV=py36-pytestrelease-coverage
+      env: TOXENV=py36-coverage
     - python: 'pypy2.7-6.0'
-      env: TOXENV=pypy-pytestrelease-coverage
+      env: TOXENV=pypy-coverage
     - python: 'pypy3.5-6.0'
-      env: TOXENV=pypy3-pytestrelease-coverage
+      env: TOXENV=pypy3-coverage
     - python: '3.7'
-      env: TOXENV=py37-pytestrelease-coverage
+      env: TOXENV=py37-coverage
     - python: '3.8-dev'
-      env: TOXENV=py38-pytestrelease-coverage
-    - python: '2.7'
-      env: TOXENV=py27-pytestmaster-coverage
-    - python: '2.7'
-      env: TOXENV=py27-pytestfeatures-coverage
+      env: TOXENV=py38-coverage
     - python: '3.6'
       env: TOXENV=py36-pytestmaster-coverage
     - python: '3.6'
       env: TOXENV=py36-pytestfeatures-coverage
     - python: '3.6'
       env: TOXENV=benchmark
+    - python: '3.7'
+      env: TOXENV=py37-pytestmaster-coverage
+    - python: '3.7'
+      env: TOXENV=py37-pytestfeatures-coverage
 
     - stage: deploy
       python: '3.6'

CHANGELOG.rst

@@ -4,6 +4,16 @@ Changelog
 
 .. towncrier release notes start
 
+pluggy 0.13.0 (2019-09-10)
+==========================
+
+Trivial/Internal Changes
+------------------------
+
+- `#222 <https://github.com/pytest-dev/pluggy/issues/222>`_: Replace ``importlib_metadata`` backport with ``importlib.metadata`` from the
+  standard library on Python 3.8+.
+
+
 pluggy 0.12.0 (2019-05-27)
 ==========================
 

appveyor.yml

@@ -3,13 +3,12 @@ environment:
   # note: please use "tox --listenvs" to populate the build matrix below
   - TOXENV: "linting"
   - TOXENV: "docs"
-  - TOXENV: "py27-pytestrelease"
-  - TOXENV: "py34-pytestrelease"
-  - TOXENV: "py35-pytestrelease"
-  - TOXENV: "py36-pytestrelease"
-  - TOXENV: "pypy-pytestrelease"
-  - TOXENV: "py27-pytestmaster"
-  - TOXENV: "py27-pytestfeatures"
+  - TOXENV: "py27"
+  - TOXENV: "py34"
+  - TOXENV: "py35"
+  - TOXENV: "py36"
+  - TOXENV: "py37"
+  - TOXENV: "pypy"
   - TOXENV: "py36-pytestmaster"
   - TOXENV: "py36-pytestfeatures"
 

docs/conf.py

@@ -1,5 +1,10 @@
 # -*- coding: utf-8 -*-
-import importlib_metadata
+import sys
+
+if sys.version_info >= (3, 8):
+    from importlib import metadata
+else:
+    import importlib_metadata as metadata
 
 
 extensions = [
@@ -24,7 +29,7 @@
 copyright = u"2016, Holger Krekel"
 author = "Holger Krekel"
 
-release = importlib_metadata.version(project)
+release = metadata.version(project)
 # The short X.Y version.
 version = u".".join(release.split(".")[:2])
 

docs/index.rst

@@ -777,7 +777,9 @@ using the :py:meth:`pluggy._HookCaller.call_historic()` method:
 
 
     # call with history; no results returned
-    pm.hook.myhook.call_historic(config=config, args=sys.argv, result_callback=callback)
+    pm.hook.myhook.call_historic(
+        kwargs={"config": config, "args": sys.argv}, result_callback=callback
+    )
 
     # ... more of our program ...
 

setup.py

@@ -37,7 +37,7 @@ def main():
         author_email="holger@merlinux.eu",
         url="https://github.com/pytest-dev/pluggy",
         python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
-        install_requires=["importlib-metadata>=0.12"],
+        install_requires=['importlib-metadata>=0.12;python_version<"3.8"'],
         extras_require={"dev": ["pre-commit", "tox"]},
         classifiers=classifiers,
         packages=["pluggy"],

src/pluggy/_tracing.py

@@ -1,19 +1,18 @@
 """
 Tracing utils
 """
-from .callers import _Result
 
 
 class TagTracer(object):
     def __init__(self):
-        self._tag2proc = {}
-        self.writer = None
+        self._tags2proc = {}
+        self._writer = None
         self.indent = 0
 
     def get(self, name):
         return TagTracerSub(self, (name,))
 
-    def format_message(self, tags, args):
+    def _format_message(self, tags, args):
         if isinstance(args[-1], dict):
             extra = args[-1]
             args = args[:-1]
@@ -27,26 +26,28 @@ def format_message(self, tags, args):
 
         for name, value in extra.items():
             lines.append("%s    %s: %s\n" % (indent, name, value))
-        return lines
 
-    def processmessage(self, tags, args):
-        if self.writer is not None and args:
-            lines = self.format_message(tags, args)
-            self.writer("".join(lines))
+        return "".join(lines)
+
+    def _processmessage(self, tags, args):
+        if self._writer is not None and args:
+            self._writer(self._format_message(tags, args))
         try:
-            self._tag2proc[tags](tags, args)
+            processor = self._tags2proc[tags]
         except KeyError:
             pass
+        else:
+            processor(tags, args)
 
     def setwriter(self, writer):
-        self.writer = writer
+        self._writer = writer
 
     def setprocessor(self, tags, processor):
         if isinstance(tags, str):
             tags = tuple(tags.split(":"))
         else:
             assert isinstance(tags, tuple)
-        self._tag2proc[tags] = processor
+        self._tags2proc[tags] = processor
 
 
 class TagTracerSub(object):
@@ -55,29 +56,7 @@ def __init__(self, root, tags):
         self.tags = tags
 
     def __call__(self, *args):
-        self.root.processmessage(self.tags, args)
-
-    def setmyprocessor(self, processor):
-        self.root.setprocessor(self.tags, processor)
+        self.root._processmessage(self.tags, args)
 
     def get(self, name):
         return self.__class__(self.root, self.tags + (name,))
-
-
-class _TracedHookExecution(object):
-    def __init__(self, pluginmanager, before, after):
-        self.pluginmanager = pluginmanager
-        self.before = before
-        self.after = after
-        self.oldcall = pluginmanager._inner_hookexec
-        assert not isinstance(self.oldcall, _TracedHookExecution)
-        self.pluginmanager._inner_hookexec = self
-
-    def __call__(self, hook, hook_impls, kwargs):
-        self.before(hook.name, 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()
-
-    def undo(self):
-        self.pluginmanager._inner_hookexec = self.oldcall

src/pluggy/hooks.py

@@ -84,7 +84,7 @@ def __call__(
         in an error (by default it is an error if no matching spec is found).
 
         If tryfirst is True this hook implementation will run as early as possible
-        in the chain of N hook implementations for a specfication.
+        in the chain of N hook implementations for a specification.
 
         If trylast is True this hook implementation will run as late as possible
         in the chain of N hook implementations.
@@ -161,7 +161,7 @@ def varnames(func):
         try:
             func = getattr(func, "__call__", func)
         except Exception:
-            return ()
+            return (), ()
 
     try:  # func MUST be a function or method here or we won't parse any args
         spec = _getargspec(func)
@@ -171,9 +171,9 @@ def varnames(func):
     args, defaults = tuple(spec.args), spec.defaults
     if defaults:
         index = -len(defaults)
-        args, defaults = args[:index], tuple(args[index:])
+        args, kwargs = args[:index], tuple(args[index:])
     else:
-        defaults = ()
+        kwargs = ()
 
     # strip any implicit instance arg
     # pypy3 uses "obj" instead of "self" for default dunder methods
@@ -185,10 +185,10 @@ def varnames(func):
             args = args[1:]
 
     try:
-        cache["_varnames"] = args, defaults
+        cache["_varnames"] = args, kwargs
     except TypeError:
         pass
-    return args, defaults
+    return args, kwargs
 
 
 class _HookRelay(object):
@@ -197,9 +197,6 @@ class _HookRelay(object):
 
     """
 
-    def __init__(self, trace):
-        self._trace = trace
-
 
 class _HookCaller(object):
     def __init__(self, name, hook_execute, specmodule_or_class=None, spec_opts=None):

src/pluggy/manager.py

@@ -1,9 +1,14 @@
 import inspect
+import sys
 from . import _tracing
+from .callers import _Result
 from .hooks import HookImpl, _HookRelay, _HookCaller, normalize_hookimpl_opts
 import warnings
 
-import importlib_metadata
+if sys.version_info >= (3, 8):
+    from importlib import metadata as importlib_metadata
+else:
+    import importlib_metadata
 
 
 def _warn_for_function(warning, function):
@@ -66,7 +71,7 @@ def __init__(self, project_name, implprefix=None):
         self._plugin2hookcallers = {}
         self._plugin_distinfo = []
         self.trace = _tracing.TagTracer().get("pluginmanage")
-        self.hook = _HookRelay(self.trace.root.get("hook"))
+        self.hook = _HookRelay()
         if implprefix is not None:
             warnings.warn(
                 "Support for the `implprefix` arg is now deprecated and will "
@@ -321,11 +326,24 @@ def add_hookcall_monitoring(self, before, after):
         same arguments as ``before`` but also a :py:class:`_Result`` object
         which represents the result of the overall hook call.
         """
-        return _tracing._TracedHookExecution(self, before, after).undo
+        oldcall = self._inner_hookexec
+
+        def traced_hookexec(hook, hook_impls, kwargs):
+            before(hook.name, hook_impls, kwargs)
+            outcome = _Result.from_call(lambda: oldcall(hook, hook_impls, kwargs))
+            after(outcome, hook.name, hook_impls, kwargs)
+            return outcome.get_result()
+
+        self._inner_hookexec = traced_hookexec
+
+        def undo():
+            self._inner_hookexec = oldcall
+
+        return undo
 
     def enable_tracing(self):
         """ enable tracing of hook calls and return an undo function. """
-        hooktrace = self.hook._trace
+        hooktrace = self.trace.root.get("hook")
 
         def before(hook_name, methods, kwargs):
             hooktrace.root.indent += 1

testing/test_multicall.py

@@ -1,22 +1,13 @@
 import pytest
 from pluggy import HookCallError, HookspecMarker, HookimplMarker
 from pluggy.hooks import HookImpl
-from pluggy.callers import _multicall, _legacymulticall, _LegacyMultiCall
+from pluggy.callers import _multicall, _legacymulticall
 
 
 hookspec = HookspecMarker("example")
 hookimpl = HookimplMarker("example")
 
 
-def test_uses_copy_of_methods():
-    out = [lambda: 42]
-    mc = _LegacyMultiCall(out, {})
-    repr(mc)
-    out[:] = []
-    res = mc.execute()
-    return res == 42
-
-
 def MC(methods, kwargs, firstresult=False):
     caller = _multicall
     hookfuncs = []

testing/test_pluginmanager.py

@@ -3,14 +3,15 @@
 """
 import pytest
 import types
-import importlib_metadata
+
 from pluggy import (
     PluginManager,
     PluginValidationError,
     HookCallError,
     HookimplMarker,
     HookspecMarker,
 )
+from pluggy.manager import importlib_metadata
 
 
 hookspec = HookspecMarker("example")

testing/test_tracer.py

@@ -51,11 +51,11 @@ def test_indent(rootlogger):
 
 def test_readable_output_dictargs(rootlogger):
 
-    out = rootlogger.format_message(["test"], [1])
-    assert out == ["1 [test]\n"]
+    out = rootlogger._format_message(["test"], [1])
+    assert out == "1 [test]\n"
 
-    out2 = rootlogger.format_message(["test"], ["test", {"a": 1}])
-    assert out2 == ["test [test]\n", "    a: 1\n"]
+    out2 = rootlogger._format_message(["test"], ["test", {"a": 1}])
+    assert out2 == "test [test]\n    a: 1\n"
 
 
 def test_setprocessor(rootlogger):
@@ -76,18 +76,3 @@ def test_setprocessor(rootlogger):
     log2("seen")
     tags, args = l2[0]
     assert args == ("seen",)
-
-
-def test_setmyprocessor(rootlogger):
-    log = rootlogger.get("1")
-    log2 = log.get("2")
-    out = []
-    log2.setmyprocessor(lambda *args: out.append(args))
-    log("not seen")
-    assert not out
-    log2(42)
-    assert len(out) == 1
-    tags, args = out[0]
-    assert "1" in tags
-    assert "2" in tags
-    assert args == (42,)