def two_temp_modules(temp_module_factory):
module1 = temp_module_factory()
module2 = temp_module_factory()
assert not module_imported(module1)
assert not module_imported(module2)
return module1, module2
def test_extension_loader__force(ext_loader, two_temp_modules):
module1, module2 = two_temp_modules
ext_loader.builtin_extensions[module1] = Extension(module1, [module2],
force=True)
ext_loader.load_all()
assert module_imported(module1)
assert module_imported(module2)
def test_extension_loader__force(ext_loader):
with unload_load('stat'), unload_load('pprint'):
assert not module_imported('stat')
assert not module_imported('pprint')
ext_loader.builtin_extensions['stat'] = Extension('stat', ['pprint'], force=True)
ext_loader.load_all()
assert module_imported('stat')
assert module_imported('pprint')
def test_extension_loader__lazy(ext_loader, two_temp_modules):
module1, module2 = two_temp_modules
ext_loader.builtin_extensions[module1] = Extension(module1, [module2],
force=False)
ext_loader.load_all()
assert not module_imported(module1)
assert not module_imported(module2)
import_module(module2) # noqa
assert module_imported(module1)
assert module_imported(module2)
def test_extension_loader__lazy_defered(ext_loader, two_temp_modules,
temp_module_factory):
module1, module2 = two_temp_modules
ext_loader.builtin_extensions[module1] = Extension(module1, [module2],
force=False)
ext_loader.load_all()
assert not module_imported(module1)
assert not module_imported(module2)
module3 = temp_module_factory(f'import {module2}')
import_module(module3) # noqa
assert module_imported(module1)
assert module_imported(module2)
def inner(text=''):
module = 'sys'
while module_imported(module):
name = f'temp_module_{random.randint(0, 10 ** 6)}'
module_path = fs.current_module_path(name) + '.py'
with open(module_path, 'w') as f:
f.write(text)
modules.append(module_path)
module = f'tests.ext.{name}'
return module
def load(cls, extension: Union[str, Extension]):
"""
Load single extension
:param extension: str of :class:`Extension` instance to load
"""
if isinstance(extension, str):
extension = Extension(extension, [], force=True)
if extension not in cls._loaded_extensions and not module_imported(extension.module):
logger.debug('Importing extension module %s', extension.module)
cls._loaded_extensions[extension] = import_module(extension.module)
def unload_load(module_name):
if module_imported(module_name):
mod = sys.modules.pop(module_name)
try:
yield
finally:
sys.modules[module_name] = mod
else:
try:
yield
finally:
sys.modules.pop(module_name, None)
def load_module(self, fullname):
# change this hook to registering hook
reg = _ImportLoadExtRegisterer()
sys.meta_path = [reg] + [x for x in sys.meta_path if x is not self]
try:
# fallback to ordinary importing
module = importlib.import_module(fullname)
finally:
# put this hook back
sys.meta_path = [self] + [x for x in sys.meta_path if x is not reg]
# check all that was imported and import all extensions that are ready
for imported in reg.imported:
if not module_imported(imported):
continue
extension = self.module_to_extension.get(imported)
if extension is None:
continue
if all(module_imported(m) for m in extension.reqs):
ExtensionLoader.load(extension)
return module
def load_module(self, fullname):
sys.meta_path = [x for x in sys.meta_path if x is not self]
try:
module = importlib.import_module(fullname)
finally:
sys.meta_path = [self] + sys.meta_path
extension = self.module_to_extension.get(fullname)
if extension is None:
return module
if all(module_imported(m) for m in extension.reqs):
ExtensionLoader.load(extension)
return module
def load_all(cls, try_lazy=True):
"""
Load all (builtin and additional) extensions
:param try_lazy: if `False`, use force load for all builtin extensions
"""
for_hook = []
for ext in cls.builtin_extensions.values():
if not try_lazy or hasattr(sys, 'frozen') or ext.force:
if all(module_importable(r) for r in ext.reqs):
cls.load(ext)
else:
if all(module_imported(r) for r in ext.reqs):
cls.load(ext)
else:
for_hook.append(ext)
cls._setup_import_hook(for_hook)
for mod in Core.ADDITIONAL_EXTENSIONS:
cls.load(mod)
def test_extension_loader__lazy(ext_loader):
with unload_load('marshal'), unload_load('dbm'):
assert not module_imported('marshal')
assert not module_imported('dbm')
ext_loader.builtin_extensions['marshal'] = Extension('marshal', ['dbm'], force=False)
ext_loader.load_all()
assert not module_imported('marshal')
assert not module_imported('dbm')
import dbm # noqa
assert module_imported('marshal')
assert module_imported('dbm')
