He estado usando argparsepara un programa de Python que puede -process, -uploado ambos:

parser = argparse.ArgumentParser(description='Log archiver arguments.')
parser.add_argument('-process', action='store_true')
parser.add_argument('-upload',  action='store_true')
args = parser.parse_args()

El programa no tiene sentido sin al menos un parámetro. ¿Cómo puedo configurar argparsepara forzar la elección de al menos un parámetro?

ACTUALIZAR:

Siguiendo los comentarios: ¿Cuál es la forma Pythonic de parametrizar un programa con al menos una opción?

if not (args.process or args.upload):
    parser.error('No action requested, add -process or -upload')

args = vars(parser.parse_args())
if not any(args.values()):
    parser.error('No arguments provided.')

Si no es la parte 'o ambas' (inicialmente me perdí esto), podría usar algo como esto:

parser = argparse.ArgumentParser(description='Log archiver arguments.')
parser.add_argument('--process', action='store_const', const='process', dest='mode')
parser.add_argument('--upload',  action='store_const', const='upload', dest='mode')
args = parser.parse_args()
if not args.mode:
    parser.error("One of --process or --upload must be given")

Sin embargo, probablemente sería una mejor idea usar subcomandos en su lugar.

Sé que esto es viejo como la suciedad, pero la forma de requerir una opción pero prohibir más de una (XOR) es así:

parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('-process', action='store_true')
group.add_argument('-upload',  action='store_true')
args = parser.parse_args()
print args

Salida:

>opt.py  
usage: multiplot.py [-h] (-process | -upload)  
multiplot.py: error: one of the arguments -process -upload is required  

>opt.py -upload  
Namespace(process=False, upload=True)  

>opt.py -process  
Namespace(process=True, upload=False)  

>opt.py -upload -process  
usage: multiplot.py [-h] (-process | -upload)  
multiplot.py: error: argument -process: not allowed with argument -upload  

Revisión de requisitos

• usar argparse(ignoraré este)
• permitir que se invoquen una o dos acciones (se requiere al menos una).
• intentar por Pythonic (prefiero llamarlo "POSIX" -como)

También hay algunos requisitos implícitos cuando se vive en la línea de comandos:

• explicar el uso al usuario de una manera que sea fácil de entender
• las opciones serán opcionales
• permitir especificar banderas y opciones
• permiten combinar con otros parámetros (como nombre de archivo o nombres).

Solución de muestra usando docopt(archivo managelog.py):

"""Manage logfiles
Usage:
    managelog.py [options] process -- <logfile>...
    managelog.py [options] upload -- <logfile>...
    managelog.py [options] process upload -- <logfile>...
    managelog.py -h

Options:
    -V, --verbose      Be verbose
    -U, --user <user>  Username
    -P, --pswd <pswd>  Password

Manage log file by processing and/or uploading it.
If upload requires authentication, you shall specify <user> and <password>
"""
if __name__ == "__main__":
    from docopt import docopt
    args = docopt(__doc__)
    print args

Intenta ejecutarlo:

$ python managelog.py
Usage:
    managelog.py [options] process -- <logfile>...
    managelog.py [options] upload -- <logfile>...
    managelog.py [options] process upload -- <logfile>...
    managelog.py -h

Muestre la ayuda:

$ python managelog.py -h
Manage logfiles
Usage:
    managelog.py [options] process -- <logfile>...
    managelog.py [options] upload -- <logfile>...
    managelog.py [options] process upload -- <logfile>...
    managelog.py -h

Options:
    -V, --verbose      Be verbose
    -U, --user <user>  Username
    -P, --pswd <pswd>  P    managelog.py [options] upload -- <logfile>...

Manage log file by processing and/or uploading it.
If upload requires authentication, you shall specify <user> and <password>

Y úsalo:

$ python managelog.py -V -U user -P secret upload -- alfa.log beta.log
{'--': True,
 '--pswd': 'secret',
 '--user': 'user',
 '--verbose': True,
 '-h': False,
 '<logfile>': ['alfa.log', 'beta.log'],
 'process': False,
 'upload': True}

Alternativa corta short.py

Puede haber una variante incluso más corta:

"""Manage logfiles
Usage:
    short.py [options] (process|upload)... -- <logfile>...
    short.py -h

Options:
    -V, --verbose      Be verbose
    -U, --user <user>  Username
    -P, --pswd <pswd>  Password

Manage log file by processing and/or uploading it.
If upload requires authentication, you shall specify <user> and <password>
"""
if __name__ == "__main__":
    from docopt import docopt
    args = docopt(__doc__)
    print args

El uso se ve así:

$ python short.py -V process upload  -- alfa.log beta.log
{'--': True,
 '--pswd': None,
 '--user': None,
 '--verbose': True,
 '-h': False,
 '<logfile>': ['alfa.log', 'beta.log'],
 'process': 1,
 'upload': 1}

Tenga en cuenta que, en lugar de valores booleanos para las claves de "proceso" y "carga", hay contadores.

Resulta que no podemos evitar la duplicación de estas palabras:

$ python short.py -V process process upload  -- alfa.log beta.log
{'--': True,
 '--pswd': None,
 '--user': None,
 '--verbose': True,
 '-h': False,
 '<logfile>': ['alfa.log', 'beta.log'],
 'process': 2,
 'upload': 1}

Conclusiones

En ocasiones, diseñar una buena interfaz de línea de comandos puede ser un desafío.

Hay varios aspectos del programa basado en la línea de comandos:

• buen diseño de línea de comando
• seleccionar / usar el analizador adecuado

