1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

# 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))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 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__},
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 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__,
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# Code copied from https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/util/lazy_loader.py
"""A LazyLoader class."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import importlib
import types
class LazyLoader(types.ModuleType):
  """Lazily import a module, mainly to avoid pulling in large dependencies.

  `contrib`, and `ffmpeg` are examples of modules that are large and not always
  needed, and this allows them to only be loaded when they are used.
  """
  # The lint error here is incorrect.
  def __init__(self, local_name, parent_module_globals, name):  # pylint: disable=super-on-old-class
    self._local_name = local_name
    self._parent_module_globals = parent_module_globals
    super(LazyLoader, self).__init__(name)
  def _load(self):
    # Import the target module and insert it into the parent's namespace
    module = importlib.import_module(self.__name__)
    self._parent_module_globals[self._local_name] = module
    # Update this object's dict so that if someone keeps a reference to the
    #   LazyLoader, lookups are efficient (__getattr__ is only called on lookups
    #   that fail).
    self.__dict__.update(module.__dict__)
    return module
  def __getattr__(self, item):
    module = self._load()
    return getattr(module, item)
  def __dir__(self):
    module = self._load()
    return dir(module)

1

import tensorflow.contrib as contrib1.

1

contrib = LazyLoader('contrib', globals(), 'tensorflow.contrib')

1
2
3
4
5
6

import importlib
def lazy_import(module_name):
    return importlib.import_module(module_name)
# 当需要使用时才导入模块
numpy = lazy_import('numpy')
array = numpy.array([1, 2, 3])

1
2
3
4
5

def lazy_import(module_name):
    return __import__(module_name)
# 当需要使用时才导入模块
numpy = lazy_import('numpy')
array = numpy.array([1, 2, 3])

1
2
3

numpy = lambda: __import__('numpy')
# 当需要使用时才执行导入
array = numpy().array([1, 2, 3])

1
2
3
4
5
6
7
8
9
10

def lazy_import(module_name):
    def wrapper():
        globals()[module_name] = __import__(module_name)
        return globals()[module_name]
    return wrapper
@lazy_import('numpy')
def numpy_function():
    return numpy.array([1, 2, 3])
# 当需要使用时才执行导入和函数调用
result = numpy_function()

1
2
3

.
├── a.py
└── impt.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import sys
import importlib
from importlib.util import LazyLoader
for i, mp in enumerate(sys.meta_path):
    if str(mp) == "<class '_frozen_importlib_external.PathFinder'>":
        index = i
        path_finder = mp
        continue
class LazyPathFinder(object):
        def find_spec(self, fullname, path, target=None):
        spec = path_finder.find_spec(fullname, path, target=target)
        if spec is not None:
            spec.loader = LazyLoader(spec.loader)
        return spec
sys.meta_path[index] = LazyPathFinder()
import os
import a
print('a lazy imported')
print(a.b)

1
2
3

print('exec a.py')
b = 2

1
2
3
4

$ python impt.py 
a lazy imported
exec a.py
2