Issue 19713: Add PEP 451-related deprecations.

Lib/importlib/__init__.py

@@ -12,6 +12,7 @@ __all__ = ['__import__', 'import_module', 'invalidate_caches', 'reload']
 import _imp  # Just the builtin component, NOT the full Python module
 import sys
 import types
+import warnings
 
 try:
     import _frozen_importlib as _bootstrap
@@ -77,13 +78,16 @@ def find_spec(name, path=None):
             return spec
 
 
-# XXX Deprecate...
 def find_loader(name, path=None):
     """Return the loader for the specified module.
 
     This is a backward-compatible wrapper around find_spec().
 
+    This function is deprecated in favor of importlib.find_spec().
+
     """
+    warnings.warn('Use importlib.find_spec() instead.', DeprecationWarning,
+                  stacklevel=2)
     try:
         loader = sys.modules[name].__loader__
         if loader is None:

Lib/importlib/_bootstrap.py

@@ -564,7 +564,11 @@ def _requires_frozen(fxn):
 
 def _find_module_shim(self, fullname):
     """Try to find a loader for the specified module by delegating to
-    self.find_loader()."""
+    self.find_loader().
+
+    This method is deprecated in favor of finder.find_spec().
+
+    """
     # Call find_loader(). If it returns a string (indicating this
     # is a namespace package portion), generate a warning and
     # return None.
@@ -576,8 +580,11 @@ def _find_module_shim(self, fullname):
 
 
 def _load_module_shim(self, fullname):
-    """Load the specified module into sys.modules and return it."""
-    # XXX Deprecation Warning here...
+    """Load the specified module into sys.modules and return it.
+
+    This method is deprecated.  Use loader.exec_module instead.
+
+    """
     spec = spec_from_loader(fullname, self)
     methods = _SpecMethods(spec)
     if fullname in sys.modules:
@@ -683,7 +690,9 @@ def _module_repr(module):
     # The implementation of ModuleType__repr__().
     loader = getattr(module, '__loader__', None)
     if hasattr(loader, 'module_repr'):
-        # XXX Deprecation Warning here...
+        # As soon as BuiltinImporter, FrozenImporter, and NamespaceLoader
+        # drop their implementations for module_repr. we can add a
+        # deprecation warning here.
         try:
             return loader.module_repr(module)
         except Exception:
@@ -1149,17 +1158,27 @@ class _SpecMethods:
                 return module
             self.init_module_attrs(module, _override=True)
             if not hasattr(self.spec.loader, 'exec_module'):
-                # XXX DeprecationWarning goes here...
+                # (issue19713) Once BuiltinImporter and ExtensionFileLoader
+                # have exec_module() implemented, we can add a deprecation
+                # warning here.
                 self.spec.loader.load_module(name)
             else:
                 self._exec(module)
         return sys.modules[name]
 
     def _load_backward_compatible(self):
-        # XXX DeprecationWarning goes here...
+        # (issue19713) Once BuiltinImporter and ExtensionFileLoader
+        # have exec_module() implemented, we can add a deprecation
+        # warning here.
         spec = self.spec
         # The module must be in sys.modules!
-        spec.loader.load_module(spec.name)
+        try:
+            _warnings
+        except NameError:
+            # We must be importing builtins in setup().
+            spec.loader.load_module(spec.name)
+        else:
+            spec.loader.load_module(spec.name)
         module = sys.modules[spec.name]
         if getattr(module, '__loader__', None) is None:
             try:
@@ -1233,7 +1252,11 @@ class BuiltinImporter:
 
     @staticmethod
     def module_repr(module):
-        # XXX deprecate
+        """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
         return '<module {!r} (built-in)>'.format(module.__name__)
 
     @classmethod
@@ -1251,6 +1274,8 @@ class BuiltinImporter:
 
         If 'path' is ever specified then the search is considered a failure.
 
+        This method is deprecated.  Use find_spec() instead.
+
         """
         spec = cls.find_spec(fullname, path)
         return spec.loader if spec is not None else None
@@ -1259,6 +1284,8 @@ class BuiltinImporter:
     @_requires_builtin
     def load_module(cls, fullname):
         """Load a built-in module."""
+        # Once an exec_module() implementation is added we can also
+        # add a deprecation warning here.
         with _ManageReload(fullname):
             module = _call_with_frames_removed(_imp.init_builtin, fullname)
         module.__loader__ = cls
@@ -1281,7 +1308,6 @@ class BuiltinImporter:
     @_requires_builtin
     def is_package(cls, fullname):
         """Return False as built-in modules are never packages."""
-        # XXX DeprecationWarning here...
         return False
 
 
@@ -1296,7 +1322,11 @@ class FrozenImporter:
 
     @staticmethod
     def module_repr(m):
-        # XXX deprecate
+        """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
         return '<module {!r} (frozen)>'.format(m.__name__)
 
     @classmethod
