111

Python2.7 argparse only accepts optional arguments (prefixed) in mutually exclusive groups:

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

Is there a way to make argparse arguments behaves like traditional unix daemon control:

(start | stop | restart) and not (--start | --stop | --restart) ?
Improve this question

4 Answers 4

Reset to default
140

Use ArgumentParser.add_mutually_exclusive_group():

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()

output:

$ 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

version2

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
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

add_mutually_exclusive_group and add_argument_group is deprecated since python 3.11.
@radioxoma No. Calling add_mutually_exclusive_group and agg_argument_group on a mutually exclusive group is what it's deprecated. See the note here docs.python.org/3/library/argparse.html#mutual-exclusion
89

For all the abilities and options in argparse I don't think you'll ever get a "canned" usage string that looks like what you want.

That said, have you looked at sub-parsers since your original post?

Here's a barebones implementation:

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()

Running this with the -h option yields:

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

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

One of the benefits of this approach is being able to use set_defaults for each sub-parser to hook up a function directly to the argument. I've also added a "graceful" option for stop and 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)

Showing the "help" message for 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

Stopping "gracefully":

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

6 Comments

But you don't show how to determine which of the start stop or restart options were selected. When I try to view the repr of the arguments, none of the sub-parsers arguments are shown.
@RonaldoNascimento I think your question is answered here docs.python.org/3/library/… just scroll down a little and there is an example of how to solve this using set_defaults
@RonaldoNascimento late, but I think my edit answers your question. set_defaults() for my_stop() was always there, but was easily overlooked (even by me). It took Ronaldo’s comment to clue me in to your question. And I’m not sure what you’re doing with repr() that didn’t show what you expected.
what if want to use the arguments in conditional statements eg if args.stop: ( then do several actions ) ?
Well, can you do the several actions inside of a function, like my_stop? If not, you could set a bool, like args.stop = True inside of my_stop and then use that elsewhere. I tried that in this gist. That will error out if you never call stop; just a quick proof of concept. Comment on the gist if you'd like to discuss further.
Thanks , I figured out how to save the subparser selection in a variable and structure my conditional logic around it. if I used defaults and func,I would need a way to pass objects into the function. I didn’t see a way to do that .
45

It sounds like you want a positional argument instead of mutually exclusive options. You can use 'choices' to restrict the possible acceptable options.

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

This produces a usage line that looks like this:

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

5 Comments

Yeah, I saw that, but choices limits expresivity of usage. I'm just looking for some way to get rid of prefixes.
What do you mean "limits expresivity of usage"? Can the user run the script without supplying one of these?
When the user issue "mydaemon -h" the help (usage) is not so clear like using a help string for each argument.
@AdamWagner What if user passes more than one argument? e.g. foo.py start stop
@SantoshKumar in your example, 'stop' is not the first positional argument, so if only one argument is defined in my example above, it'll cause an error saying it does not recognize 'stop' (in the example you give). If you had defined a second positional argument, then 'start' would be the value for the first, and 'stop' would be the value for the second (whatever that happened to be).
16

Building on Adam's answer... if you wanted to specify a default you could always do the following so they can effectively leave it blank.

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())

which will print:

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
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.