Function wrapper

tensorboard/lazy.py:39–78

(load_fn)

    """

    def wrapper(load_fn):
        # Wrap load_fn to call it exactly once and update __dict__ afterwards to
        # make future lookups efficient (only failed lookups call __getattr__).
        @_memoize
        def load_once(self):
            if load_once.loading:
                raise ImportError(
                    "Circular import when resolving LazyModule %r" % name
                )
            load_once.loading = True
            try:
                module = load_fn()
            finally:
                load_once.loading = False
            self.__dict__.update(module.__dict__)
            load_once.loaded = True
            return module

        load_once.loading = False
        load_once.loaded = False

        # Define a module that proxies getattr() and dir() to the result of calling
        # load_once() the first time it's needed. The class is nested so we can close
        # over load_once() and avoid polluting the module's attrs with our own state.
        class LazyModule(types.ModuleType):
            def __getattr__(self, attr_name):
                return getattr(load_once(self), attr_name)

            def __dir__(self):
                return dir(load_once(self))

            def __repr__(self):
                if load_once.loaded:
                    return "<%r via LazyModule (loaded)>" % load_once(self)
                return (
                    "<module %r via LazyModule (not yet loaded)>"
                    % self.__name__
                )

        return LazyModule(name)

    return wrapper