code: def option(name: Union[any, List[any]], *args: any):
      r"""
      Use this as a decorator to register configuration options.
  
      This has multiple overloads
  
      .. function:: option(config_item: Union[any, List[any]])
          :noindex:
  
      .. function:: option(config_item: Union[any, List[any]], option_name: str)
          :noindex:
  
      .. function:: option(config_item: Union[any, List[any]], pass_params: List[any])
          :noindex:
  
      .. function:: option(config_item: Union[any, List[any]], option_name: str, pass_params: List[any])
          :noindex:
  
      Arguments:
          name: the configuration item or a list of items.
              If it is a list of items the function should return
              tuple.
  
          option_name (str, optional): name of the option.
              If not provided it will be derived from the
              function name.
  
          pass_params (list, optional): list of params to be passed.
              If not provided the configs object is passed.
              If provided the corresponding calculated configuration items
              will be passed to the function
      """
      config_class = _get_config_class(name)
      if config_class is None:
          raise ConfigsError("You need to pass config items to option")
  
      option_name = None
      pass_params = None
      for arg in args:
          if isinstance(arg, str):
              option_name = arg
          elif isinstance(arg, list):
              pass_params = arg
  
      return config_class.calc(name, option_name, pass_params)
  
file_path: labml/client/labml/configs.py
imports: from typing import List, Callable, overload, Union, Tuple
  from labml.internal.configs.base import Configs
  from labml.internal.configs.config_item import ConfigItem
  from labml.utils.errors import ConfigsError
label_desc: Use image node_id 6 for calling a global function with example usage: option(name) and returns: config_class