Soutien pour Enum arguments en argparse

Est-il un meilleur moyen de soutenir les Énumérations que les types de argparse arguments de ce modèle?

class SomeEnum(Enum):
    ONE = 1
    TWO = 2

parser.add_argument('some_val', type=str, default='one',
                    choices=[i.name.lower() for i in SomeEnum])
...
args.some_val = SomeEnum[args.some_val.upper()]
Il y avait une demande pour Enum sur Python bug/problèmes. Je ne me souviens pas beaucoup d'enthousiasme pour l'ajout de manutention spéciale. Choix, comme la vôtre, est une seule façon. Une autre serait une coutume type fonction. Qui pourrait à la fois de tester et de les convertir. Je soupçonne que vous êtes plus familier avec les Énumérations que je suis.
Je me demandais un instant si il serait possible de dériver une coutume Enum qui allait se comporter comme prévu lorsqu'il est réglé sur type=
Le type paramètre est une fonction/appelable. Écrivez votre propre qui prend une chaîne de caractères, et fait quelque chose avec elle. Les types les plus courants, int et float sont les fonctions standard qui ne int("123") ou float("12.3").

OriginalL'auteur Andrzej Pronobis | 2017-05-14

  1. 40

    Je vois c'est une vieille question, mais je viens de tomber sur le même problème (Python 2.7) et voici comment je l'ai résolu:

    from argparse import ArgumentParser
from enum import Enum

class Color(Enum):
    red = 'red'
    blue = 'blue'
    green = 'green'

    def __str__(self):
        return self.value

parser = ArgumentParser()
parser.add_argument('color', type=Color, choices=list(Color))

opts = parser.parse_args()
print 'your color was:', opts.color

    Noter que la définition de __str__ est nécessaire pour obtenir ArgumentParser's sortie de l'aide pour inclure le texte lisible (valeurs) de Color.

    Quelques exemples d'invocations:

    => python enumtest.py blue
your color was: blue

=> python enumtest.py not-a-color
usage: enumtest.py [-h] {blue,green,red}
enumtest.py: error: argument color: invalid Color value: 'not-a-color'

=> python enumtest.py -h
usage: enumtest.py [-h] {blue,green,red}

positional arguments:
  {blue,green,red}

    Depuis l'OP question spécifiée entiers comme des valeurs, ici est une version légèrement modifiée qui fonctionne dans ce cas (à l'aide de l'énumération des noms, plutôt que les valeurs, comme la ligne de commande args):

    class Color(Enum):
    red = 1
    blue = 2
    green = 3

    def __str__(self):
        return self.name

parser = ArgumentParser()
parser.add_argument('color', type=lambda color: Color[color], choices=list(Color))

    Le seul inconvénient il n'y a qu'un mauvais paramètre provoque une vilaine KeyError. C'est facilement résolu en ajoutant juste un peu plus de code, la conversion de la lambda dans une fonction appropriée.

    class Color(Enum):
    red = 1
    blue = 2
    green = 3

    def __str__(self):
        return self.name

    @staticmethod
    def from_string(s):
        try:
            return Color[s]
        except KeyError:
            raise ValueError()

parser = ArgumentParser()
parser.add_argument('color', type=Color.from_string, choices=list(Color))

    OriginalL'auteur ron rothman

  2. 0

    Voici pertinentes bug/problème: http://bugs.python.org/issue25061

    Ajouter native prise en charge des énumérations pour argparse

    J'ai déjà écrit trop. 🙂

    OriginalL'auteur hpaulj