docs: def andeshelp(group=None,
                category=None,
                model_list=None,
                model_format=None,
                model_var=None,
                quick_help=None,
                help_option=None,
                help_config=None,
                export='plain',
                **kwargs):
      """
      Print the requested help and documentation to stdout.
  
      Parameters
      ----------
      group : None or str
          Name of a group whose model names will be printed
  
      category : None or str
          Name of a category whose models will be printed
  
      model_list : bool
          If ``True``, print the full model list.
  
      model_format : None or str
          Names of models whose parameter definitions will be printed. Model
          names are separated by comma without space.
  
      model_var : None or str
          A pair of model name and parameter name separated by dot. For
          example, ``Bus.voltage`` stands for the ``voltage`` parameter of
          ``Bus``.
  
      quick_help : None or str
          Name of a model to print a quick help of parameter definitions.
  
      help_option : None or str
          A pair of config name and option name separated by dot. For example,
          ``System.sparselib`` stands for the ``sparselib`` option of
          the ``System`` config.
  
      help_config : None or str
          Config names whose option definitions will be printed. Configs are
          separated by comma without space. For example, ``System,Pflow``. In
          the naming convention, the first letter is captialized.
  
      export : None or {'plain', 'latex'}
          Formatting style available in plain text or LaTex format. This option
          has not been implemented.
  
      kwargs : None or dict
          Other keyword arguments
  
      Returns
      -------
      bool
          True if any help function is executed.
  
      Notes
      -----
      The outputs can be written to a text file using shell command,
      for example, ::
  
          andes -q Bus > bus_help.txt
  
      """
      out = []
  
      if not (group or category or model_list or model_format
              or model_var or quick_help or help_option or help_config):
          return False
  
      from .models import all_models_list
  
      if category:
          raise NotImplementedError
  
      if model_list:
          raise NotImplementedError
  
      system = PowerSystem()
  
      if model_format:
          if model_format.lower() == 'all':
              model_format = all_models_list
          else:
              model_format = model_format.split(',')
  
          for item in model_format:
              if item not in all_models_list:
                  logger.warning('Model <{}> does not exist.'.format(item))
                  model_format.remove(item)
  
          if len(model_format) > 0:
              for item in model_format:
                  out.append(system.__dict__[item].doc(export=export))
  
      if model_var:
          model_var = model_var.split('.')
  
          if len(model_var) == 1:
              logger.error('Model and parameter not separated by dot.')
  
          elif len(model_var) > 2:
              logger.error('Model parameter not specified correctly.')
  
          else:
              dev, var = model_var
              if not hasattr(system, dev):
                  logger.error('Model <{}> does not exist.'.format(dev))
              else:
                  if var not in system.__dict__[dev]._data.keys():
                      logger.error(
                          'Model <{}> does not have parameter <{}>.'.format(
                              dev, var))
                  else:
                      c1 = system.__dict__[dev]._descr.get(var, 'no Description')
                      c2 = system.__dict__[dev]._data.get(var)
                      c3 = system.__dict__[dev]._units.get(var, 'no Unit')
                      out.append('{}: {}, default = {:g} {}'.format(
                          '.'.join(model_var), c1, c2, c3))
  
      if group:
          group_dict = {}
          match = []
  
          for model in all_models_list:
              g = system.__dict__[model]._group
              if g not in group_dict:
                  group_dict[g] = []
              group_dict[g].append(model)
  
          if group.lower() == 'all':
              match = sorted(list(group_dict.keys()))
  
          else:
              group = [group]
              # search for ``group`` in all group names and store in ``match``
              for item in group_dict.keys():
                  if group[0].lower() in item.lower():
                      match.append(item)
  
          # if group name not found
          if len(match) == 0:
              out.append('Group <{:s}> not found.'.format(group[0]))
  
          for item in match:
              group_models = sorted(list(group_dict[item]))
              out.append('<{:s}>'.format(item))
              out.append(', '.join(group_models))
              out.append('')
  
      if quick_help:
          if quick_help not in all_models_list:
              out.append('Model <{}> does not exist.'.format(quick_help))
          else:
              out.append(system.__dict__[quick_help].doc(export=export))
  
      if help_option:
          raise NotImplementedError
  
      if help_config:
  
          all_config = ['system', 'pflow', 'tds', 'eig']
  
          if help_config.lower() == 'all':
              help_config = all_config
  
          else:
              help_config = help_config.split(',')
  
              for item in help_config:
                  if item.lower() not in all_config:
                      logger.warning('Config <{}> does not exist.'.format(item))
                      help_config.remove(item)
  
          if len(help_config) > 0:
              for item in help_config:
                  if item == 'system':
                      out.append(system.config.doc(export=export))
                  else:
                      out.append(system.__dict__[item.lower()].config.doc(
                          export=export))
  
      print('\n'.join(out))  # NOQA
  
      return True