@@ -1308,7 +1338,11 @@ class FrozenImporter:
 
     @classmethod
     def find_module(cls, fullname, path=None):
-        """Find a frozen module."""
+        """Find a frozen module.
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
         return cls if _imp.is_frozen(fullname) else None
 
     @staticmethod
@@ -1322,7 +1356,11 @@ class FrozenImporter:
 
     @classmethod
     def load_module(cls, fullname):
-        """Load a frozen module."""
+        """Load a frozen module.
+
+        This method is deprecated.  Use exec_module() instead.
+
+        """
         return _load_module_shim(cls, fullname)
 
     @classmethod
@@ -1395,7 +1433,11 @@ class WindowsRegistryFinder:
 
     @classmethod
     def find_module(cls, fullname, path=None):
-        """Find module named in the registry."""
+        """Find module named in the registry.
+
+        This method is deprecated.  Use exec_module() instead.
+
+        """
         spec = cls.find_spec(fullname, path)
         if spec is not None:
             return spec.loader
@@ -1408,7 +1450,6 @@ class _LoaderBasics:
     """Base class of common code needed by both SourceLoader and
     SourcelessFileLoader."""
 
-    # XXX deprecate?
     def is_package(self, fullname):
         """Concrete implementation of InspectLoader.is_package by checking if
         the path returned by get_filename has a filename of '__init__.py'."""
@@ -1558,9 +1599,12 @@ class FileLoader:
 
     @_check_name
     def load_module(self, fullname):
-        """Load a module from a file."""
-        # The only reason for this method is for the name check.
+        """Load a module from a file.
 
+        This method is deprecated.  Use exec_module() instead.
+
+        """
+        # The only reason for this method is for the name check.
         # Issue #14857: Avoid the zero-argument form of super so the implementation
         # of that form can be updated without breaking the frozen module
         return super(FileLoader, self).load_module(fullname)
@@ -1660,6 +1704,8 @@ class ExtensionFileLoader:
     @_check_name
     def load_module(self, fullname):
         """Load an extension module."""
+        # Once an exec_module() implementation is added we can also
+        # add a deprecation warning here.
         with _ManageReload(fullname):
             module = _call_with_frames_removed(_imp.load_dynamic,
                                                fullname, self.path)
@@ -1754,9 +1800,13 @@ class _NamespaceLoader:
     def __init__(self, name, path, path_finder):
         self._path = _NamespacePath(name, path, path_finder)
 
-    # XXX Deprecate
     @classmethod
     def module_repr(cls, module):
+        """Return repr for the module.
+
+        The method is deprecated.  The import machinery does the job itself.
+
+        """
         return '<module {!r} (namespace)>'.format(module.__name__)
 
     def is_package(self, fullname):
@@ -1768,9 +1818,16 @@ class _NamespaceLoader:
     def get_code(self, fullname):
         return compile('', '<string>', 'exec', dont_inherit=True)
 
-    # XXX Deprecate
+    def exec_module(self, module):
+        pass
+
     def load_module(self, fullname):
-        """Load a namespace module."""
+        """Load a namespace module.
+
+        This method is deprecated.  Use exec_module() instead.
+
+        """
+        # The import system never calls this method.
         _verbose_message('namespace module loaded with path {!r}', self._path)
         return _load_module_shim(self, fullname)
 
@@ -1825,6 +1882,8 @@ class PathFinder:
 
     @classmethod
     def _legacy_get_spec(cls, fullname, finder):
+        # This would be a good place for a DeprecationWarning if
+        # we ended up going that route.
         if hasattr(finder, 'find_loader'):
             loader, portions = finder.find_loader(fullname)
         else:
@@ -1893,8 +1952,11 @@ class PathFinder:
     @classmethod
     def find_module(cls, fullname, path=None):
         """find the module on sys.path or 'path' based on sys.path_hooks and
-        sys.path_importer_cache."""
-        # XXX Deprecation warning here.
+        sys.path_importer_cache.
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
         spec = cls.find_spec(fullname, path)
         if spec is None:
             return None
@@ -1932,7 +1994,11 @@ class FileFinder:
 
     def find_loader(self, fullname):
         """Try to find a loader for the specified module, or the namespace
