code: def verbose(function: _FuncT) -> _FuncT:
      """Verbose decorator to allow functions to override log-level.
  
      Parameters
      ----------
      function : callable
          Function to be decorated by setting the verbosity level.
  
      Returns
      -------
      dec : callable
          The decorated function.
  
      See Also
      --------
      set_log_level
      set_config
  
      Notes
      -----
      This decorator is used to set the verbose level during a function or method
      call, such as :func:`mne.compute_covariance`. The `verbose` keyword
      argument can be 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', True (an
      alias for 'INFO'), or False (an alias for 'WARNING'). To set the global
      verbosity level for all functions, use :func:`mne.set_log_level`.
  
      This function also serves as a docstring filler.
  
      Examples
      --------
      You can use the ``verbose`` argument to set the verbose level on the fly::
  
          >>> import mne
          >>> cov = mne.compute_raw_covariance(raw, verbose='WARNING')  # doctest: +SKIP
          >>> cov = mne.compute_raw_covariance(raw, verbose='INFO')  # doctest: +SKIP
          Using up to 49 segments
          Number of samples used : 5880
          [done]
      """  # noqa: E501
      # See https://decorator.readthedocs.io/en/latest/tests.documentation.html
      # #dealing-with-third-party-decorators
      try:
          fill_doc(function)
      except TypeError:  # nothing to add
          pass
  
      # Anything using verbose should have `verbose=None` in the signature.
      # This code path will raise an error if this is not the case.
      body = """\
  def %(name)s(%(signature)s):\n
      try:
          do_level_change = verbose is not None
      except (NameError, UnboundLocalError):
          raise RuntimeError('Function/method %%s does not accept verbose '
                             'parameter' %% (_function_,)) from None
      if do_level_change:
          with _use_log_level_(verbose):
              return _function_(%(shortsignature)s)
      else:
          return _function_(%(shortsignature)s)"""
      evaldict = dict(
          _use_log_level_=use_log_level, _function_=function
      )
      fm = FunctionMaker(function)
      attrs = dict(
          __wrapped__=function,
          __qualname__=function.__qualname__,
          __globals__=function.__globals__,
      )
      return fm.make(body, evaldict, addsource=True, **attrs)
  
imports: import contextlib
  import importlib
  import inspect
  import logging
  import os.path
  import re
  import sys
  import warnings
  from io import StringIO
  from typing import Any, Callable, TypeVar
  from decorator import FunctionMaker
  from .docs import fill_doc
label_desc: Use image node_id 1 for calling a global function with example usage: verbose(function) and returns: fm