importlib.machinery

The machinery of importlib: finders, loaders, hooks, etc.

Classes

BuiltinImporter

Meta path import for built-in modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

create_module(spec)

  Create a built-in module

exec_module(module)

  Exec a built-in module

find_module(fullname, path=None)

  Find the built-in module.

          If 'path' is ever specified then the search is considered a failure.

          This method is deprecated.  Use find_spec() instead.

find_spec(fullname, path=None, target=None)

get_code(fullname)

  Return None as built-in modules do not have code objects.

get_source(fullname)

  Return None as built-in modules do not have source code.

is_package(fullname)

  Return False as built-in modules are never packages.

_load_module_shim(fullname)

  Load the specified module into sys.modules and return it.

      This method is deprecated.  Use loader.exec_module() instead.

module_repr(module)

  Return repr for the module.

          The method is deprecated.  The import machinery does the job itself.

ExtensionFileLoader

Loader for extension modules.

    The constructor is designed to work with FileFinder.

create_module(self, spec)

  Create an unitialized extension module

exec_module(self, module)

  Initialize an extension module

get_code(self, fullname)

  Return None as an extension module cannot create a code object.

get_data(self, path)

  Return the data from path as raw bytes.

get_filename(self, name=None, *args, **kwargs)

  Return the path to the source file as found by the finder.

get_resource_reader(self, name=None, *args, **kwargs)

get_source(self, fullname)

  Return None as extension modules have no source code.

is_package(self, fullname)

  Return True if the extension module is a package.

load_module(self, name=None, *args, **kwargs)

  Load a module from a file.

          This method is deprecated.  Use exec_module() instead.

FileFinder

File-based finder.

    Interactions with the file system are cached for performance, being
    refreshed when the directory the finder is handling has been modified.

find_loader(self, fullname)

  Try to find a loader for the specified module, or the namespace
          package portions. Returns (loader, list-of-portions).

          This method is deprecated.  Use find_spec() instead.

_find_module_shim(self, fullname)

  Try to find a loader for the specified module by delegating to
      self.find_loader().

      This method is deprecated in favor of finder.find_spec().

find_spec(self, fullname, target=None)

  Try to find a spec for the specified module.

          Returns the matching spec, or None if not found.

invalidate_caches(self)

  Invalidate the directory mtime.

path_hook(*loader_details)

  A class method which returns a closure to use on sys.path_hook
          which will return an instance using the specified loaders and the path
          called on the closure.

          If the path called on the closure is not a directory, ImportError is
          raised.

FrozenImporter

Meta path import for frozen modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

create_module(spec)

  Use default semantics for module creation.

exec_module(module)

find_module(fullname, path=None)

  Find a frozen module.

          This method is deprecated.  Use find_spec() instead.

find_spec(fullname, path=None, target=None)

get_code(fullname)

  Return the code object for the frozen module.

get_source(fullname)

  Return None as frozen modules do not have source code.

is_package(fullname)

  Return True if the frozen module is a package.

load_module(fullname)

  Load a frozen module.

          This method is deprecated.  Use exec_module() instead.

module_repr(m)

  Return repr for the module.

          The method is deprecated.  The import machinery does the job itself.

ModuleSpec

