pasar - que es argv en python

¿Cómo formateo la ayuda de los argumentos posicionales usando el optparse de Python?

Question

Como se mencionó en los documentos, el optparse.OptionParser utiliza un IndentedHelpFormatter para generar la ayuda de la opción formateada, para la cual encontré algo de documentación de API .

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

Aclaración

Preferiblemente solo utilizando el estándar. Optparse hace un gran trabajo a excepción de este matiz de formato, que creo que deberíamos poder solucionar sin importar otros paquetes. :-)

Answer 1

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

Answer 2

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

De lo contrario, siempre y cuando llene el argumento "ayuda" mientras usa el analizador, la documentación debería producirse por sí misma.

Answer 3

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 logrará 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 la salida 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 4

Me interesaría una solución limpia a esto; No pude encontrar uno. El OptionParser realmente se centra completamente en las opciones; no te 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 me uní a ellos con nuevas líneas, y adjunté eso a la cadena de ''uso'' que se pasa al OptionParser.

Se ve bien, pero se siente tonto, y por supuesto que la documentación termina apareciendo encima de la lista de opciones. No he encontrado ninguna manera de evitar eso, o cómo hacer cualquier cosa compleja, es decir, un conjunto dado de opciones se describe debajo de la descripción para un argumento posicional, porque solo se aplican a ese argumento.

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