In Python, using argparse, allow only positive integers

Question

The title pretty much summarizes what I'd like to have happen.

Here is what I have, and while the program doesn't blow up on a nonpositive integer, I want the user to be informed that a nonpositive integer is basically nonsense.

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-g", "--games", type=int, default=162,
                    help="The number of games to simulate")
args = parser.parse_args()

And the output:

python simulate_many.py -g 20
Setting up...
Playing games...
....................

Output with a negative:

python simulate_many.py -g -2
Setting up...
Playing games...

Now, obviously I could just add an if to determine if args.games is negative, but I was curious if there was a way to trap it at the argparse level, so as to take advantage of the automatic usage printing.

Ideally, it would print something similar to this:

python simulate_many.py -g a
usage: simulate_many.py [-h] [-g GAMES] [-d] [-l LEAGUE]
simulate_many.py: error: argument -g/--games: invalid int value: 'a'

Like so:

python simulate_many.py -g -2
usage: simulate_many.py [-h] [-g GAMES] [-d] [-l LEAGUE]
simulate_many.py: error: argument -g/--games: invalid positive int value: '-2'

For now I'm doing this, and I guess I'm happy:

if args.games <= 0:
    parser.print_help()
    print "-g/--games: must be positive."
    sys.exit(1)

Answer 1

This should be possible utilizing type. You'll still need to define an actual method that decides this for you:

def check_positive(value):
    ivalue = int(value)
    if ivalue <= 0:
        raise argparse.ArgumentTypeError("%s is an invalid positive int value" % value)
    return ivalue

parser = argparse.ArgumentParser(...)
parser.add_argument('foo', type=check_positive)

This is basically just an adapted example from the perfect_square function in the docs on argparse.

Answer 2

type would be the recommended option to handle conditions/checks, as in Yuushi's answer.

In your specific case, you can also use the choices parameter if your upper limit is also known:

parser.add_argument('foo', type=int, choices=xrange(5, 10))

Answer 3

The quick and dirty way, if you have a predictable max as well as min for your arg, is use choices with a range

parser.add_argument('foo', type=int, choices=xrange(0, 1000))

Answer 4

A simpler alternative, especially if subclassing argparse.ArgumentParser, is to initiate the validation from inside the parse_args method.

Inside such a subclass:

def parse_args(self, args=None, namespace=None):
    """Parse and validate args."""
    namespace = super().parse_args(args, namespace)  # super() works in Python 3
    if namespace.games <= 0:
         raise self.error('The number of games must be a positive integer.')
    return namespace

This technique may not be as cool as a custom callable, but it does the job.

---

About ArgumentParser.error(message):

This method prints a usage message including the message to the standard error and terminates the program with a status code of 2.

---

Credit: answer by jonatan