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