Utilisation de la sortie argparse pour appeler des fonctions

Question

mon code ressemble actuellement à ce sujet. Il me permet d'analyser plusieurs paramètres mon script de programme reçoit. Y at-il une autre façon qui est plus proche de « meilleures pratiques »? Je ne l'ai pas vu code en utilisant effectivement la sortie de argparse, seule la façon de le mettre en place.

def useArguments():
    x = 0
    while x <= 5:
        if x == 0:                      
            if args.getweather != None:
                getWeather(args.getweather)
        if x == 1:
            if args.post != None:
                post(args.post)
        if x == 2:
            if args.custompost != None:
                custompost(args.custompost)
        if x == 3:
            if args.list != None:
                listAccounts(args.list)
        if x == 4:
            if args.add != None:
                addAccount(args.add[0])
        if x == 5:
            if args.edit != None:
                editAccount(args.edit[0])
        x = x + 1    


if __name__ == '__main__':

    updateConfig()

    parser = argparse.ArgumentParser(description='Post Yahoo weather to Twitter.', epilog="Report any bugs to example@email.com", prog='Program')

    parser.add_argument('-a', '--add', nargs=1, help='Add a new account. Use the desired account name as an argument.')
    parser.add_argument('-e', '--edit', nargs=1, choices=accountListSTR[:-1], help='Edit an account. Use the desired account name as an argument.')
    parser.add_argument('-g', '--getweather', nargs='*', choices=accountListSTR, help='Get weather and post here. Specify account(s) as argument. Use "all" for all accounts. If you specify multiple accounts, separate by a space NOT a comma.')
    parser.add_argument('-p', '--post', nargs='*', choices=accountListSTR, help='Post weather to Twitter. Specify account(s) as argument. Use "all" for all accounts. If you specify multiple accounts, separate by a space NOT a comma.')
    parser.add_argument('-c', '--custompost', nargs=2, help='Post a custom message. Specify an account then type the message. Make sure you use "" around the message. Use "all" for all accounts.')
    parser.add_argument('-l', '--list', action='store_const', const='all', help='List all accounts.')
    parser.add_argument('--version', action='version', version='%(prog)s 0.3.3')

    args = parser.parse_args()

    useArguments()

Answer 1

Vous pourriez fournir une coutume pour un argument, et je citation:

  

le passage d'un objet qui implémente les   API d'action. La meilleure façon de le faire   est d'étendre argparse.Action,   fournir un __call__ approprié   méthode. La méthode devrait __call__   accepter quatre paramètres:

     

  
1. analyseur :. L'objet ArgumentParser qui contient cette action
  
2. espace : L'objet espace de noms qui sera retourné par parse_args(). La plupart des actions ajouter un attribut à cet objet.
  
3. valeurs :.. Les arguments de ligne de commande associés, avec tout type-conversions appliquées (Type-conversions sont spécifiés par l'argument de mot-clé du type à add_argument()
  
4. option_string : La chaîne d'option qui a été utilisée pour invoquer cette action. L'argument option_string est facultatif, et sera absent si l'action est associée à un argument de position.
  

Answer 2

Voir http://docs.python.org/library/argparse.html # sous-commandes :

  

Une façon particulièrement efficace de gérer les sous-commandes est de combiner l'utilisation de la méthode add_subparsers() avec des appels à set_defaults() afin que chaque subparser sait quelle fonction Python il doit exécuter.

En bref:

parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()

weather_parser = subparsers.add_parser('get-weather')
weather_parser.add_argument('--bar')
weather_parser.set_defaults(function=get_weather)  # !

args = parser.parse_args(['get-weather', '--bar', 'quux'])
print args.function(args)

Ici, nous créons un subparser pour la commande get-weather et assigner la fonction get_weather à elle.

Notez que la documentation indique que le mot-clé / attribut est nommé func mais il est certainement function au argparse 1.1.

Le code résultant est un peu trop verbeux donc j'ai publié un petit paquet "Argh" qui rend les choses plus simples, par exemple:

parser = argparse.ArgumentParser()
add_commands(parser, [get_weather])
print dispatch(parser, ['get-weather', '--bar', 'quux'])

« Argh » peut faire plus mais je vais laisser répondre de débordement de pile. : -)

Answer 3

A l'exception de --version, qui est très souvent une option, les actions que vous avez fournis sont mieux traités comme des « sous-commandes ».

Je ne suis pas au courant des détails argparse, comme je l'ai pas encore essayer Python 2.7, mais vous pouvez jeter un oeil à la commande svn à titre d'exemple, voici quelques pseudo-code pour la ligne de commande:

myprog [--version] <command> [<command opts>...]

Où <command> dans:

add|edit|getweather|post|custompost|list

Et <command opts> sont des options spécifiques à cette commande. L'utilisation optparse (qui est similaire), cela signifierait que votre commande sera retourné dans args, lorsque vous appelez parse_args, vous permettant de faire quelque chose comme ceci:

opts, args = parser.parse_args()
if opts.version:
    ...
else:
    getattr("do_" + args[0])(*args[1:])

Je trouve ce modèle particulièrement utile pour le débogage, où je fournir l'accès aux fonctions internes de la ligne de commande, et passe différents arguments pour tester. Ajustez la sélection du gestionnaire de commande en fonction de votre propre projet.