¿Cómo formateo la ayuda del argumento posicional usando el optparse de Python?

Question

Como se menciona en los documentos el optparse.OptionParser utiliza un IndentedHelpFormatter para generar la ayuda de la opción formateada, para lo cual encontré algunos Documentación de la API .

Deseo mostrar un texto de ayuda con un formato similar para los argumentos posicionales requeridos en el texto de uso. ¿Hay un adaptador o un patrón de uso simple que pueda usarse para un formato de argumento posicional similar?

Aclaración

Preferiblemente solo usando stdlib. Optparse funciona muy bien, excepto por este matiz de formato, que creo que deberíamos poder solucionar sin importar otros paquetes completos. :-)

Answer 1

La mejor opción sería escribir un parche en el módulo optparse. Mientras tanto, puede lograr esto con una clase OptionParser ligeramente modificada. Esto no es perfecto, pero obtendrá lo que quieres hacer.

#!/usr/bin/env python
from optparse import OptionParser, Option, IndentedHelpFormatter

class PosOptionParser(OptionParser):
    def format_help(self, formatter=None):
        class Positional(object):
            def __init__(self, args):
                self.option_groups = []
                self.option_list = args

        positional = Positional(self.positional)
        formatter = IndentedHelpFormatter()
        formatter.store_option_strings(positional)
        output = ['\n', formatter.format_heading("Positional Arguments")]
        formatter.indent()
        pos_help = [formatter.format_option(opt) for opt in self.positional]
        pos_help = [line.replace('--','') for line in pos_help]
        output += pos_help
        return OptionParser.format_help(self, formatter) + ''.join(output)

    def add_positional_argument(self, option):
        try:
            args = self.positional
        except AttributeError:
            args = []
        args.append(option)
        self.positional = args

    def set_out(self, out):
        self.out = out
def main():
    usage = "usage: %prog [options] bar baz"
    parser = PosOptionParser(usage)
    parser.add_option('-f', '--foo', dest='foo',
                      help='Enable foo')
    parser.add_positional_argument(Option('--bar', action='store_true',
                                   help='The bar positional argument'))
    parser.add_positional_argument(Option('--baz', action='store_true',
                                   help='The baz positional argument'))
    (options, args) = parser.parse_args()
    if len(args) != 2:
        parser.error("incorrect number of arguments")
    pass

if __name__ == '__main__':
    main()

Y el resultado que obtienes al ejecutar esto:

Usage: test.py [options] bar baz

  Options:
    -h, --help         show this help message and exit
    -f FOO, --foo=FOO  Enable foo

Positional Arguments:
  bar  The bar positional argument
  baz  The baz positional argument

Answer 2

Intente echar un vistazo a argparse . La documentación dice que admite argumentos de posición y mensajes de ayuda más bonitos.

Answer 3

Me interesaría una solución limpia para esto; No pude encontrar uno. OptionParser realmente se centra por completo en las opciones; no le da nada para trabajar con argumentos de posición, por lo que he podido encontrar.

Lo que hice fue generar una lista de pequeños bloques de documentación para cada uno de mis argumentos posicionales, usando \ t s para obtener el espacio correcto. Luego los uní con nuevas líneas y las agregué a la cadena de 'uso' que se pasa al OptionParser.

Se ve bien, pero se siente tonto, y por supuesto esa documentación termina apareciendo sobre la lista de opciones. No he encontrado ninguna forma de evitar eso, o cómo hacer cosas complejas, es decir, un conjunto dado de opciones se describe debajo de la descripción de un argumento posicional, porque solo se aplican a ese argumento.

Miré los métodos de OptionParser para parchar monos y recuerdo (esto fue hace un año más o menos) que no habría sido tan difícil, pero no quería seguir ese camino.

Answer 4

La mayoría del texto de ayuda para argumentos posicionales se asemeja al formato que se usa con frecuencia en las páginas man para los cuadros * NIX. Eche un vistazo a cómo se documenta el comando 'cp' . Su texto de ayuda debería parecerse a eso.

De lo contrario, siempre que complete la "ayuda" argumento al usar el analizador, la documentación debe producirse sola.