lazy.py

import builtins
from contextlib import contextmanager

real_import = builtins.__import__

is_lazy = False

@contextmanager
def lazy():
    global is_lazy
    is_lazy = True
    try:
        yield
    finally:
        is_lazy = False


def _resolve(proxy):
    obj = real_import(*proxy.args)
    proxy.args[1][proxy.args[0]] = obj
    return obj


class Proxy:
    def __init__(self, args):
        self.args = args

    def __getattr__(self, attr):
        return getattr(_resolve(self), attr)

    def __call__(self, *args, **kwargs):
        return _resolve(self)(*args, **kwargs)


class SpecialKey:
    def __init__(self, key, proxy) -> None:
        self.key = key
        self.proxy = proxy
        self.counter = 0

    def __eq__(self, value: object) -> bool:
        if not isinstance(value, str):
            return NotImplemented
        if value != self.key:
            return False
        self.counter += 1
        if self.counter == 2:
            _resolve(self.proxy)
        return True

    def __hash__(self) -> int:
        return hash(self.key)


def new_import(name, globals, locals, fromlist, level):
    if is_lazy:
        proxy = Proxy((name, globals, locals, fromlist, level))
        globals[SpecialKey(name, proxy)] = proxy
        return proxy
    else:
        return real_import(name, globals, locals, fromlist, level)

builtins.__import__ = new_import

use.py

from lazy import lazy

with lazy():
    import os

print(os)  # <module 'os' (frozen)>
print(os.path)  # <module 'posixpath' (frozen)>
print(os)  # <module 'os' (frozen)>