In Python, using argparse, allow only positive integers


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 -g 20
Setting up...
Playing games...

Output with a negative:

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

Now, obviously I could just add an if to determine if 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 -g a
usage: [-h] [-g GAMES] [-d] [-l LEAGUE] error: argument -g/--games: invalid int value: 'a'

Like so:

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

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

if <= 0:
    print "-g/--games: must be positive."
Asked By: jgritty



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.

Answered By: Yuushi

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))
Answered By: ben author

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

Note: Use range instead of xrange for python 3.x

Answered By: aneroid

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)
    if <= 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

Answered By: Asclepius

In case someone (like me) comes across this question in a Google search, here is an example of how to use a modular approach to neatly solve the more general problem of allowing argparse integers only in a specified range:

# Custom argparse type representing a bounded int
class IntRange:

    def __init__(self, imin=None, imax=None):
        self.imin = imin
        self.imax = imax

    def __call__(self, arg):
            value = int(arg)
        except ValueError:
            raise self.exception()
        if (self.imin is not None and value < self.imin) or (self.imax is not None and value > self.imax):
            raise self.exception()
        return value

    def exception(self):
        if self.imin is not None and self.imax is not None:
            return argparse.ArgumentTypeError(f"Must be an integer in the range [{self.imin}, {self.imax}]")
        elif self.imin is not None:
            return argparse.ArgumentTypeError(f"Must be an integer >= {self.imin}")
        elif self.imax is not None:
            return argparse.ArgumentTypeError(f"Must be an integer <= {self.imax}")
            return argparse.ArgumentTypeError("Must be an integer")

This allows you to do something like:

parser = argparse.ArgumentParser(...)
parser.add_argument('foo', type=IntRange(1))     # Must have foo >= 1
parser.add_argument('bar', type=IntRange(1, 7))  # Must have 1 <= bar <= 7

The variable foo now allows only positive integers, like the OP asked.

Note that in addition to the above forms, just a maximum is also possible with IntRange:

parser.add_argument('other', type=IntRange(imax=10))  # Must have other <= 10
Answered By: pallgeuer

Based on Yuushi’s answer, you can also define a simple helper function that can check if a number is positive for various numeric types:

def positive(numeric_type):
    def require_positive(value):
        number = numeric_type(value)
        if number <= 0:
            raise ArgumentTypeError(f"Number {value} must be positive.")
        return number

    return require_positive

The helper function can be used to annotate any numeric argument type like this:

parser = argparse.ArgumentParser(...)
parser.add_argument("positive-integer", type=positive(int))
parser.add_argument("positive-float", type=positive(float))
Answered By: Jan Heinrich Reimer
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.