-        package portions. Returns (loader, list-of-portions)."""
+        package portions. Returns (loader, list-of-portions).
+
+        This method is deprecated.  Use find_spec() instead.
+
+        """
         spec = self.find_spec(fullname)
         if spec is None:
             return None, []
@@ -2065,6 +2131,15 @@ def _resolve_name(name, package, level):
     return '{}.{}'.format(base, name) if name else base
 
 
+def _find_spec_legacy(finder, name, path):
+    # This would be a good place for a DeprecationWarning if
+    # we ended up going that route.
+    loader = finder.find_module(name, path)
+    if loader is None:
+        return None
+    return spec_from_loader(name, loader)
+
+
 def _find_spec(name, path, target=None):
     """Find a module's loader."""
     if not sys.meta_path:
@@ -2078,10 +2153,9 @@ def _find_spec(name, path, target=None):
             try:
                 find_spec = finder.find_spec
             except AttributeError:
-                loader = finder.find_module(name, path)
-                if loader is None:
+                spec = _find_spec_legacy(finder, name, path)
+                if spec is None:
                     continue
-                spec = spec_from_loader(name, loader)
             else:
                 spec = find_spec(name, path, target)
         if spec is not None:

Lib/importlib/abc.py

@@ -43,13 +43,14 @@ class MetaPathFinder(Finder):
     # We don't define find_spec() here since that would break
     # hasattr checks we do to support backward compatibility.
 
-    # XXX Deprecate
     def find_module(self, fullname, path):
         """Return a loader for the module.
 
         If no module is found, return None.  The fullname is a str and
         the path is a list of strings or None.
 
+        This method is deprecated in favor of finder.find_spec().
+
         """
         return None
 
@@ -69,7 +70,6 @@ class PathEntryFinder(Finder):
     # We don't define find_spec() here since that would break
     # hasattr checks we do to support backward compatibility.
 
-    # XXX Deprecate.
     def find_loader(self, fullname):
         """Return (loader, namespace portion) for the path entry.
 
@@ -81,10 +81,11 @@ class PathEntryFinder(Finder):
         The portion will be discarded if another path entry finder
         locates the module as a normal module or package.
 
+        This method is deprecated in favor of finder.find_spec().
+
         """
         return None, []
 
-    # XXX Deprecate.
     find_module = _bootstrap._find_module_shim
 
     def invalidate_caches(self):
@@ -115,7 +116,6 @@ class Loader(metaclass=abc.ABCMeta):
     # We don't define exec_module() here since that would break
     # hasattr checks we do to support backward compatibility.
 
-    # XXX Deprecate.
     def load_module(self, fullname):
         """Return the loaded module.
 
@@ -124,16 +124,19 @@ class Loader(metaclass=abc.ABCMeta):
 
         ImportError is raised on failure.
 
+        This method is deprecated in favor of loader.exec_module().
+
         """
         raise ImportError
 
-    # XXX Deprecate.
     def module_repr(self, module):
         """Return a module's repr.
 
         Used by the module type when the method does not raise
         NotImplementedError.
 
+        This method is deprecated.
+
         """
         # The exception will cause ModuleType.__repr__ to ignore this method.
         raise NotImplementedError

Lib/importlib/util.py

@@ -55,11 +55,16 @@ def _module_to_load(name):
         module.__initializing__ = False
 
 
-# XXX deprecate
 def set_package(fxn):
-    """Set __package__ on the returned module."""
+    """Set __package__ on the returned module.
+
+    This function is deprecated.
+
+    """
     @functools.wraps(fxn)
     def set_package_wrapper(*args, **kwargs):
+        warnings.warn('The import system now takes care of this automatically.',
+                      DeprecationWarning, stacklevel=2)
         module = fxn(*args, **kwargs)
         if getattr(module, '__package__', None) is None:
             module.__package__ = module.__name__
@@ -69,11 +74,16 @@ def set_package(fxn):
     return set_package_wrapper
 
 
-# XXX deprecate
 def set_loader(fxn):
-    """Set __loader__ on the returned module."""
+    """Set __loader__ on the returned module.
+
+    This function is deprecated.
+
+    """
     @functools.wraps(fxn)
     def set_loader_wrapper(self, *args, **kwargs):
+        warnings.warn('The import system now takes care of this automatically.',
+                      DeprecationWarning, stacklevel=2)
         module = fxn(self, *args, **kwargs)
         if getattr(module, '__loader__', None) is None:
             module.__loader__ = self
