code: def option(
      *param_decls: str,
      cls: t.Optional[t.Type[Option]] = None,
      **attrs: t.Any,
  ) -> t.Callable[[FC], FC]:
      """Attaches an option to the command.  All positional arguments are
      passed as parameter declarations to :class:`Option`; all keyword
      arguments are forwarded unchanged (except ``cls``).
      This is equivalent to creating an :class:`Option` instance manually
      and attaching it to the :attr:`Command.params` list.
  
      For the default option class, refer to :class:`Option` and
      :class:`Parameter` for descriptions of parameters.
  
      :param cls: the option class to instantiate.  This defaults to
                  :class:`Option`.
      :param param_decls: Passed as positional arguments to the constructor of
          ``cls``.
      :param attrs: Passed as keyword arguments to the constructor of ``cls``.
      """
      if cls is None:
          cls = Option
  
      def decorator(f: FC) -> FC:
          _param_memo(f, cls(param_decls, **attrs))
          return f
  
      return decorator
  
imports: import inspect
  import types
  import typing
  from functools import update_wrapper
  from gettext import gettext
  from .core import Argument
  from .core import Command
  from .core import Context
  from .core import Group
  from .core import Option
  from .core import Parameter
  from .globals import get_current_context
  from .utils import echo
label_desc: Use image node_id 17 for calling a global function with example usage: option() and returns: decorator, f