Importlib's documentation said that importlib.abc.PyLoader inherited from

importlib.abc.ResourceLoader, when in fact it did not. Fixed the ABC to inherit
as documented.

This doesn't introduce an backwards-incompatiblity as the code in PyLoader
already required the single method ResourceLoader defined as an abstract
method.

Lib/importlib/abc.py

@@ -76,7 +76,7 @@ InspectLoader.register(machinery.BuiltinImporter)
 InspectLoader.register(machinery.FrozenImporter)
 
 
-class PyLoader(_bootstrap.PyLoader, InspectLoader):
+class PyLoader(_bootstrap.PyLoader, ResourceLoader, InspectLoader):
 
     """Abstract base class to assist in loading source code by requiring only
     back-end storage methods to be implemented.

Lib/importlib/test/test_abc.py

@@ -1,30 +1,77 @@
 from importlib import abc
 from importlib import machinery
+import inspect
 import unittest
 
 
-class SubclassTests(unittest.TestCase):
+class InheritanceTests:
 
-    """Test that the various classes in importlib are subclasses of the
+    """Test that the specified class is a subclass/superclass of the expected
-    expected ABCS."""
+    classes."""
 
-    def verify(self, ABC, *classes):
+    subclasses = []
-        """Verify the classes are subclasses of the ABC."""
+    superclasses = []
-        for cls in classes:
-            self.assertTrue(issubclass(cls, ABC))
 
-    def test_Finder(self):
+    def __init__(self, *args, **kwargs):
-        self.verify(abc.Finder, machinery.BuiltinImporter,
+        super().__init__(*args, **kwargs)
-                    machinery.FrozenImporter, machinery.PathFinder)
+        assert self.subclasses or self.superclasses, self.__class__
+        self.__test = getattr(abc, self.__class__.__name__)
 
-    def test_Loader(self):
+    def test_subclasses(self):
-        self.verify(abc.Loader, machinery.BuiltinImporter,
+        # Test that the expected subclasses inherit.
-                    machinery.FrozenImporter)
+        for subclass in self.subclasses:
+            self.assertTrue(issubclass(subclass, self.__test),
+                "{0} is not a subclass of {1}".format(subclass, self.__test))
+
+    def test_superclasses(self):
+        # Test that the class inherits from the expected superclasses.
+        for superclass in self.superclasses:
+            self.assertTrue(issubclass(self.__test, superclass),
+               "{0} is not a superclass of {1}".format(superclass, self.__test))
+
+
+class Finder(InheritanceTests, unittest.TestCase):
+
+    subclasses = [machinery.BuiltinImporter, machinery.FrozenImporter,
+                    machinery.PathFinder]
+
+
+class Loader(InheritanceTests, unittest.TestCase):
+
+    subclasses = [abc.PyLoader]
+
+
+class ResourceLoader(InheritanceTests, unittest.TestCase):
+
+    superclasses = [abc.Loader]
+
+
+class InspectLoader(InheritanceTests, unittest.TestCase):
+
+    superclasses = [abc.Loader]
+    subclasses = [abc.PyLoader, machinery.BuiltinImporter,
+                    machinery.FrozenImporter]
+
+
+class PyLoader(InheritanceTests, unittest.TestCase):
+
+    superclasses = [abc.Loader, abc.ResourceLoader, abc.InspectLoader]
+
+
+class PyPycLoader(InheritanceTests, unittest.TestCase):
+
+    superclasses = [abc.PyLoader]
 
 
 def test_main():
     from test.support import run_unittest
-    run_unittest(SubclassTests)
+    classes = []
+    for class_ in globals().values():
+        if (inspect.isclass(class_) and
+                issubclass(class_, unittest.TestCase) and
+                issubclass(class_, InheritanceTests)):
+            classes.append(class_)
+    run_unittest(*classes)
 
 
 if __name__ == '__main__':

Misc/NEWS

@@ -43,6 +43,10 @@ C-API
 Library
 -------
 
+- importlib.abc.PyLoader did not inherit from importlib.abc.ResourceLoader like
+  the documentation said it did even though the code in PyLoader relied on the
+  abstract method required by ResourceLoader.
+
 - Issue #6431: Make Fraction type return NotImplemented when it doesn't
   know how to handle a comparison without loss of precision.  Also add
   correct handling of infinities and nans for comparisons with float.