@@ -100,7 +110,7 @@ def module_for_loader(fxn):
 
     """
     warnings.warn('The import system now takes care of this automatically.',
-                  PendingDeprecationWarning, stacklevel=2)
+                  DeprecationWarning, stacklevel=2)
     @functools.wraps(fxn)
     def module_for_loader_wrapper(self, fullname, *args, **kwargs):
         with _module_to_load(fullname) as module:

Lib/test/test_importlib/extension/test_finder.py

@@ -5,6 +5,7 @@ from . import util
 machinery = test_util.import_importlib('importlib.machinery')
 
 import unittest
+import warnings
 
 # XXX find_spec tests
 
@@ -16,7 +17,9 @@ class FinderTests(abc.FinderTests):
         importer = self.machinery.FileFinder(util.PATH,
                                             (self.machinery.ExtensionFileLoader,
                                              self.machinery.EXTENSION_SUFFIXES))
-        return importer.find_module(fullname)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            return importer.find_module(fullname)
 
     def test_module(self):
         self.assertTrue(self.find_module(util.NAME))

Lib/test/test_importlib/frozen/test_loader.py

@@ -8,6 +8,7 @@ import sys
 from test.support import captured_stdout
 import types
 import unittest
+import warnings
 
 
 class ExecModuleTests(abc.LoaderTests):
@@ -60,8 +61,16 @@ class ExecModuleTests(abc.LoaderTests):
                                  expected=value))
             self.assertEqual(output, 'Hello world!\n')
 
-
     def test_module_repr(self):
+        name = '__hello__'
+        module, output = self.exec_module(name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            repr_str = self.machinery.FrozenImporter.module_repr(module)
+        self.assertEqual(repr_str,
+                         "<module '__hello__' (frozen)>")
+
+    def test_module_repr_indirect(self):
         name = '__hello__'
         module, output = self.exec_module(name)
         self.assertEqual(repr(module),
@@ -84,7 +93,9 @@ class LoaderTests(abc.LoaderTests):
 
     def test_module(self):
         with util.uncache('__hello__'), captured_stdout() as stdout:
-            module = self.machinery.FrozenImporter.load_module('__hello__')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__hello__')
             check = {'__name__': '__hello__',
                     '__package__': '',
                     '__loader__': self.machinery.FrozenImporter,
@@ -96,7 +107,9 @@ class LoaderTests(abc.LoaderTests):
 
     def test_package(self):
         with util.uncache('__phello__'),  captured_stdout() as stdout:
-            module = self.machinery.FrozenImporter.load_module('__phello__')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__phello__')
             check = {'__name__': '__phello__',
                      '__package__': '__phello__',
                      '__path__': [],
@@ -113,7 +126,9 @@ class LoaderTests(abc.LoaderTests):
     def test_lacking_parent(self):
         with util.uncache('__phello__', '__phello__.spam'), \
              captured_stdout() as stdout:
-            module = self.machinery.FrozenImporter.load_module('__phello__.spam')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__phello__.spam')
             check = {'__name__': '__phello__.spam',
                     '__package__': '__phello__',
                     '__loader__': self.machinery.FrozenImporter,
@@ -128,18 +143,29 @@ class LoaderTests(abc.LoaderTests):
 
     def test_module_reuse(self):
         with util.uncache('__hello__'), captured_stdout() as stdout:
-            module1 = self.machinery.FrozenImporter.load_module('__hello__')
-            module2 = self.machinery.FrozenImporter.load_module('__hello__')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module1 = self.machinery.FrozenImporter.load_module('__hello__')
+                module2 = self.machinery.FrozenImporter.load_module('__hello__')
             self.assertIs(module1, module2)
             self.assertEqual(stdout.getvalue(),
                              'Hello world!\nHello world!\n')
 
     def test_module_repr(self):
         with util.uncache('__hello__'), captured_stdout():
-            module = self.machinery.FrozenImporter.load_module('__hello__')
-            self.assertEqual(repr(module),
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__hello__')
+                repr_str = self.machinery.FrozenImporter.module_repr(module)
+            self.assertEqual(repr_str,
                              "<module '__hello__' (frozen)>")
 
+    def test_module_repr_indirect(self):
+        with util.uncache('__hello__'), captured_stdout():
+            module = self.machinery.FrozenImporter.load_module('__hello__')
+        self.assertEqual(repr(module),
+                         "<module '__hello__' (frozen)>")
+
     # No way to trigger an error in a frozen module.
     test_state_after_failure = None
 

Lib/test/test_importlib/source/test_file_loader.py

@@ -16,6 +16,7 @@ import stat
 import sys
 import types
 import unittest
+import warnings
 
 from test.support import make_legacy_pyc, unload
 
@@ -39,7 +40,9 @@ class SimpleTest(abc.LoaderTests):
 
         loader = Tester('blah', 'blah.py')
         self.addCleanup(unload, 'blah')
-        module = loader.load_module()  # Should not raise an exception.
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            module = loader.load_module()  # Should not raise an exception.
 
     def test_get_filename_API(self):
         # If fullname is not set then assume self.path is desired.
@@ -70,7 +73,9 @@ class SimpleTest(abc.LoaderTests):
     def test_module(self):
         with source_util.create_modules('_temp') as mapping:
             loader = self.machinery.SourceFileLoader('_temp', mapping['_temp'])
-            module = loader.load_module('_temp')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_temp')
             self.assertIn('_temp', sys.modules)
             check = {'__name__': '_temp', '__file__': mapping['_temp'],
                      '__package__': ''}
@@ -81,7 +86,9 @@ class SimpleTest(abc.LoaderTests):
         with source_util.create_modules('_pkg.__init__') as mapping:
             loader = self.machinery.SourceFileLoader('_pkg',
                                                  mapping['_pkg.__init__'])
-            module = loader.load_module('_pkg')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_pkg')
             self.assertIn('_pkg', sys.modules)
             check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'],
                      '__path__': [os.path.dirname(mapping['_pkg.__init__'])],
@@ -94,7 +101,9 @@ class SimpleTest(abc.LoaderTests):
         with source_util.create_modules('_pkg.__init__', '_pkg.mod')as mapping:
             loader = self.machinery.SourceFileLoader('_pkg.mod',
                                                     mapping['_pkg.mod'])
-            module = loader.load_module('_pkg.mod')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_pkg.mod')
             self.assertIn('_pkg.mod', sys.modules)
             check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'],
                      '__package__': '_pkg'}
@@ -108,12 +117,16 @@ class SimpleTest(abc.LoaderTests):
     def test_module_reuse(self):
         with source_util.create_modules('_temp') as mapping:
             loader = self.machinery.SourceFileLoader('_temp', mapping['_temp'])
-            module = loader.load_module('_temp')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_temp')
             module_id = id(module)
             module_dict_id = id(module.__dict__)
             with open(mapping['_temp'], 'w') as file:
                 file.write("testing_var = 42\n")
-            module = loader.load_module('_temp')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_temp')
             self.assertIn('testing_var', module.__dict__,
                          "'testing_var' not in "
                             "{0}".format(list(module.__dict__.keys())))
@@ -138,7 +151,9 @@ class SimpleTest(abc.LoaderTests):
             for attr in attributes:
                 self.assertEqual(getattr(orig_module, attr), value)
             with self.assertRaises(SyntaxError):
-                loader.load_module(name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    loader.load_module(name)
             for attr in attributes:
                 self.assertEqual(getattr(orig_module, attr), value)
 
@@ -149,7 +164,9 @@ class SimpleTest(abc.LoaderTests):
                 file.write('=')
             loader = self.machinery.SourceFileLoader('_temp', mapping['_temp'])
             with self.assertRaises(SyntaxError):
-                loader.load_module('_temp')
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    loader.load_module('_temp')
             self.assertNotIn('_temp', sys.modules)
 
     def test_file_from_empty_string_dir(self):
@@ -161,7 +178,9 @@ class SimpleTest(abc.LoaderTests):
         try:
             with util.uncache('_temp'):
                 loader = self.machinery.SourceFileLoader('_temp', file_path)
-                mod = loader.load_module('_temp')
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    mod = loader.load_module('_temp')
                 self.assertEqual(file_path, mod.__file__)
                 self.assertEqual(self.util.cache_from_source(file_path),
                                  mod.__cached__)
@@ -196,7 +215,9 @@ class SimpleTest(abc.LoaderTests):
             self.assertTrue(os.path.exists(compiled))
             os.unlink(compiled)
             # PEP 302
-            mod = loader.load_module('_temp') # XXX
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                mod = loader.load_module('_temp') # XXX
             # Sanity checks.
             self.assertEqual(mod.__cached__, compiled)
             self.assertEqual(mod.x, 5)
@@ -210,7 +231,9 @@ class SimpleTest(abc.LoaderTests):
         with self.assertRaises(ImportError):
             loader.exec_module(module)
         with self.assertRaises(ImportError):
-            loader.load_module('bad name')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                loader.load_module('bad name')
 
 Frozen_SimpleTest, Source_SimpleTest = util.test_both(
         SimpleTest, importlib=importlib, machinery=machinery, abc=importlib_abc,
@@ -221,7 +244,10 @@ class BadBytecodeTest:
 
     def import_(self, file, module_name):
         loader = self.loader(module_name, file)
-        module = loader.load_module(module_name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            # XXX Change to use exec_module().
+            module = loader.load_module(module_name)
         self.assertIn(module_name, sys.modules)
 
     def manipulate_bytecode(self, name, mapping, manipulator, *,
@@ -332,7 +358,9 @@ class BadBytecodeTestPEP302(BadBytecodeTest):
 
     def import_(self, file, module_name):
         loader = self.loader(module_name, file)
-        module = loader.load_module(module_name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            module = loader.load_module(module_name)
         self.assertIn(module_name, sys.modules)
 
 

Lib/test/test_importlib/source/test_finder.py

@@ -46,6 +46,10 @@ class FinderTests(abc.FinderTests):
                             self.machinery.BYTECODE_SUFFIXES)]
         return self.machinery.FileFinder(root, *loader_details)
 
+    def import_(self, root, module):
+        finder = self.get_finder(root)
+        return self._find(finder, module, loader_only=True)
+
     def run_test(self, test, create=None, *, compile_=None, unlink=None):
         """Test the finding of 'test' with the creation of modules listed in
         'create'.
