No Python, usando argparse, permita apenas números inteiros positivos

O título resume muito bem o que eu gostaria que acontecesse.

Aqui está o que eu tenho e, embora o programa não exploda um número inteiro não positivo, quero que o usuário seja informado de que um número inteiro não positivo é basicamente um disparate.

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

E a saída:

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

Saída com negativo:

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

Agora, obviamente, eu poderia simplesmente adicionar um if para determinar que if args.gamesé negativo, mas fiquei curioso para saber se havia uma maneira de capturá-lo no argparsenível, para tirar proveito da impressão de uso automático.

Idealmente, imprimiria algo semelhante a este:

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'

Igual a:

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'

Por enquanto estou fazendo isso e acho que estou feliz:

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

Isso deve ser possível utilizando type. Você ainda precisará definir um método real que decida isso para você:

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)

Este é basicamente apenas um exemplo adaptado da perfect_squarefunção nos documentos em argparse.

type seria a opção recomendada para lidar com condições / verificações, como na resposta de Yuushi.

No seu caso específico, você também pode usar o choicesparâmetro se seu limite superior também for conhecido:

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

Nota: use em rangevez de xrangepara python 3.x

A maneira rápida e suja, se você tem um máximo previsível e um mínimo para o seu argumento, é usado choicescom um intervalo

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

Uma alternativa mais simples, especialmente se a subclasse argparse.ArgumentParser, é iniciar a validação de dentro do parse_argsmétodo.

Dentro dessa subclasse:

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

Essa técnica pode não ser tão legal quanto uma chamada personalizada, mas faz o trabalho.

Sobre ArgumentParser.error(message):

Este método imprime uma mensagem de uso incluindo a mensagem para o erro padrão e finaliza o programa com um código de status 2.

Crédito: resposta por jonatan

Caso alguém (como eu) se depare com essa pergunta em uma pesquisa no Google, aqui está um exemplo de como usar uma abordagem modular para resolver com perfeição o problema mais geral de permitir números inteiros argparse apenas em um intervalo especificado :

# 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):
        try:
            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}")
        else:
            return argparse.ArgumentTypeError("Must be an integer")

Isso permite que você faça algo como:

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

A variável fooagora permite apenas números inteiros positivos , como o OP solicitado.

Observe que, além dos formulários acima, apenas um máximo também é possível com IntRange:

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