parser - ¿Cómo hacer que python argparse argumentos de grupo mutuamente excluyentes sin prefijo?

arguments parser python

Question

Python2.7 argparse solo acepta argumentos opcionales (prefijados) en grupos mutuamente excluyentes:

parser = argparse.ArgumentParser(prog=''mydaemon'')
action = parser.add_mutually_exclusive_group(required=True)
action.add_argument(''--start'', action=''store_true'', help=''Starts %(prog)s daemon'')
action.add_argument(''--stop'', action=''store_true'', help=''Stops %(prog)s daemon'')
action.add_argument(''--restart'', action=''store_true'', help=''Restarts %(prog)s daemon'')

$ mydaemon -h

usage: mydaemon [-h] (--start | --stop | --restart)

optional arguments:
  -h, --help  show this help message and exit
  --start     Starts mydaemon daemon
  --stop      Stops mydaemon daemon
  --restart   Restarts mydaemon daemon

¿Hay alguna manera de hacer que los argumentos argparse se comporten como el control daemon unix tradicional?

(start | stop | restart) and not (--start | --stop | --restart) ?

Answer 1

Basándose en la respuesta de Adam ... si quisiera especificar un valor por defecto, siempre podría hacer lo siguiente para dejarlo en blanco.

import argparse

ActionHelp = """
    Start = Starts the daemon (default)
    Stop = Stops the daemon
    Restart = Restarts the daemon
    """
parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)

parser.add_argument(''action'', nargs = ''?'', choices=(''start'', ''stop'', ''restart''),
    default = ''start'', help = ActionHelp)

print parser.parse_args(''''.split())
print
print parser.parse_args(''-h''.split())

que se imprimirá:

Namespace(action=''start'')

usage: program.py [-h] [{start,stop,restart}]

postional arguments:
    {start,stop,restart}
                      Start = Starts the daemon (default)
                      Stop = Stops the daemon
                      Restart = Restarts the daemon

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

Answer 2

Para todas las habilidades y opciones en argparse no creo que alguna vez obtengas una cadena de uso "enlatado" que se parece a lo que quieres.

Dicho esto, ¿has mirado los sub-analizadores desde tu publicación original?

Aquí hay una implementación de barebones:

import argparse

parser = argparse.ArgumentParser(prog=''mydaemon'')
sp = parser.add_subparsers()
sp_start = sp.add_parser(''start'', help=''Starts %(prog)s daemon'')
sp_stop = sp.add_parser(''stop'', help=''Stops %(prog)s daemon'')
sp_restart = sp.add_parser(''restart'', help=''Restarts %(prog)s daemon'')

parser.parse_args()

Ejecutar esto con la opción -h produce:

usage: mydaemon [-h] {start,stop,restart} ...

positional arguments:
  {start,stop,restart}
    start               Starts mydaemon daemon
    stop                Stops mydaemon daemon
    restart             Restarts mydaemon daemon

Uno de los beneficios de este enfoque es poder usar set_defaults para cada sub-analizador para conectar una función directamente al argumento. También agregué una opción "agraciada" para stop y restart :

import argparse

def my_stop(args):
    if args.gracefully:
        print "Let''s try to stop..."
    else:
        print ''Stop, now!''

parser = argparse.ArgumentParser(prog=''mydaemon'')

graceful = argparse.ArgumentParser(add_help=False)
graceful.add_argument(''-g'', ''--gracefully'', action=''store_true'', help=''tries to terminate the process gracefully'')
sp = parser.add_subparsers()
sp_start = sp.add_parser(''start'', help=''Starts %(prog)s daemon'')
sp_stop = sp.add_parser(''stop'', parents=[graceful],
                    description=''Stops the daemon if it is currently running.'',
                    help=''Stops %(prog)s daemon'')
sp_restart = sp.add_parser(''restart'', parents=[graceful], help=''Restarts %(prog)s daemon'')

# Hook subparsers up to functions
sp_stop.set_defaults(func=my_stop)

# Uncomment when my_start() and 
# my_restart() are implemented
#
# sp_start.set_defaults(func=my_start)
# sp_restart.set_defaults(func=my_restart)

args = parser.parse_args()
args.func(args)

Mostrando el mensaje de "ayuda" para stop :

$ python mydaemon.py stop -h
usage: mydaemon stop [-h] [-g]

Stops the daemon if it is currently running.

optional arguments:
  -h, --help        show this help message and exit
  -g, --gracefully  tries to terminate the process gracefully

Detener "con gracia":

$ python mydaemon.py stop -g
Let''s try to stop...

Answer 3

Parece que quieres un argumento posicional en lugar de opciones mutuamente excluyentes. Puede usar ''elecciones'' para restringir las posibles opciones aceptables.

parser = ArgumentParser()
parser.add_argument(''action'', choices=(''start'', ''stop'', ''restart''))

Esto produce una línea de uso que se ve así:

usage: foo.py [-h] {start,stop,restart}

Answer 4

de pymotw

import argparse

parser = argparse.ArgumentParser()

group = parser.add_mutually_exclusive_group()
group.add_argument(''-a'', action=''store_true'')
group.add_argument(''-b'', action=''store_true'')

print parser.parse_args()

salida:

$ python argparse_mutually_exclusive.py -h  
usage: argparse_mutually_exclusive.py [-h] [-a | -b]

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

$ python argparse_mutually_exclusive.py -a  
Namespace(a=True, b=False)

$ python argparse_mutually_exclusive.py -b  
Namespace(a=False, b=True)

$ python argparse_mutually_exclusive.py -a -b  
usage: argparse_mutually_exclusive.py [-h] [-a | -b]  
argparse_mutually_exclusive.py: error: argument -b: not allowed with argument -a

versión 2

import argparse

parser = argparse.ArgumentParser()

subparsers = parser.add_subparsers(help=''commands'')

# A list command
list_parser = subparsers.add_parser(''list'', help=''List contents'')
list_parser.add_argument(''dirname'', action=''store'', help=''Directory to list'')

# A create command
create_parser = subparsers.add_parser(''create'', help=''Create a directory'')
create_parser.add_argument(''dirname'', action=''store'', help=''New directory to create'')
create_parser.add_argument(''--read-only'', default=False, action=''store_true'',
                       help=''Set permissions to prevent writing to the directory'',
                       )

# A delete command
delete_parser = subparsers.add_parser(''delete'', help=''Remove a directory'')
delete_parser.add_argument(''dirname'', action=''store'', help=''The directory to remove'')
delete_parser.add_argument(''--recursive'', ''-r'', default=False, action=''store_true'',
                       help=''Remove the contents of the directory, too'',
                       )

print parser.parse_args([''list'', ''a s d'', ])
>>> Namespace(dirname=''a s d'')
print parser.parse_args([''list'', ''a s d'', ''create'' ])
>>> error: unrecognized arguments: create