argparse ofrece mucho, pero restringe los posibles escenarios y puede volverse muy complejo.

Con las docoptcosas van mucho más cortas conservando la legibilidad y ofreciendo un alto grado de flexibilidad. Si logra obtener argumentos analizados del diccionario y realiza algunas conversiones (a números enteros, abrir archivos ...) manualmente (o mediante otra biblioteca llamada schema), puede encontrar una docoptbuena opción para el análisis de línea de comandos.

Si necesita que un programa de Python se ejecute con al menos un parámetro, agregue un argumento que no tenga el prefijo de opción (- o - por defecto) y establezcanargs=+ (Se requiere un mínimo de un argumento). El problema que encontré con este método es que si no especificas el argumento, argparse generará un error de "muy pocos argumentos" y no imprimirá el menú de ayuda. Si no necesita esa funcionalidad, aquí se explica cómo hacerlo en el código:

import argparse

parser = argparse.ArgumentParser(description='Your program description')
parser.add_argument('command', nargs="+", help='describe what a command is')
args = parser.parse_args()

Yo creo que cuando se agrega una discusión con los prefijos de opción, nargs gobierna todo el analizador argumento y no sólo la opción. (Lo que quiero decir es que, si tiene una --optionbandera con nargs="+", la --optionbandera espera al menos un argumento. Si tiene optioncon nargs="+", espera al menos un argumento en general).

Para http://bugs.python.org/issue11588 , estoy explorando formas de generalizar el mutually_exclusive_groupconcepto para manejar casos como este.

Con este desarrollo argparse.py, https://github.com/hpaulj/argparse_issues/blob/nested/argparse.py puedo escribir:

parser = argparse.ArgumentParser(prog='PROG', 
    description='Log archiver arguments.')
group = parser.add_usage_group(kind='any', required=True,
    title='possible actions (at least one is required)')
group.add_argument('-p', '--process', action='store_true')
group.add_argument('-u', '--upload',  action='store_true')
args = parser.parse_args()
print(args)

que produce lo siguiente help:

usage: PROG [-h] (-p | -u)

Log archiver arguments.

optional arguments:
  -h, --help     show this help message and exit

possible actions (at least one is required):
  -p, --process
  -u, --upload

Esto acepta entradas como '-u', '-up', '--proc --up', etc.

Termina ejecutando una prueba similar a https://stackoverflow.com/a/6723066/901925 , aunque el mensaje de error debe ser más claro:

usage: PROG [-h] (-p | -u)
PROG: error: some of the arguments process upload is required

Me pregunto:

• ¿Son los parámetros lo kind='any', required=Truesuficientemente claros (acepte cualquiera del grupo; se requiere al menos uno)?

• ¿Está (-p | -u)claro el uso ? Un grupo mutually_exclusive_group requerido produce lo mismo. ¿Existe alguna notación alternativa?

• ¿Usar un grupo como este es más intuitivo que una phihag'ssimple prueba?

La mejor manera de hacer esto es usando el módulo incorporado de Python add_mutually_exclusive_group .

parser = argparse.ArgumentParser(description='Log archiver arguments.')
group = parser.add_mutually_exclusive_group()
group.add_argument('-process', action='store_true')
group.add_argument('-upload',  action='store_true')
args = parser.parse_args()

Si desea que solo se seleccione un argumento mediante la línea de comando, use required = True como argumento para el grupo

group = parser.add_mutually_exclusive_group(required=True)

¿Quizás usar sub-analizadores?

import argparse

parser = argparse.ArgumentParser(description='Log archiver arguments.')
subparsers = parser.add_subparsers(dest='subparser_name', help='sub-command help')
parser_process = subparsers.add_parser('process', help='Process logs')
parser_upload = subparsers.add_parser('upload', help='Upload logs')
args = parser.parse_args()

print("Subparser: ", args.subparser_name)

Ahora --helpmuestra:

$ python /tmp/aaa.py --help
usage: aaa.py [-h] {process,upload} ...

Log archiver arguments.

positional arguments:
  {process,upload}  sub-command help
    process         Process logs
    upload          Upload logs

optional arguments:
  -h, --help        show this help message and exit
$ python /tmp/aaa.py
usage: aaa.py [-h] {process,upload} ...
aaa.py: error: too few arguments
$ python3 /tmp/aaa.py upload
Subparser:  upload

También puede agregar opciones adicionales a estos sub-analizadores. Además, en lugar de usar eso dest='subparser_name', también puede vincular funciones para que se invoquen directamente en un subcomando dado (ver documentos).

Esto logra el propósito y esto también se verá afectado en la --helpsalida autogenerada de argparse , que es en mi humilde opinión lo que quieren la mayoría de los programadores cuerdos (también funciona con argumentos opcionales):

parser.add_argument(
    'commands',
    nargs='+',                      # require at least 1
    choices=['process', 'upload'],  # restrict the choice
    help='commands to execute'
)

Documentos oficiales sobre esto: https://docs.python.org/3/library/argparse.html#choices

Use append_const para una lista de acciones y luego verifique que la lista esté completa:

parser.add_argument('-process', dest=actions, const="process", action='append_const')
parser.add_argument('-upload',  dest=actions, const="upload", action='append_const')

args = parser.parse_args()

if(args.actions == None):
    parser.error('Error: No actions requested')

Incluso puede especificar los métodos directamente dentro de las constantes.

def upload:
    ...

parser.add_argument('-upload',  dest=actions, const=upload, action='append_const')
args = parser.parse_args()

if(args.actions == None):
    parser.error('Error: No actions requested')

else:
    for action in args.actions:
        action()