Lines Matching refs:module
3 This module is NOT meant to be directly imported! It has been designed such
6 work. One should use importlib as the public-facing version of this module.
10 # IMPORTANT: Whenever making changes to this module, be sure to run a top-level
12 # of the module updated. Not doing so will result in the Makefile to fail for
13 # all others who don't have a ./python around to freeze the module
54 # A dict mapping module names to weakrefs of _ModuleLock instances
102 Acquire the module lock. If a potential deadlock is detected,
180 """Get or create the module lock for a given module name.
217 """Acquires then releases the module lock for a given module name.
219 This is used to ensure a module is completely initialized, in the
227 # module object.
239 module code)
253 """Decorator to verify the named module is built-in."""
256 raise ImportError('{!r} is not a built-in module'.format(fullname),
264 """Decorator to verify the named module is frozen."""
267 raise ImportError('{!r} is not a frozen module'.format(fullname),
276 """Load the specified module into sys.modules and return it.
286 module = sys.modules[fullname]
287 _exec(spec, module)
294 def _module_repr(module):
296 loader = getattr(module, '__loader__', None)
297 if spec := getattr(module, "__spec__", None):
301 return loader.module_repr(module)
306 name = module.__name__
310 filename = module.__file__
313 return '<module {!r}>'.format(name)
315 return '<module {!r} ({!r})>'.format(name, loader)
317 return '<module {!r} from {!r}>'.format(name, filename)
321 """The specification for a module, used for loading.
323 A module's spec is the source for information about the module. For
324 data associated with the module, including source, use the spec's
327 `name` is the absolute name of the module. `loader` is the loader
328 to use when loading the module. `parent` is the name of the
329 package the module is in. The parent is derived from the name.
331 `is_package` determines if the module is considered a package or
335 load the module, if that information is available. When filename is
339 When this is True, `__file__` attribute of the module is set.
407 """The name of the module's parent."""
423 """Return a module spec based on various loader methods."""
451 def _spec_from_module(module, loader=None, origin=None):
454 spec = module.__spec__
461 name = module.__name__
464 loader = module.__loader__
469 location = module.__file__
478 cached = module.__cached__
482 submodule_search_locations = list(module.__path__)
493 def _init_module_attrs(spec, module, *, override=False):
494 # The passed-in module may be not support attribute assignment,
497 if (override or getattr(module, '__name__', None) is None):
499 module.__name__ = spec.name
503 if override or getattr(module, '__loader__', None) is None:
515 # While the docs say that module.__file__ is not set for
519 # __spec__.origin is None, and thus their module.__file__
525 module.__file__ = None
527 module.__loader__ = loader
531 if override or getattr(module, '__package__', None) is None:
533 module.__package__ = spec.parent
538 module.__spec__ = spec
542 if override or getattr(module, '__path__', None) is None:
546 module.__path__ = spec.submodule_search_locations
551 if override or getattr(module, '__file__', None) is None:
553 module.__file__ = spec.origin
557 if override or getattr(module, '__cached__', None) is None:
560 module.__cached__ = spec.cached
563 return module
567 """Create a module based on the provided spec."""
569 module = None
572 # module creation should be used.
573 module = spec.loader.create_module(spec)
577 if module is None:
578 module = _new_module(spec.name)
579 _init_module_attrs(spec, module)
580 return module
584 """Return the repr to use for the module."""
589 return '<module {!r}>'.format(name)
591 return '<module {!r} ({!r})>'.format(name, spec.loader)
594 return '<module {!r} from {!r}>'.format(name, spec.origin)
596 return '<module {!r} ({})>'.format(spec.name, spec.origin)
600 def _exec(spec, module):
601 """Execute the spec's specified module in an existing module's namespace."""
604 if sys.modules.get(name) is not module:
605 msg = 'module {!r} not in sys.modules'.format(name)
612 _init_module_attrs(spec, module, override=True)
614 _init_module_attrs(spec, module, override=True)
621 spec.loader.exec_module(module)
623 # Update the order of insertion into sys.modules for module
625 module = sys.modules.pop(spec.name)
626 sys.modules[spec.name] = module
627 return module
637 module = sys.modules.pop(spec.name)
638 sys.modules[spec.name] = module
640 # The module must be in sys.modules at this point!
642 module = sys.modules.pop(spec.name)
643 sys.modules[spec.name] = module
644 if getattr(module, '__loader__', None) is None:
646 module.__loader__ = spec.loader
649 if getattr(module, '__package__', None) is None:
651 # Since module.__path__ may not line up with
654 module.__package__ = module.__name__
655 if not hasattr(module, '__path__'):
656 module.__package__ = spec.name.rpartition('.')[0]
659 if getattr(module, '__spec__', None) is None:
661 module.__spec__ = spec
664 return module
676 module = module_from_spec(spec)
678 # This must be done before putting the module in sys.modules
683 sys.modules[spec.name] = module
690 spec.loader.exec_module(module)
697 # Move the module to the end of sys.modules.
698 # We don't ensure that the import-related module attributes get
701 module = sys.modules.pop(spec.name)
702 sys.modules[spec.name] = module
707 return module
712 """Return a new module object, loaded by the spec's loader.
714 The module is not added to its parent.
716 If a module is already in sys.modules, that existing module gets
738 def module_repr(module):
739 """Return repr for the module.
746 return f'<module {module.__name__!r} ({BuiltinImporter._ORIGIN})>'
757 """Find the built-in module.
772 """Create a built-in module"""
774 raise ImportError('{!r} is not a built-in module'.format(spec.name),
779 def exec_module(module):
780 """Exec a built-in module"""
781 _call_with_frames_removed(_imp.exec_builtin, module)
817 """Return repr for the module.
824 return '<module {!r} ({})>'.format(m.__name__, FrozenImporter._ORIGIN)
827 def _fix_up_module(cls, module):
828 spec = module.__spec__
831 # The module is missing FrozenImporter-specific values.
834 origname = vars(module).pop('__origname__', None)
836 ispkg = hasattr(module, '__path__')
837 assert _imp.is_frozen_package(module.__name__) == ispkg, ispkg
851 # Fix up the module attrs (the bare minimum).
852 assert not hasattr(module, '__file__'), module.__file__
855 module.__file__ = filename
859 if module.__path__ != __path__:
860 assert module.__path__ == [], module.__path__
861 module.__path__.extend(__path__)
884 assert hasattr(module, '__file__')
885 assert module.__file__ == __file__, (module.__file__, __file__)
887 assert not hasattr(module, '__file__'), module.__file__
889 assert hasattr(module, '__path__')
890 assert module.__path__ == __path__, (module.__path__, __path__)
892 assert not hasattr(module, '__path__'), module.__path__
928 # be loaded into the module. (For example, see _LoaderBasics
932 # to later load the module is okay, and sometimes important.
952 """Find a frozen module.
965 module = _new_module(spec.name)
972 module.__file__ = filename
973 return module
976 def exec_module(module):
977 spec = module.__spec__
980 exec(code, module.__dict__)
984 """Load a frozen module.
990 module = _load_module_shim(cls, fullname)
994 module.__origname__ = origname
995 vars(module).pop('__file__', None)
997 module.__path__ = []
998 cls._fix_up_module(module)
999 return module
1004 """Return the code object for the frozen module."""
1016 """Return True if the frozen module is a package."""
1036 """Resolve a relative module name to an absolute one."""
1055 """Find a module's spec."""
1080 # The parent import may have already imported this module.
1082 module = sys.modules[name]
1084 __spec__ = module.__spec__
1087 # we would have used if the parent module hadn't
1104 raise TypeError('module name must be str, not {}'.format(type(name)))
1114 raise ValueError('Empty module name')
1117 _ERR_MSG_PREFIX = 'No module named '
1147 module = _load_unlocked(spec)
1152 # Set the module as an attribute on its parent.
1155 setattr(parent_module, child, module)
1157 msg = f"Cannot set an attribute on {parent!r} for child module {child!r}"
1159 return module
1166 """Find and load the module."""
1168 # Optimization: we avoid unneeded module locking if the module
1170 module = sys.modules.get(name, _NEEDS_LOADING)
1171 if (module is _NEEDS_LOADING or
1172 getattr(getattr(module, "__spec__", None), "_initializing", False)):
1174 module = sys.modules.get(name, _NEEDS_LOADING)
1175 if module is _NEEDS_LOADING:
1179 # module.__spec__._initializing is True.
1181 # putting the new module in sys.modules.
1184 if module is None:
1189 return module
1193 """Import and return the module based on its name, the package the call is
1207 def _handle_fromlist(module, fromlist, import_, *, recursive=False):
1210 The import_ parameter is a callable which takes the name of module to
1220 where = module.__name__ + '.__all__'
1226 if not recursive and hasattr(module, '__all__'):
1227 _handle_fromlist(module, module.__all__, import_,
1229 elif not hasattr(module, x):
1230 from_name = '{}.{}'.format(module.__name__, x)
1241 return module
1272 """Import a module.
1276 'fromlist' argument specifies what should exist as attributes on the module
1277 being imported (e.g. ``from module import <fromlist>``). The 'level'
1283 module = _gcd_import(name)
1287 module = _gcd_import(name, package, level)
1294 return module
1296 # Figure out where to slice the module's name up to the first dot
1301 return sys.modules[module.__name__[:len(module.__name__)-cut_off]]
1302 elif hasattr(module, '__path__'):
1303 return _handle_fromlist(module, fromlist, _gcd_import)
1305 return module
1311 raise ImportError('no built-in module named ' + name)
1329 for name, module in sys.modules.items():
1330 if isinstance(module, module_type):
1337 spec = _spec_from_module(module, loader)
1338 _init_module_attrs(spec, module)
1340 loader._fix_up_module(module)