The specification for a module, used for loading.

    A module's spec is the source for information about the module.  For
    data associated with the module, including source, use the spec's
    loader.

    `name` is the absolute name of the module.  `loader` is the loader
    to use when loading the module.  `parent` is the name of the
    package the module is in.  The parent is derived from the name.

    `is_package` determines if the module is considered a package or
    not.  On modules this is reflected by the `__path__` attribute.

    `origin` is the specific location used by the loader from which to
    load the module, if that information is available.  When filename is
    set, origin will match.

    `has_location` indicates that a spec's "origin" reflects a location.
    When this is True, `__file__` attribute of the module is set.

    `cached` is the location of the cached bytecode file, if any.  It
    corresponds to the `__cached__` attribute.

    `submodule_search_locations` is the sequence of path entries to
    search when importing submodules.  If set, is_package should be
    True--and False otherwise.

    Packages are simply modules that (may) have submodules.  If a spec
    has a non-None value in `submodule_search_locations`, the import
    system will consider modules loaded from the spec as packages.

    Only finders (see importlib.abc.MetaPathFinder and
    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.

cached = <property object at 0x7f75e3cb9440>

has_location = <property object at 0x7f75e3cb94e0>

parent = <property object at 0x7f75e3cb9350>
  The name of the module's parent.

PathFinder

Meta path finder for sys.path and package __path__ attributes.

find_distributions(*args, **kwargs)


          Find distributions.

          Return an iterable of all Distribution instances capable of
          loading the metadata for packages matching ``context.name``
          (or all names if ``None`` indicated) along the paths in the list
          of directories ``context.path``.

find_module(fullname, path=None)

  find the module on sys.path or 'path' based on sys.path_hooks and
          sys.path_importer_cache.

          This method is deprecated.  Use find_spec() instead.

find_spec(fullname, path=None, target=None)

  Try to find a spec for 'fullname' on sys.path or 'path'.

          The search is based on sys.path_hooks and sys.path_importer_cache.

invalidate_caches()

  Call the invalidate_caches() method on all path entry finders
          stored in sys.path_importer_caches (where implemented).

SourceFileLoader

Concrete implementation of SourceLoader using the file system.

create_module(self, spec)

  Use default semantics for module creation.

exec_module(self, module)

  Execute the module.

get_code(self, fullname)

  Concrete implementation of InspectLoader.get_code.

          Reading of bytecode requires path_stats to be implemented. To write
          bytecode, set_data must also be implemented.

get_data(self, path)

  Return the data from path as raw bytes.

get_filename(self, name=None, *args, **kwargs)

  Return the path to the source file as found by the finder.

get_resource_reader(self, name=None, *args, **kwargs)

get_source(self, fullname)

  Concrete implementation of InspectLoader.get_source.

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

load_module(self, name=None, *args, **kwargs)

  Load a module from a file.

          This method is deprecated.  Use exec_module() instead.

path_mtime(self, path)

  Optional method that returns the modification time (an int) for the
          specified path (a str).

          Raises OSError when the path cannot be handled.

path_stats(self, path)

  Return the metadata for the path.

set_data(self, path, data, *, _mode=438)

  Write bytes data to a file.

source_to_code(self, data, path, *, _optimize=-1)

  Return the code object compiled from source.

          The 'data' argument can be any object type that compile() supports.

SourcelessFileLoader

Loader which handles sourceless file imports.

create_module(self, spec)

  Use default semantics for module creation.

exec_module(self, module)

  Execute the module.

get_code(self, fullname)

get_data(self, path)

  Return the data from path as raw bytes.

get_filename(self, name=None, *args, **kwargs)

  Return the path to the source file as found by the finder.

get_resource_reader(self, name=None, *args, **kwargs)

get_source(self, fullname)

  Return None as there is no source code.

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

load_module(self, name=None, *args, **kwargs)

  Load a module from a file.

          This method is deprecated.  Use exec_module() instead.

WindowsRegistryFinder

Meta path finder for modules declared in the Windows registry.

find_module(fullname, path=None)

  Find module named in the registry.

          This method is deprecated.  Use find_spec() instead.

find_spec(fullname, path=None, target=None)

DEBUG_BUILD = False

REGISTRY_KEY = 'Software\\Python\\PythonCore\\{sys_version}\\Modules\\{fullname}'

REGISTRY_KEY_DEBUG = 'Software\\Python\\PythonCore\\{sys_version}\\Modules\\{fullname}\\Debug'

Functions

all_suffixes

all_suffixes()

  Returns a list of all recognized module suffixes for this process

Other members

BYTECODE_SUFFIXES = ['.pyc']

DEBUG_BYTECODE_SUFFIXES = ['.pyc']

EXTENSION_SUFFIXES = ['.cpython-310-x86_64-linux-gnu.so', '.abi3.so', '.so']

OPTIMIZED_BYTECODE_SUFFIXES = ['.pyc']

SOURCE_SUFFIXES = ['.py']