code: def lazy_function(module: str, name: str) -> Callable:
      """Create a lazy proxy for a function in a module.
  
      The module containing the function is not imported until the function is used.
  
      """
      func = None
  
      def _get_function():
          nonlocal func
          if func is None:
              func = getattr(import_module(module), name)
          return func
  
      # The metaclass is needed so that help() shows the docstring
      class LazyFunctionMeta(type):
          @property
          def __doc__(self):
              docstring = _get_function().__doc__
              docstring += f"\n\nNote: this is a {self.__class__.__name__} wrapper of '{module}.{name}'"
              return docstring
  
      class LazyFunction(metaclass=LazyFunctionMeta):
          def __call__(self, *args, **kwargs):
              # inline get of function for performance gh-23832
              nonlocal func
              if func is None:
                  func = getattr(import_module(module), name)
              return func(*args, **kwargs)
  
          @property
          def __doc__(self):
              docstring = _get_function().__doc__
              docstring += f"\n\nNote: this is a {self.__class__.__name__} wrapper of '{module}.{name}'"
              return docstring
  
          def __str__(self):
              return _get_function().__str__()
  
          def __repr__(self):
              return f"<{__class__.__name__} object at 0x{id(self):x}>: wrapping '{module}.{name}'"
  
      return LazyFunction()
  
file_path: sympy/sympy/core/cache.py
imports: from importlib import import_module
  from typing import Callable
  from functools import lru_cache, wraps
label_desc: Use image node_id 6 for calling a global function with example usage: lazy_function(module, name) and returns: LazyFunction, func, docstring, func, docstring, _get_function, str, __class__, str, id, str, module, str, name, str