Tenho usado argparsepara um programa Python que pode -process, -uploadou ambos:

parser = argparse.ArgumentParser(description='Log archiver arguments.')
parser.add_argument('-process', action='store_true')
parser.add_argument('-upload',  action='store_true')
args = parser.parse_args()

O programa não tem sentido sem pelo menos um parâmetro. Como posso configurar argparsepara forçar a escolha de pelo menos um parâmetro?

ATUALIZAR:

Seguindo os comentários: Qual é a maneira Pythônica de parametrizar um programa com pelo menos uma opção?

if not (args.process or args.upload):
    parser.error('No action requested, add -process or -upload')

args = vars(parser.parse_args())
if not any(args.values()):
    parser.error('No arguments provided.')

Se não for a parte 'ou ambas' (inicialmente não percebi isso), você poderia usar algo assim:

parser = argparse.ArgumentParser(description='Log archiver arguments.')
parser.add_argument('--process', action='store_const', const='process', dest='mode')
parser.add_argument('--upload',  action='store_const', const='upload', dest='mode')
args = parser.parse_args()
if not args.mode:
    parser.error("One of --process or --upload must be given")

Porém, provavelmente seria uma ideia melhor usar subcomandos .

Eu sei que isso é muito antigo, mas a maneira de exigir uma opção, mas proibir mais de uma (XOR) é assim:

parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('-process', action='store_true')
group.add_argument('-upload',  action='store_true')
args = parser.parse_args()
print args

Resultado:

>opt.py  
usage: multiplot.py [-h] (-process | -upload)  
multiplot.py: error: one of the arguments -process -upload is required  

>opt.py -upload  
Namespace(process=False, upload=True)  

>opt.py -process  
Namespace(process=True, upload=False)  

>opt.py -upload -process  
usage: multiplot.py [-h] (-process | -upload)  
multiplot.py: error: argument -process: not allowed with argument -upload  

Revisão de Requisitos

• usar argparse(vou ignorar este)
• permitir que uma ou duas ações sejam chamadas (pelo menos uma é necessária).
• tente por Pythonic (prefiro chamá-lo de "POSIX")

Existem também alguns requisitos implícitos ao viver na linha de comando:

• explicar o uso para o usuário de uma maneira que seja fácil de entender
• as opções devem ser opcionais
• permite especificar sinalizadores e opções
• permite a combinação com outros parâmetros (como nome ou nomes de arquivo).

Solução de amostra usando docopt (arquivo managelog.py):

"""Manage logfiles
Usage:
    managelog.py [options] process -- <logfile>...
    managelog.py [options] upload -- <logfile>...
    managelog.py [options] process upload -- <logfile>...
    managelog.py -h

Options:
    -V, --verbose      Be verbose
    -U, --user <user>  Username
    -P, --pswd <pswd>  Password

Manage log file by processing and/or uploading it.
If upload requires authentication, you shall specify <user> and <password>
"""
if __name__ == "__main__":
    from docopt import docopt
    args = docopt(__doc__)
    print args

Tente executá-lo:

$ python managelog.py
Usage:
    managelog.py [options] process -- <logfile>...
    managelog.py [options] upload -- <logfile>...
    managelog.py [options] process upload -- <logfile>...
    managelog.py -h

Mostre a ajuda:

$ python managelog.py -h
Manage logfiles
Usage:
    managelog.py [options] process -- <logfile>...
    managelog.py [options] upload -- <logfile>...
    managelog.py [options] process upload -- <logfile>...
    managelog.py -h

Options:
    -V, --verbose      Be verbose
    -U, --user <user>  Username
    -P, --pswd <pswd>  P    managelog.py [options] upload -- <logfile>...

Manage log file by processing and/or uploading it.
If upload requires authentication, you shall specify <user> and <password>

E use-o:

$ python managelog.py -V -U user -P secret upload -- alfa.log beta.log
{'--': True,
 '--pswd': 'secret',
 '--user': 'user',
 '--verbose': True,
 '-h': False,
 '<logfile>': ['alfa.log', 'beta.log'],
 'process': False,
 'upload': True}

Alternativa curta short.py

Pode haver uma variante ainda mais curta:

"""Manage logfiles
Usage:
    short.py [options] (process|upload)... -- <logfile>...
    short.py -h

Options:
    -V, --verbose      Be verbose
    -U, --user <user>  Username
    -P, --pswd <pswd>  Password

Manage log file by processing and/or uploading it.
If upload requires authentication, you shall specify <user> and <password>
"""
if __name__ == "__main__":
    from docopt import docopt
    args = docopt(__doc__)
    print args

O uso é parecido com este:

$ python short.py -V process upload  -- alfa.log beta.log
{'--': True,
 '--pswd': None,
 '--user': None,
 '--verbose': True,
 '-h': False,
 '<logfile>': ['alfa.log', 'beta.log'],
 'process': 1,
 'upload': 1}

Observe que, em vez de valores booleanos para as chaves de "processo" e "upload", existem contadores.

Acontece que não podemos evitar a duplicação dessas palavras:

$ python short.py -V process process upload  -- alfa.log beta.log
{'--': True,
 '--pswd': None,
 '--user': None,
 '--verbose': True,
 '-h': False,
 '<logfile>': ['alfa.log', 'beta.log'],
 'process': 2,
 'upload': 1}

Conclusões

Projetar uma boa interface de linha de comando pode ser um desafio às vezes.

Existem vários aspectos do programa baseado em linha de comando:

• bom design de linha de comando
• selecionando / usando o analisador adequado

