| """Abstract base classes related to import.""" |
| from . import _bootstrap |
| from . import machinery |
| try: |
| import _frozen_importlib |
| except ImportError as exc: |
| if exc.name != '_frozen_importlib': |
| raise |
| _frozen_importlib = None |
| import abc |
| |
| |
| def _register(abstract_cls, *classes): |
| for cls in classes: |
| abstract_cls.register(cls) |
| if _frozen_importlib is not None: |
| frozen_cls = getattr(_frozen_importlib, cls.__name__) |
| abstract_cls.register(frozen_cls) |
| |
| |
| class Finder(metaclass=abc.ABCMeta): |
| |
| """Legacy abstract base class for import finders. |
| |
| It may be subclassed for compatibility with legacy third party |
| reimplementations of the import system. Otherwise, finder |
| implementations should derive from the more specific MetaPathFinder |
| or PathEntryFinder ABCs. |
| """ |
| |
| @abc.abstractmethod |
| def find_module(self, fullname, path=None): |
| """An abstract method that should find a module. |
| The fullname is a str and the optional path is a str or None. |
| Returns a Loader object or None. |
| """ |
| |
| |
| class MetaPathFinder(Finder): |
| |
| """Abstract base class for import finders on sys.meta_path.""" |
| |
| # We don't define find_spec() here since that would break |
| # hasattr checks we do to support backward compatibility. |
| |
| 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(). If find_spec() |
| exists then backwards-compatible functionality is provided for this |
| method. |
| |
| """ |
| if not hasattr(self, 'find_spec'): |
| return None |
| found = self.find_spec(fullname, path) |
| return found.loader if found is not None else None |
| |
| def invalidate_caches(self): |
| """An optional method for clearing the finder's cache, if any. |
| This method is used by importlib.invalidate_caches(). |
| """ |
| |
| _register(MetaPathFinder, machinery.BuiltinImporter, machinery.FrozenImporter, |
| machinery.PathFinder, machinery.WindowsRegistryFinder) |
| |
| |
| class PathEntryFinder(Finder): |
| |
| """Abstract base class for path entry finders used by PathFinder.""" |
| |
| # We don't define find_spec() here since that would break |
| # hasattr checks we do to support backward compatibility. |
| |
| def find_loader(self, fullname): |
| """Return (loader, namespace portion) for the path entry. |
| |
| The fullname is a str. The namespace portion is a sequence of |
| path entries contributing to part of a namespace package. The |
| sequence may be empty. If loader is not None, the portion will |
| be ignored. |
| |
| 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(). If find_spec() |
| is provided than backwards-compatible functionality is provided. |
| |
| """ |
| if not hasattr(self, 'find_spec'): |
| return None, [] |
| found = self.find_spec(fullname) |
| if found is not None: |
| if not found.submodule_search_locations: |
| portions = [] |
| else: |
| portions = found.submodule_search_locations |
| return found.loader, portions |
| else: |
| return None, [] |
| |
| find_module = _bootstrap._find_module_shim |
| |
| def invalidate_caches(self): |
| """An optional method for clearing the finder's cache, if any. |
| This method is used by PathFinder.invalidate_caches(). |
| """ |
| |
| _register(PathEntryFinder, machinery.FileFinder) |
| |
| |
| class Loader(metaclass=abc.ABCMeta): |
| |
| """Abstract base class for import loaders.""" |
| |
| def create_module(self, spec): |
| """Return a module to initialize and into which to load. |
| |
| This method should raise ImportError if anything prevents it |
| from creating a new module. It may return None to indicate |
| that the spec should create the new module. |
| |
| create_module() is optional. |
| |
| """ |
| # By default, defer to _SpecMethods.create() for the new module. |
| return None |
| |
| # We don't define exec_module() here since that would break |
| # hasattr checks we do to support backward compatibility. |
| |
| def load_module(self, fullname): |
| """Return the loaded module. |
| |
| The module must be added to sys.modules and have import-related |
| attributes set properly. The fullname is a str. |
| |
| ImportError is raised on failure. |
| |
| This method is deprecated in favor of loader.exec_module(). If |
| exec_module() exists then it is used to provide a backwards-compatible |
| functionality for this method. |
| |
| """ |
| if not hasattr(self, 'exec_module'): |
| raise ImportError |
| return _bootstrap._load_module_shim(self, fullname) |
| |
| 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 |
| |
| |
| class ResourceLoader(Loader): |
| |
| """Abstract base class for loaders which can return data from their |
| back-end storage. |
| |
| This ABC represents one of the optional protocols specified by PEP 302. |
| |
| """ |
| |
| @abc.abstractmethod |
| def get_data(self, path): |
| """Abstract method which when implemented should return the bytes for |
| the specified path. The path must be a str.""" |
| raise IOError |
| |
| |
| class InspectLoader(Loader): |
| |
| """Abstract base class for loaders which support inspection about the |
| modules they can load. |
| |
| This ABC represents one of the optional protocols specified by PEP 302. |
| |
| """ |
| |
| def is_package(self, fullname): |
| """Optional method which when implemented should return whether the |
| module is a package. The fullname is a str. Returns a bool. |
| |
| Raises ImportError if the module cannot be found. |
| """ |
| raise ImportError |
| |
| def get_code(self, fullname): |
| """Method which returns the code object for the module. |
| |
| The fullname is a str. Returns a types.CodeType if possible, else |
| returns None if a code object does not make sense |
| (e.g. built-in module). Raises ImportError if the module cannot be |
| found. |
| """ |
| source = self.get_source(fullname) |
| if source is None: |
| return None |
| return self.source_to_code(source) |
| |
| @abc.abstractmethod |
| def get_source(self, fullname): |
| """Abstract method which should return the source code for the |
| module. The fullname is a str. Returns a str. |
| |
| Raises ImportError if the module cannot be found. |
| """ |
| raise ImportError |
| |
| def source_to_code(self, data, path='<string>'): |
| """Compile 'data' into a code object. |
| |
| The 'data' argument can be anything that compile() can handle. The'path' |
| argument should be where the data was retrieved (when applicable).""" |
| return compile(data, path, 'exec', dont_inherit=True) |
| |
| exec_module = _bootstrap._LoaderBasics.exec_module |
| load_module = _bootstrap._LoaderBasics.load_module |
| |
| _register(InspectLoader, machinery.BuiltinImporter, machinery.FrozenImporter) |
| |
| |
| class ExecutionLoader(InspectLoader): |
| |
| """Abstract base class for loaders that wish to support the execution of |
| modules as scripts. |
| |
| This ABC represents one of the optional protocols specified in PEP 302. |
| |
| """ |
| |
| @abc.abstractmethod |
| def get_filename(self, fullname): |
| """Abstract method which should return the value that __file__ is to be |
| set to. |
| |
| Raises ImportError if the module cannot be found. |
| """ |
| raise ImportError |
| |
| def get_code(self, fullname): |
| """Method to return the code object for fullname. |
| |
| Should return None if not applicable (e.g. built-in module). |
| Raise ImportError if the module cannot be found. |
| """ |
| source = self.get_source(fullname) |
| if source is None: |
| return None |
| try: |
| path = self.get_filename(fullname) |
| except ImportError: |
| return self.source_to_code(source) |
| else: |
| return self.source_to_code(source, path) |
| |
| _register(ExecutionLoader, machinery.ExtensionFileLoader) |
| |
| |
| class FileLoader(_bootstrap.FileLoader, ResourceLoader, ExecutionLoader): |
| |
| """Abstract base class partially implementing the ResourceLoader and |
| ExecutionLoader ABCs.""" |
| |
| _register(FileLoader, machinery.SourceFileLoader, |
| machinery.SourcelessFileLoader) |
| |
| |
| class SourceLoader(_bootstrap.SourceLoader, ResourceLoader, ExecutionLoader): |
| |
| """Abstract base class for loading source code (and optionally any |
| corresponding bytecode). |
| |
| To support loading from source code, the abstractmethods inherited from |
| ResourceLoader and ExecutionLoader need to be implemented. To also support |
| loading from bytecode, the optional methods specified directly by this ABC |
| is required. |
| |
| Inherited abstractmethods not implemented in this ABC: |
| |
| * ResourceLoader.get_data |
| * ExecutionLoader.get_filename |
| |
| """ |
| |
| def path_mtime(self, path): |
| """Return the (int) modification time for the path (str).""" |
| if self.path_stats.__func__ is SourceLoader.path_stats: |
| raise IOError |
| return int(self.path_stats(path)['mtime']) |
| |
| def path_stats(self, path): |
| """Return a metadata dict for the source pointed to by the path (str). |
| Possible keys: |
| - 'mtime' (mandatory) is the numeric timestamp of last source |
| code modification; |
| - 'size' (optional) is the size in bytes of the source code. |
| """ |
| if self.path_mtime.__func__ is SourceLoader.path_mtime: |
| raise IOError |
| return {'mtime': self.path_mtime(path)} |
| |
| def set_data(self, path, data): |
| """Write the bytes to the path (if possible). |
| |
| Accepts a str path and data as bytes. |
| |
| Any needed intermediary directories are to be created. If for some |
| reason the file cannot be written because of permissions, fail |
| silently. |
| """ |
| |
| _register(SourceLoader, machinery.SourceFileLoader) |