from the import. If the loader inserted a module and the load fails, it

must be removed by the loader from:data:`sys.modules`; modules already

in:data:`sys.modules` before the loader began execution should be left

alone (see:func:`importlib.util.module_for_loader`).

alone.

The loader should set several attributes on the module

(note that some of these attributes can change when a module is

..versionadded::3.5

..decorator::module_for_loader

A:term:`decorator` for:meth:`importlib.abc.Loader.load_module`

to handle selecting the proper

module object to load with. The decorated method is expected to have a call

signature taking two positional arguments

(e.g. ``load_module(self, module)``) for which the second argument

will be the module **object** to be used by the loader.

Note that the decorator will not work on static methods because of the

assumption of two arguments.

The decorated method will take in the **name** of the module to be loaded

as expected for a:term:`loader`. If the module is not found in

:data:`sys.modules` then a new one is constructed. Regardless of where the

module came from,:attr:`__loader__` set to **self** and:attr:`__package__`

is set based on what:meth:`importlib.abc.InspectLoader.is_package` returns

(if available). These attributes are set unconditionally to support

reloading.

If an exception is raised by the decorated method and a module was added to

:data:`sys.modules`, then the module will be removed to prevent a partially

initialized module from being in left in:data:`sys.modules`. If the module

was already in:data:`sys.modules` then it is left alone.

..versionchanged::3.3

:attr:`__loader__` and:attr:`__package__` are automatically set

(when possible).

..versionchanged::3.4

Set:attr:`__name__`,:attr:`__loader__`:attr:`__package__`

unconditionally to support reloading.

..deprecated::3.4

The import machinery now directly performs all the functionality

provided by this function.

..decorator::set_loader

A:term:`decorator` for:meth:`importlib.abc.Loader.load_module`

to set the:attr:`__loader__`

attribute on the returned module. If the attribute is already set the

decorator does nothing. It is assumed that the first positional argument to

the wrapped method (i.e. ``self``) is what:attr:`__loader__` should be set

to.

..versionchanged::3.4

Set ``__loader__`` if set to ``None``, as if the attribute does not

exist.

..deprecated::3.4

The import machinery takes care of this automatically.

..decorator::set_package

A:term:`decorator` for:meth:`importlib.abc.Loader.load_module` to set the

:attr:`__package__` attribute on the returned module. If:attr:`__package__`

is set and has a value other than ``None`` it will not be changed.

..deprecated::3.4

The import machinery takes care of this automatically.

..function::spec_from_loader(name, loader, *, origin=None, is_package=None)

A factory function for creating a:class:`~importlib.machinery.ModuleSpec`

from ._bootstrap_externalimportsource_from_cache

from ._bootstrap_externalimportspec_from_file_location

defsource_hash(source_bytes):

def_module_to_load(name):

is_reload=nameinsys.modules

module=sys.modules.get(name)

ifnotis_reload:

module=type(sys)(name)

module.__initializing__=True

sys.modules[name]=module

try:

exceptException:

ifnotis_reload:

try:

delsys.modules[name]

exceptKeyError:

finally:

module.__initializing__=False

defset_package(fxn):

defset_package_wrapper(*args,**kwargs):

warnings.warn('The import system now takes care of this automatically; '

'this decorator is slated for removal in Python 3.12',

DeprecationWarning,stacklevel=2)

module=fxn(*args,**kwargs)

ifgetattr(module,'__package__',None)isNone:

module.__package__=module.__name__

ifnothasattr(module,'__path__'):

module.__package__=module.__package__.rpartition('.')[0]

defset_loader(fxn):

defset_loader_wrapper(self,*args,**kwargs):

warnings.warn('The import system now takes care of this automatically; '

'this decorator is slated for removal in Python 3.12',

DeprecationWarning,stacklevel=2)

module=fxn(self,*args,**kwargs)

ifgetattr(module,'__loader__',None)isNone:

module.__loader__=self

defmodule_for_loader(fxn):

warnings.warn('The import system now takes care of this automatically; '

'this decorator is slated for removal in Python 3.12',

DeprecationWarning,stacklevel=2)

defmodule_for_loader_wrapper(self,fullname,*args,**kwargs):

with_module_to_load(fullname)asmodule:

module.__loader__=self

try:

is_package=self.is_package(fullname)

except (ImportError,AttributeError):

else:

ifis_package:

module.__package__=fullname

else:

module.__package__=fullname.rpartition('.')[0]

returnfxn(self,module,*args,**kwargs)

class_LazyModule(types.ModuleType):

classSourceOnlyLoaderTests(SourceLoaderTestHarness):

deftest_get_source(self):

module.eggs=self.EGGS

classLegacyLoader(TestLoader):

withwarnings.catch_warnings():

warnings.simplefilter("ignore",DeprecationWarning)

frozen_util=util['Frozen']

defload_module(self,module):

module.ham=self.HAM

classModuleSpecTests:

defsetUp(self):

loaded=self.bootstrap._load(self.spec)

self.assertNotIn(self.spec.name,sys.modules)

deftest_load_legacy(self):

withwarnings.catch_warnings():

warnings.simplefilter("ignore",ImportWarning)

self.spec.loader=LegacyLoader()

withCleanImport(self.spec.name):

loaded=self.bootstrap._load(self.spec)

self.assertEqual(loaded.ham,-1)

deftest_load_legacy_attributes(self):

withwarnings.catch_warnings():

warnings.simplefilter("ignore",ImportWarning)

self.spec.loader=LegacyLoader()

withCleanImport(self.spec.name):

loaded=self.bootstrap._load(self.spec)

self.assertIs(loaded.__loader__,self.spec.loader)

self.assertEqual(loaded.__package__,self.spec.parent)

self.assertIs(loaded.__spec__,self.spec)

deftest_load_legacy_attributes_immutable(self):

module=object()

withwarnings.catch_warnings():

self.assertFalse(hasattr(loaded,'__file__'))

self.assertFalse(hasattr(loaded,'__cached__'))

deftest_reload_legacy(self):

withwarnings.catch_warnings():

warnings.simplefilter("ignore",ImportWarning)

self.spec.loader=LegacyLoader()

withCleanImport(self.spec.name):

loaded=self.bootstrap._load(self.spec)

reloaded=self.bootstrap._exec(self.spec,loaded)

installed=sys.modules[self.spec.name]

self.assertEqual(loaded.ham,-1)

self.assertIs(reloaded,loaded)

self.assertIs(installed,loaded)

(Frozen_ModuleSpecMethodsTests,