@@ -127,7 +131,7 @@ class FinderTests(abc.FinderTests):
         with open('mod.py', 'w') as file:
             file.write("# test file for importlib")
         try:
-            loader = finder.find_module('mod')
+            loader = self._find(finder, 'mod', loader_only=True)
             self.assertTrue(hasattr(loader, 'load_module'))
         finally:
             os.unlink('mod.py')
@@ -145,8 +149,10 @@ class FinderTests(abc.FinderTests):
         mod = 'mod'
         with source_util.create_modules(mod) as mapping:
             finder = self.get_finder(mapping['.root'])
-            self.assertIsNotNone(finder.find_module(mod))
-        self.assertIsNone(finder.find_module(mod))
+            found = self._find(finder, 'mod', loader_only=True)
+            self.assertIsNotNone(found)
+        found = self._find(finder, 'mod', loader_only=True)
+        self.assertIsNone(found)
 
     @unittest.skipUnless(sys.platform != 'win32',
             'os.chmod() does not support the needed arguments under Windows')
@@ -170,29 +176,52 @@ class FinderTests(abc.FinderTests):
         self.addCleanup(cleanup, tempdir)
         os.chmod(tempdir.name, stat.S_IWUSR | stat.S_IXUSR)
         finder = self.get_finder(tempdir.name)
