Python中的惰性导入/懒导入/动态导入（Lazy Import）

　　参考资料：

　　https://cloud.tencent.com/developer/article/2204701

　　https://github.com/huggingface/diffusers

　　想研究这个lazy import的起因是：我想学习一下高级的算法工程师是如何构建一个pip包的，然后我发现在diffusers这个广泛使用的huggingface包的组织方式中出现了_LazyModule这个破东西。

　　查阅资料后知道，_LazyModule这个模块实际上对应了python中的一种lazy import的思想。也就是在整个包很大的情况下不再将所有的包都import，而仅仅在使用的时候进行真正的import。这么做可以极大地缩短整个的import时间。

　　OK，教练我想学这个，我也想让我的包摩登一把？我要怎么做？首先介绍几个点：

　　1. lazy import这个特性虽然python中已经有PEP做阐述，但是并没有官方的built-in包做支持

　　2. 如果我们想在自己的包中使用lazy import，完全可以借鉴别人已经实现好的类（diffusers，就决定是你了）

　　接下来我讲一下如何使用diffuers里面的lazy import代码让我我们的项目实现lazy import，项目组织如下：

　　重点在于两个地方：一个就是utils文件夹，这个文件夹里的import_utils.py包含了我们lazy import类的实现。另一个就是若干__init__.py文件，这些文件就讲我们lazy import的逻辑交代地很清楚。我们首先来看一看lazy import类的实现：

# Inspired by diffusers repo
# https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/import_utils.py
import os
import importlib.util
from itertools import chain
from types import ModuleType
from typing import Any


class _LazyModule(ModuleType):
    """
    Module class that surfaces all objects but only performs associated imports when the objects are requested.
    """

    # Very heavily inspired by optuna.integration._IntegrationModule
    # https://github.com/optuna/optuna/blob/master/optuna/integration/__init__.py
    def __init__(self, name, module_file, import_structure, module_spec=None, extra_objects=None):
        super().__init__(name)
        self._modules = set(import_structure.keys())
        self._class_to_module = {}
        for key, values in import_structure.items():
            for value in values:
                self._class_to_module[value] = key
        # Needed for autocompletion in an IDE
        self.__all__ = list(import_structure.keys()) + \
            list(chain(*import_structure.values()))
        self.__file__ = module_file
        self.__spec__ = module_spec
        self.__path__ = [os.path.dirname(module_file)]
        self._objects = {} if extra_objects is None else extra_objects
        self._name = name
        self._import_structure = import_structure

    # Needed for autocompletion in an IDE
    def __dir__(self):
        result = super().__dir__()
        # The elements of self.__all__ that are submodules may or may not be in the dir already, depending on whether
        # they have been accessed or not. So we only add the elements of self.__all__ that are not already in the dir.
        for attr in self.__all__:
            if attr not in result:
                result.append(attr)
        return result

    def __getattr__(self, name: str) -> Any:
        if name in self._objects:
            return self._objects[name]
        if name in self._modules:
            value = self._get_module(name)
        elif name in self._class_to_module.keys():
            module = self._get_module(self._class_to_module[name])
            value = getattr(module, name)
        else:
            raise AttributeError(
                f"module {self.__name__} has no attribute {name}")

        setattr(self, name, value)
        return value

    def _get_module(self, module_name: str):
        try:
            return importlib.import_module("." + module_name, self.__name__)
        except Exception as e:
            raise RuntimeError(
                f"Failed to import {self.__name__}.{module_name} because of the following error (look up to see its"
                f" traceback):\n{e}"
            ) from e

    def __reduce__(self):
        return (self.__class__, (self._name, self.__file__, self._import_structure))

　　这里不打算细讲，源码在https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/import_utils.py，我做了一些精简，读者可以直接copy，接下来讲用法：

　　我们首先看一下最高层的包是如何调用这个lazy import类的，也就是package_name下的__init__.py：

# Only support lazy import for now.
# TODO: support slow import
import sys
__version__ = "0.1"

from .utils import (
    _LazyModule
)

_import_structure = {
    "pipelines": []
}

_import_structure["pipelines"].extend(
    [
        "a",
        "LayoutDMPipeline"
    ]
)


sys.modules[__name__] = _LazyModule(
    __name__,
    globals()["__file__"],
    _import_structure,
    module_spec=__spec__,
    extra_objects={"__version__": __version__},
)

　　我们首先用了一个字典将我们想要导入的东西包起来，然后一起喂给_LazyModule，最后由_LazyModule传给sys.modules

　　这个包起来的东西包含了根目录的下级目录，extend的部分是我们最终想要导入的东西。流程是这样：

　　我们想要一个名为a的东西，那么packge就会去找下级目录找a，如果下级目录能够找到a，那么显然可以直接 from XX import a。但是问题出在下级目录显然也没有a，下级目录又要到下下级目录中去找，直至找到。我们不妨看看叶子的__init__.py

# Only support lazy import for now.
# TODO: support slow import

import sys
from ...utils import (
    _LazyModule
)

_import_structure = {}
_import_structure["bar"] = ["a"]


sys.modules[__name__] = _LazyModule(
    __name__,
    globals()["__file__"],
    _import_structure,
    module_spec=__spec__,
)

　　就是这样~

　　最后再顺一遍：我们通过from XX import a，python有如下操作

　　从XX中要a，XX再找pipelines要a，pipelines再找foo要a，foo再找bar要a，最终要到了a。

　　这么一来，from XX import a, from XX.pipelines import a, from XX.pipelines.foo import a, from XX.pipelines.foo.bar import a，全部都是可用的。