Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Issue 19713: Add PEP 451-related deprecations.

This commit is contained in:
Eric Snow 2014-01-06 20:49:04 -07:00
parent 02b9f9d6bb
commit 1500d49c22
15 changed files with 4348 additions and 4047 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Lib/importlib/__init__.py
View File

@ -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:

124
Lib/importlib/_bootstrap.py
View File

@ -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:

13
Lib/importlib/abc.py
View File

@ -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

20
Lib/importlib/util.py
View File

@ -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:

5
Lib/test/test_importlib/extension/test_finder.py
View File

@ -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))

42
Lib/test/test_importlib/frozen/test_loader.py
View File

@ -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

54
Lib/test/test_importlib/source/test_file_loader.py
View File

@ -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)

49
Lib/test/test_importlib/source/test_finder.py
View File

@ -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)

21
Lib/test/test_importlib/source/test_source_encoding.py
View File

@ -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)

13
Lib/test/test_importlib/test_abc.py
View File

@ -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__'))

27
Lib/test/test_importlib/test_api.py
View File

@ -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

2
Lib/test/test_importlib/test_spec.py
View File

@ -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):

26
Lib/test/test_importlib/test_util.py
View File

@ -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:

3
Misc/NEWS
View File

@ -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.

7990
Python/importlib.h
View File

File diff suppressed because it is too large Load Diff