-        self.assertEqual((None, []), finder.find_loader('doesnotexist'))
+        found = self._find(finder, 'doesnotexist')
+        self.assertEqual(found, self.NOT_FOUND)
 
     def test_ignore_file(self):
         # If a directory got changed to a file from underneath us, then don't
         # worry about looking for submodules.
         with tempfile.NamedTemporaryFile() as file_obj:
             finder = self.get_finder(file_obj.name)
-            self.assertEqual((None, []), finder.find_loader('doesnotexist'))
+            found = self._find(finder, 'doesnotexist')
+            self.assertEqual(found, self.NOT_FOUND)
+
 
 class FinderTestsPEP451(FinderTests):
 
-    def import_(self, root, module):
-        found = self.get_finder(root).find_spec(module)
-        return found.loader if found is not None else found
+    NOT_FOUND = None
+
+    def _find(self, finder, name, loader_only=False):
+        spec = finder.find_spec(name)
+        return spec.loader if spec is not None else spec
 
 Frozen_FinderTestsPEP451, Source_FinderTestsPEP451 = util.test_both(
         FinderTestsPEP451, machinery=machinery)
 
 
+class FinderTestsPEP420(FinderTests):
+
+    NOT_FOUND = (None, [])
+
+    def _find(self, finder, name, loader_only=False):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            loader_portions = finder.find_loader(name)
+            return loader_portions[0] if loader_only else loader_portions
+
+Frozen_FinderTestsPEP420, Source_FinderTestsPEP420 = util.test_both(
+        FinderTestsPEP420, machinery=machinery)
+
+
 class FinderTestsPEP302(FinderTests):
 
-    def import_(self, root, module):
-        return self.get_finder(root).find_module(module)
+    NOT_FOUND = None
+
+    def _find(self, finder, name, loader_only=False):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            return finder.find_module(name)
 
 Frozen_FinderTestsPEP302, Source_FinderTestsPEP302 = util.test_both(
         FinderTestsPEP302, machinery=machinery)