argparse oferece muito, mas restringe cenários possíveis e pode se tornar muito complexo.

Com as docoptcoisas ficam muito mais curtas, preservando a legibilidade e oferecendo alto grau de flexibilidade. Se você consegue obter argumentos analisados ​​do dicionário e faz algumas conversões (para inteiro, abrindo arquivos ..) manualmente (ou por outra biblioteca chamada schema), você pode achar um docoptbom ajuste para análise de linha de comando.

Se você precisar que um programa python seja executado com pelo menos um parâmetro, adicione um argumento que não tenha o prefixo de opção (- ou - por padrão) e defina nargs=+(mínimo de um argumento necessário). O problema com esse método que descobri é que, se você não especificar o argumento, argparse gerará um erro de "poucos argumentos" e não imprimirá o menu de ajuda. Se você não precisa dessa funcionalidade, veja como fazê-lo no código:

import argparse

parser = argparse.ArgumentParser(description='Your program description')
parser.add_argument('command', nargs="+", help='describe what a command is')
args = parser.parse_args()

Eu acho que quando você adiciona um argumento com os prefixos de opção, nargs governa todo o analisador de argumento e não apenas a opção. (O que quero dizer é que, se você tiver um --optionsinalizador com nargs="+", o --optionsinalizador espera pelo menos um argumento. Se você tiver optioncom nargs="+", ele espera pelo menos um argumento geral.)

Para http://bugs.python.org/issue11588 , estou explorando maneiras de generalizar o mutually_exclusive_groupconceito para lidar com casos como este.

Com este desenvolvimento argparse.py , https://github.com/hpaulj/argparse_issues/blob/nested/argparse.py eu sou capaz de escrever:

parser = argparse.ArgumentParser(prog='PROG', 
    description='Log archiver arguments.')
group = parser.add_usage_group(kind='any', required=True,
    title='possible actions (at least one is required)')
group.add_argument('-p', '--process', action='store_true')
group.add_argument('-u', '--upload',  action='store_true')
args = parser.parse_args()
print(args)

que produz o seguinte help :

usage: PROG [-h] (-p | -u)

Log archiver arguments.

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

possible actions (at least one is required):
  -p, --process
  -u, --upload

Isso aceita entradas como '-u', '-up', '--proc --up' etc.

Ele acaba executando um teste semelhante a https://stackoverflow.com/a/6723066/901925 , embora a mensagem de erro precise ser mais clara:

usage: PROG [-h] (-p | -u)
PROG: error: some of the arguments process upload is required

Eu me pergunto:

• são os parâmetros kind='any', required=True claros o suficiente (aceitar qualquer um do grupo; pelo menos um é necessário)?

• é uso (-p | -u) claro? Um mutually_exclusive_group necessário produz a mesma coisa. Existe alguma notação alternativa?

• é usar um grupo como este mais intuitivo do que phihag'sum teste simples?

A melhor maneira de fazer isso é usando o módulo embutido python add_mutually_exclusive_group .

parser = argparse.ArgumentParser(description='Log archiver arguments.')
group = parser.add_mutually_exclusive_group()
group.add_argument('-process', action='store_true')
group.add_argument('-upload',  action='store_true')
args = parser.parse_args()

Se você quiser que apenas um argumento seja selecionado pela linha de comando, use apenas required = True como um argumento para o grupo

group = parser.add_mutually_exclusive_group(required=True)

Talvez use sub-analisadores?

import argparse

parser = argparse.ArgumentParser(description='Log archiver arguments.')
subparsers = parser.add_subparsers(dest='subparser_name', help='sub-command help')
parser_process = subparsers.add_parser('process', help='Process logs')
parser_upload = subparsers.add_parser('upload', help='Upload logs')
args = parser.parse_args()

print("Subparser: ", args.subparser_name)

Agora --helpmostra:

$ python /tmp/aaa.py --help
usage: aaa.py [-h] {process,upload} ...

Log archiver arguments.

positional arguments:
  {process,upload}  sub-command help
    process         Process logs
    upload          Upload logs

optional arguments:
  -h, --help        show this help message and exit
$ python /tmp/aaa.py
usage: aaa.py [-h] {process,upload} ...
aaa.py: error: too few arguments
$ python3 /tmp/aaa.py upload
Subparser:  upload

Você também pode adicionar opções adicionais a esses subanalisadores. Além disso, em vez de usar isso, dest='subparser_name'você também pode vincular funções a serem chamadas diretamente em um determinado subcomando (consulte a documentação).

Isso atinge o objetivo e também será afetado na --helpsaída gerada automaticamente do argparse , que é o que a maioria dos programadores sãos desejam (também funciona com argumentos opcionais):

parser.add_argument(
    'commands',
    nargs='+',                      # require at least 1
    choices=['process', 'upload'],  # restrict the choice
    help='commands to execute'
)

Documentos oficiais sobre isso: https://docs.python.org/3/library/argparse.html#choices

Use append_const para uma lista de ações e, em seguida, verifique se a lista está preenchida:

parser.add_argument('-process', dest=actions, const="process", action='append_const')
parser.add_argument('-upload',  dest=actions, const="upload", action='append_const')

args = parser.parse_args()

if(args.actions == None):
    parser.error('Error: No actions requested')

Você pode até especificar os métodos diretamente nas constantes.

def upload:
    ...

parser.add_argument('-upload',  dest=actions, const=upload, action='append_const')
args = parser.parse_args()

if(args.actions == None):
    parser.error('Error: No actions requested')

else:
    for action in args.actions:
        action()