Lib/test/test_importlib/source/test_source_encoding.py

@@ -12,6 +12,7 @@ import types
 # imported for the parser to use.
 import unicodedata
 import unittest
+import warnings
 
 
 CODING_RE = re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)', re.ASCII)
@@ -102,7 +103,9 @@ Frozen_EncodingTestPEP451, Source_EncodingTestPEP451 = util.test_both(
 class EncodingTestPEP302(EncodingTest):
 
     def load(self, loader):
-        return loader.load_module(self.module_name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            return loader.load_module(self.module_name)
 
 Frozen_EncodingTestPEP302, Source_EncodingTestPEP302 = util.test_both(
         EncodingTestPEP302, machinery=machinery)
@@ -121,8 +124,8 @@ class LineEndingTest:
             with open(mapping[module_name], 'wb') as file:
                 file.write(source)
             loader = self.machinery.SourceFileLoader(module_name,
-                                                 mapping[module_name])
-            return loader.load_module(module_name)
+                                                     mapping[module_name])
+            return self.load(loader, module_name)
 
     # [cr]
     def test_cr(self):
@@ -138,9 +141,9 @@ class LineEndingTest:
 
 class LineEndingTestPEP451(LineEndingTest):
 
-    def load(self, loader):
-        module = types.ModuleType(self.module_name)
-        module.__spec__ = importlib.util.spec_from_loader(self.module_name, loader)
+    def load(self, loader, module_name):
+        module = types.ModuleType(module_name)
+        module.__spec__ = importlib.util.spec_from_loader(module_name, loader)
         loader.exec_module(module)
         return module
 
@@ -149,8 +152,10 @@ Frozen_LineEndingTestPEP451, Source_LineEndingTestPEP451 = util.test_both(
 
 class LineEndingTestPEP302(LineEndingTest):
 
-    def load(self, loader):
-        return loader.load_module(self.module_name)
+    def load(self, loader, module_name):
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            return loader.load_module(module_name)
 
 Frozen_LineEndingTestPEP302, Source_LineEndingTestPEP302 = util.test_both(
         LineEndingTestPEP302, machinery=machinery)

Lib/test/test_importlib/test_abc.py

@@ -8,6 +8,7 @@ from test import support
 import types
 import unittest
 from unittest import mock
+import warnings
 
 from . import util
 
@@ -388,7 +389,9 @@ class InspectLoaderLoadModuleTests:
             mocked_get_code.side_effect = ImportError
             with self.assertRaises(ImportError):
                 loader = self.InspectLoaderSubclass()
-                loader.load_module(self.module_name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    loader.load_module(self.module_name)
 
     def test_get_code_None(self):
         # If get_code() returns None, raise ImportError.
@@ -631,7 +634,9 @@ class SourceOnlyLoaderTests(SourceLoaderTestHarness):
         # __path__ (for packages), __file__, and __cached__.
         # The module should also be put into sys.modules.
         with util.uncache(self.name):
-            module = self.loader.load_module(self.name)
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.loader.load_module(self.name)
             self.verify_module(module)
             self.assertEqual(module.__path__, [os.path.dirname(self.path)])
             self.assertIn(self.name, sys.modules)
@@ -642,7 +647,9 @@ class SourceOnlyLoaderTests(SourceLoaderTestHarness):
         # Testing the values for a package are covered by test_load_module.
         self.setUp(is_package=False)
         with util.uncache(self.name):
-            module = self.loader.load_module(self.name)
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.loader.load_module(self.name)
             self.verify_module(module)
             self.assertTrue(not hasattr(module, '__path__'))
 

Lib/test/test_importlib/test_api.py

@@ -10,6 +10,7 @@ import sys
 from test import support
 import types
 import unittest
+import warnings
 
 
 @contextmanager
@@ -143,7 +144,9 @@ class FindLoaderTests:
             loader = 'a loader!'
             module.__loader__ = loader
             sys.modules[name] = module
-            found = self.init.find_loader(name)
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                found = self.init.find_loader(name)
             self.assertEqual(loader, found)
 
     def test_sys_modules_loader_is_None(self):
@@ -154,7 +157,9 @@ class FindLoaderTests:
             module.__loader__ = None
             sys.modules[name] = module
             with self.assertRaises(ValueError):
-                self.init.find_loader(name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.init.find_loader(name)
 
     def test_sys_modules_loader_is_not_set(self):
         # Should raise ValueError
@@ -168,14 +173,18 @@ class FindLoaderTests:
                 pass
             sys.modules[name] = module
             with self.assertRaises(ValueError):
-                self.init.find_loader(name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.init.find_loader(name)
 
     def test_success(self):
         # Return the loader found on sys.meta_path.
         name = 'some_mod'
         with util.uncache(name):
             with util.import_state(meta_path=[self.FakeMetaFinder]):
-                self.assertEqual((name, None), self.init.find_loader(name))
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.assertEqual((name, None), self.init.find_loader(name))
 
     def test_success_path(self):
         # Searching on a path should work.
@@ -183,12 +192,16 @@ class FindLoaderTests:
         path = 'path to some place'
         with util.uncache(name):
             with util.import_state(meta_path=[self.FakeMetaFinder]):
-                self.assertEqual((name, path),
-                                 self.init.find_loader(name, path))
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.assertEqual((name, path),
+                                     self.init.find_loader(name, path))
 
     def test_nothing(self):
         # None is returned upon failure to find a loader.
-        self.assertIsNone(self.init.find_loader('nevergoingtofindthismodule'))
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertIsNone(self.init.find_loader('nevergoingtofindthismodule'))
 
 class Frozen_FindLoaderTests(FindLoaderTests, unittest.TestCase):
     init = frozen_init

Lib/test/test_importlib/test_spec.py

@@ -50,7 +50,7 @@ class LegacyLoader(TestLoader):
     HAM = -1
 
     with warnings.catch_warnings():
-        warnings.simplefilter("ignore", PendingDeprecationWarning)
+        warnings.simplefilter("ignore", DeprecationWarning)
 
         @frozen_util.module_for_loader
         def load_module(self, module):

Lib/test/test_importlib/test_util.py

@@ -41,14 +41,14 @@ class ModuleForLoaderTests:
     @classmethod
     def module_for_loader(cls, func):
         with warnings.catch_warnings():
-            warnings.simplefilter('ignore', PendingDeprecationWarning)
+            warnings.simplefilter('ignore', DeprecationWarning)
             return cls.util.module_for_loader(func)
 
     def test_warning(self):
         # Should raise a PendingDeprecationWarning when used.
         with warnings.catch_warnings():
-            warnings.simplefilter('error', PendingDeprecationWarning)
-            with self.assertRaises(PendingDeprecationWarning):
+            warnings.simplefilter('error', DeprecationWarning)
+            with self.assertRaises(DeprecationWarning):
                 func = self.util.module_for_loader(lambda x: x)
 
     def return_module(self, name):
@@ -172,7 +172,9 @@ class SetPackageTests:
         passing through set_package."""
         fxn = lambda: module
         wrapped = self.util.set_package(fxn)
-        wrapped()
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            wrapped()
         self.assertTrue(hasattr(module, '__package__'))
         self.assertEqual(expect, module.__package__)
 
@@ -212,7 +214,9 @@ class SetPackageTests:
 
     def test_decorator_attrs(self):
         def fxn(module): pass
-        wrapped = self.util.set_package(fxn)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            wrapped = self.util.set_package(fxn)
         self.assertEqual(wrapped.__name__, fxn.__name__)
         self.assertEqual(wrapped.__qualname__, fxn.__qualname__)
 
@@ -236,19 +240,25 @@ class SetLoaderTests:
             del loader.module.__loader__
         except AttributeError:
             pass
-        self.assertEqual(loader, loader.load_module('blah').__loader__)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertEqual(loader, loader.load_module('blah').__loader__)
 
     def test_attribute_is_None(self):
         loader = self.DummyLoader()
         loader.module = types.ModuleType('blah')
         loader.module.__loader__ = None
-        self.assertEqual(loader, loader.load_module('blah').__loader__)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertEqual(loader, loader.load_module('blah').__loader__)
 
     def test_not_reset(self):
         loader = self.DummyLoader()
         loader.module = types.ModuleType('blah')
         loader.module.__loader__ = 42
-        self.assertEqual(42, loader.load_module('blah').__loader__)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertEqual(42, loader.load_module('blah').__loader__)
 
 class Frozen_SetLoaderTests(SetLoaderTests, unittest.TestCase):
     class DummyLoader:

Misc/NEWS

@@ -283,7 +283,8 @@ Library
 - Issue #6477: Added support for pickling the types of built-in singletons
   (i.e., Ellipsis, NotImplemented, None).
 
-- Issue #19713: Move away from using find_module/load_module.
+- Issue #19713: Add remaining PEP 451-related deprecations and move away
+  from using find_module/find_loaer/load_module.
 
 - Issue #19708: Update pkgutil to use the new importer APIs.