"enum" --- Support for enumerations
***********************************

Ajouté dans la version 3.4.

**Code source :** Lib/enum.py


Important
^^^^^^^^^

Cette page contient les informations de référence de l'API. Pour des
informations sur le didacticiel et une discussion sur des sujets plus
avancés, reportez-vous à

* Tutoriel de base

* Tutoriel avancé

* Recettes pour les énumérations

======================================================================

Une énumération :

* est un ensemble de noms symboliques (appelés membres) liés à des
  valeurs uniques,

* can be iterated over to return its canonical (i.e. non-alias)
  members in definition order

* utilise la syntaxe *d'appel* pour renvoyer les valeurs de ses
  membres,

* utilise la syntaxe *d'indiçage* pour renvoyer les noms de ses
  membres.

Les énumérations sont créées soit en utilisant la syntaxe "class",
soit en utilisant la syntaxe d'appel de fonction :

   >>> from enum import Enum

   >>> # class syntax
   >>> class Color(Enum):
   ...     RED = 1
   ...     GREEN = 2
   ...     BLUE = 3

   >>> # functional syntax
   >>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])

Même si on peut utiliser la syntaxe "class" pour créer des
énumérations, les *Enums* ne sont pas des vraies classes Python. Lisez
En quoi les énumérations sont-elles différentes ? pour plus de
détails.

Note:

  Nomenclature

  * The class "Color" is an *enumeration* (or *enum*)

  * The attributes "Color.RED", "Color.GREEN", etc., are *enumeration
    members* (or *members*) and are functionally constants.

  * The enum members have *names* and *values* (the name of
    "Color.RED" is "RED", the value of "Color.BLUE" is "3", etc.)

======================================================================


Module contents
===============

   "EnumType"

      Le "type" d'*Enum* et de ses sous-classes.

   "Enum"

      Classe mère pour créer une énumération de constantes.

   "IntEnum"

      Classe mère pour créer une énumération de constantes qui sont
      également des sous-classes de "int" (notes).

   "StrEnum"

      Classe mère pour créer une énumération de constantes qui sont
      également des sous-classes de "str" (notes).

   "Flag"

      Classe mère pour créer une énumération de constantes pouvant
      être combinées avec des opérateurs de comparaison bit-à-bit,
      sans perdre leur qualité de "Flag".

   "IntFlag"

      Classe mère pour créer une énumération de constantes pouvant
      être combinées avec des opérateurs de comparaison bit-à-bit,
      sans perdre leur qualité de "IntFlag". Les membres de "IntFlag"
      sont aussi des sous-classes de "int" (notes).

   "ReprEnum"

      Used by "IntEnum", "StrEnum", and "IntFlag" to keep the "str()"
      of the mixed-in type.

   "EnumCheck"

      Énumération avec les valeurs "CONTINUOUS", "NAMED_FLAGS" et
      "UNIQUE", à utiliser avec "verify()" pour s'assurer que diverses
      contraintes sont satisfaites par une énumération donnée.

   "FlagBoundary"

      Énumération avec les valeurs "STRICT", "CONFORM", "EJECT" et
      "KEEP" qui permet un contrôle plus précis sur la façon dont les
      valeurs invalides sont traitées dans une énumération.

   "EnumDict"

      A subclass of "dict" for use when subclassing "EnumType".

   "auto"

      Les instances sont remplacées par une valeur appropriée pour les
      membres de l'énumération. "StrEnum" utilise par défaut la
      version minuscule du nom du membre, tandis que les autres
      énumérations utilisent 1 par défaut et puis augmentent.

   "property()"

      Allows "Enum" members to have attributes without conflicting
      with member names.  The "value" and "name" attributes are
      implemented this way.

   "unique()"

      Décorateur de classe qui garantit qu'une valeur ne puisse être
      associée qu'à un seul nom.

   "verify()"

      Décorateur de classe qui vérifie des contraintes personnalisées
      pour une énumération.

   "member()"

      Fait de "obj" un membre. Peut être utilisé comme décorateur.

   "nonmember()"

      Fait que "obj" n'est pas un membre. Peut être utilisé comme
      décorateur.

   "global_enum()"

      Modify the "str()" and "repr()" of an enum to show its members
      as belonging to the module instead of its class, and export the
      enum members to the global namespace.

   "show_flag_values()"

      Return a list of all power-of-two integers contained in a flag.

   "enum.bin()"

      Like built-in "bin()", except negative values are represented in
      two's complement, and the leading bit always indicates sign ("0"
      implies positive, "1" implies negative).

Ajouté dans la version 3.6: "Flag", "IntFlag", "auto"

Ajouté dans la version 3.11: "StrEnum", "EnumCheck", "ReprEnum",
"FlagBoundary", "property", "member", "nonmember", "global_enum",
"show_flag_values"

Ajouté dans la version 3.13: "EnumDict"

======================================================================


Data types
==========

class enum.EnumType

   *EnumType* est la *métaclasse* pour les énumérations. Il est
   possible de sous-classer *EnumType* ­— voir Sous-classer EnumType
   pour plus de détails.

   "EnumType" is responsible for setting the correct "__repr__()",
   "__str__()", "__format__()", and "__reduce__()" methods on the
   final *enum*, as well as creating the enum members, properly
   handling duplicates, providing iteration over the enum class, etc.

   Ajouté dans la version 3.11: Before 3.11 "EnumType" was called
   "EnumMeta", which is still available as an alias.

   __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

      Cette méthode peut être appelée de deux manières différentes :

      * pour chercher un membre existant :

           cls:
              Classe de l'énumération concernée.

           value:
              Valeur à chercher.

      * to use the "cls" enum to create a new enum (only if the
        existing enum does not have any members):

           cls:
              Classe de l'énumération concernée.

           value:
              Nom de la nouvelle énumération à créer.

           names:
              Couples nom-valeur des membres de la nouvelle
              énumération.

           module:
              Nom du module dans lequel la classe *Enum* se trouve.

           qualname:
              Position dans le module où la classe *Enum* se trouve.

           type:
              Type à mélanger pour la nouvelle énumération.

           start:
              The first integer value for the Enum (used by "auto").

           boundary:
              How to handle out-of-range values from bit operations
              ("Flag" only).

   __contains__(cls, member)

      Renvoie "True" si le membre appartient à "cls" :

         >>> some_var = Color.RED
         >>> some_var in Color
         True
         >>> Color.RED.value in Color
         True

      Modifié dans la version 3.12: Before Python 3.12, a "TypeError"
      is raised if a non-Enum-member is used in a containment check.

   __dir__(cls)

      Renvoie "['__class__', '__doc__', '__members__', '__module__']"
      et les noms des membres de *cls* :

         >>> dir(Color)
         ['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', '__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', '__module__', '__name__', '__qualname__']

   __getitem__(cls, name)

      Returns the Enum member in *cls* matching *name*, or raises a
      "KeyError":

         >>> Color['BLUE']
         <Color.BLUE: 3>

   __iter__(cls)

      Renvoie chaque membre de *cls* dans l'ordre de définition :

         >>> list(Color)
         [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]

   __len__(cls)

      Renvoie le nombre de membres de *cls* :

         >>> len(Color)
         3

   __members__

      Returns a mapping of every enum name to its member, including
      aliases

   __reversed__(cls)

      Renvoie chaque membre de *cls* dans l'ordre inverse de
      définition :

         >>> list(reversed(Color))
         [<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]

class enum.Enum

   *Enum* est la classe mère de toutes les énumérations.

   name

      Le nom utilisé pour définir le membre de l'"Enum" :

         >>> Color.BLUE.name
         'BLUE'

   value

      La valeur attribuée au membre de l'"Enum" :

         >>> Color.RED.value
         1

      Value of the member, can be set in "__new__()".

      Note:

        Valeurs des membres d'une *Enum*Member values can be anything:
        "int", "str", etc.  If the exact value is unimportant you may
        use "auto" instances and an appropriate value will be chosen
        for you.  See "auto" for the details.While mutable/unhashable
        values, such as "dict", "list" or a mutable "dataclass", can
        be used, they will have a quadratic performance impact during
        creation relative to the total number of mutable/unhashable
        values in the enum.

   _name_

      Name of the member.

   _value_

      Value of the member, can be set in "__new__()".

   _order_

      No longer used, kept for backward compatibility. (class
      attribute, removed during class creation).

      The "_order_" attribute can be provided to help keep Python 2 /
      Python 3 code in sync. It will be checked against the actual
      order of the enumeration and raise an error if the two do not
      match:

         >>> class Color(Enum):
         ...     _order_ = 'RED GREEN BLUE'
         ...     RED = 1
         ...     BLUE = 3
         ...     GREEN = 2
         ...
         Traceback (most recent call last):
         ...
         TypeError: member order does not match _order_:
            ['RED', 'BLUE', 'GREEN']
            ['RED', 'GREEN', 'BLUE']

      Note:

        In Python 2 code the "_order_" attribute is necessary as
        definition order is lost before it can be recorded.

      Ajouté dans la version 3.6.

   _ignore_

      "_ignore_" n'est utilisé que lors de la création et est supprimé
      de l'énumération une fois la création terminée.

      "_ignore_" est une liste de noms qui ne deviendront pas membres
      et qui seront également supprimés de l'énumération terminée.
      Voir Intervalle de temps pour un exemple.

      Ajouté dans la version 3.7.

   __dir__(self)

      Renvoie "['__class__', '__doc__', '__module__', 'name',
      'value']" et toutes les méthodes publiques définies pour
      *self.__class__* :

         >>> from enum import Enum
         >>> import datetime as dt
         >>> class Weekday(Enum):
         ...     MONDAY = 1
         ...     TUESDAY = 2
         ...     WEDNESDAY = 3
         ...     THURSDAY = 4
         ...     FRIDAY = 5
         ...     SATURDAY = 6
         ...     SUNDAY = 7
         ...     @classmethod
         ...     def today(cls):
         ...         print(f'today is {cls(dt.date.today().isoweekday()).name}')
         ...
         >>> dir(Weekday.SATURDAY)
         ['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'today', 'value']

   _generate_next_value_(name, start, count, last_values)

         name:
            Nom du membre en cours de définition (par ex. "RED").

         start:
            Valeur de départ pour l'énumération ; 1 par défaut.

         count:
            Nombre de membres actuellement définis, le membre actuel
            n'étant pas inclus.

         last_values:
            Liste des valeurs précédentes.

      A *staticmethod* that is used to determine the next value
      returned by "auto".

      Note:

        For standard "Enum" classes the next value chosen is the
        highest value seen incremented by one.For "Flag" classes the
        next value chosen will be the next highest power-of-two.

      This method may be overridden, e.g.:

         >>> from enum import auto, Enum
         >>> class PowersOfThree(Enum):
         ...     @staticmethod
         ...     def _generate_next_value_(name, start, count, last_values):
         ...         return 3 ** (count + 1)
         ...     FIRST = auto()
         ...     SECOND = auto()
         ...
         >>> PowersOfThree.SECOND.value
         9

      Ajouté dans la version 3.6.

      Modifié dans la version 3.13: Prior versions would use the last
      seen value instead of the highest value.

   __init__(self, *args, **kwds)

      By default, does nothing.  If multiple values are given in the
      member assignment, those values become separate arguments to
      "__init__"; e.g.

      >>> from enum import Enum
      >>> class Weekday(Enum):
      ...     MONDAY = 1, 'Mon'

      "Weekday.__init__()" would be called as "Weekday.__init__(self,
      1, 'Mon')"

   __init_subclass__(cls, **kwds)

      Méthode de classe utilisée pour personnaliser davantage les
      sous-classes à venir. Ne fait rien par défaut.

   _missing_(cls, value)

      Méthode de classe pour chercher des valeurs non trouvées dans
      *cls*. Ne fait rien par défaut mais peut être surchargée pour
      implémenter un comportement personnalisé de recherche :

         >>> from enum import auto, StrEnum
         >>> class Build(StrEnum):
         ...     DEBUG = auto()
         ...     OPTIMIZED = auto()
         ...     @classmethod
         ...     def _missing_(cls, value):
         ...         value = value.lower()
         ...         for member in cls:
         ...             if member.value == value:
         ...                 return member
         ...         return None
         ...
         >>> Build.DEBUG.value
         'debug'
         >>> Build('deBUG')
         <Build.DEBUG: 'debug'>

      Ajouté dans la version 3.6.

   __new__(cls, *args, **kwds)

      By default, doesn't exist.  If specified, either in the enum
      class definition or in a mixin class (such as "int"), all values
      given in the member assignment will be passed; e.g.

      >>> from enum import Enum
      >>> class MyIntEnum(int, Enum):
      ...     TWENTYSIX = '1a', 16

      results in the call "int('1a', 16)" and a value of "26" for the
      member.

      Note:

        When writing a custom "__new__", do not use "super().__new__"
        -- call the appropriate "__new__" instead.

   __repr__(self)

      Renvoie la chaîne utilisée pour les appels à *repr()*. Par
      défaut, renvoie le nom de l'énumération, le nom du membre et sa
      valeur, mais peut être surchargée :

         >>> from enum import auto, Enum
         >>> class OtherStyle(Enum):
         ...     ALTERNATE = auto()
         ...     OTHER = auto()
         ...     SOMETHING_ELSE = auto()
         ...     def __repr__(self):
         ...         cls_name = self.__class__.__name__
         ...         return f'{cls_name}.{self.name}'
         ...
         >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
         (OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')

   __str__(self)

      Renvoie la chaîne utilisée pour les appels à *str()*. Par
      défaut, renvoie le nom *Enum* et le nom du membre, mais peut
      être remplacé :

         >>> from enum import auto, Enum
         >>> class OtherStyle(Enum):
         ...     ALTERNATE = auto()
         ...     OTHER = auto()
         ...     SOMETHING_ELSE = auto()
         ...     def __str__(self):
         ...         return f'{self.name}'
         ...
         >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
         (<OtherStyle.ALTERNATE: 1>, 'ALTERNATE', 'ALTERNATE')

   __format__(self)

      Returns the string used for *format()* and *f-string* calls.  By
      default, returns "__str__()" return value, but can be
      overridden:

         >>> from enum import auto, Enum
         >>> class OtherStyle(Enum):
         ...     ALTERNATE = auto()
         ...     OTHER = auto()
         ...     SOMETHING_ELSE = auto()
         ...     def __format__(self, spec):
         ...         return f'{self.name}'
         ...
         >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
         (<OtherStyle.ALTERNATE: 1>, 'OtherStyle.ALTERNATE', 'ALTERNATE')

   Note:

     L'utilisation de "auto" avec "Enum" donne des nombres entiers de
     valeur croissante, en commençant par "1".

   Modifié dans la version 3.12: Added Dataclass support

   _add_alias_()

      Adds a new name as an alias to an existing member:

         >>> Color.RED._add_alias_("ERROR")
         >>> Color.ERROR
         <Color.RED: 1>

      Raises a "NameError" if the name is already assigned to a
      different member.

      Ajouté dans la version 3.13.

   _add_value_alias_()

      Adds a new value as an alias to an existing member:

         >>> Color.RED._add_value_alias_(42)
         >>> Color(42)
         <Color.RED: 1>

         Raises a "ValueError" if the value is already linked with a different member.
         See MultiValueEnum for an example.

      Ajouté dans la version 3.13.

class enum.IntEnum

   *IntEnum* is the same as "Enum", but its members are also integers
   and can be used anywhere that an integer can be used.  If any
   integer operation is performed with an *IntEnum* member, the
   resulting value loses its enumeration status.

   >>> from enum import IntEnum
   >>> class Number(IntEnum):
   ...     ONE = 1
   ...     TWO = 2
   ...     THREE = 3
   ...
   >>> Number.THREE
   <Number.THREE: 3>
   >>> Number.ONE + Number.TWO
   3
   >>> Number.THREE + 5
   8
   >>> Number.THREE == 3
   True

   Note:

     L'utilisation de "auto" avec "IntEnum" donne des entiers de
     valeur croissante, en commençant par "1".

   Modifié dans la version 3.11: "__str__()" is now "int.__str__()" to
   better support the *replacement of existing constants* use-case.
   "__format__()" was already "int.__format__()" for that same reason.

class enum.StrEnum

   *StrEnum* is the same as "Enum", but its members are also strings
   and can be used in most of the same places that a string can be
   used. The result of any string operation performed on or with a
   *StrEnum* member is not part of the enumeration.

   >>> from enum import StrEnum, auto
   >>> class Color(StrEnum):
   ...     RED = 'r'
   ...     GREEN = 'g'
   ...     BLUE = 'b'
   ...     UNKNOWN = auto()
   ...
   >>> Color.RED
   <Color.RED: 'r'>
   >>> Color.UNKNOWN
   <Color.UNKNOWN: 'unknown'>
   >>> str(Color.UNKNOWN)
   'unknown'

   Note:

     There are places in the stdlib that check for an exact "str"
     instead of a "str" subclass (i.e. "type(unknown) == str" instead
     of "isinstance(unknown, str)"), and in those locations you will
     need to use "str(MyStrEnum.MY_MEMBER)".

   Note:

     L'utilisation de "auto" avec "StrEnum" donne le nom du membre en
     minuscule comme valeur.

   Note:

     "__str__()" is "str.__str__()" to better support the *replacement
     of existing constants* use-case.  "__format__()" is likewise
     "str.__format__()" for that same reason.

   Ajouté dans la version 3.11.

class enum.Flag

   "Flag" is the same as "Enum", but its members support the bitwise
   operators "&" (*AND*), "|" (*OR*), "^" (*XOR*), and "~" (*INVERT*);
   the results of those operations are (aliases of) members of the
   enumeration.

   __contains__(self, value)

      Renvoie *True* si la valeur est dans *self* :

         >>> from enum import Flag, auto
         >>> class Color(Flag):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> purple = Color.RED | Color.BLUE
         >>> white = Color.RED | Color.GREEN | Color.BLUE
         >>> Color.GREEN in purple
         False
         >>> Color.GREEN in white
         True
         >>> purple in white
         True
         >>> white in purple
         False

   __iter__(self):

      Returns all contained non-alias members:

         >>> list(Color.RED)
         [<Color.RED: 1>]
         >>> list(purple)
         [<Color.RED: 1>, <Color.BLUE: 4>]

      Ajouté dans la version 3.11.

   __len__(self):

      Renvoie le nombre de membres de *Flag* :

         >>> len(Color.GREEN)
         1
         >>> len(white)
         3

      Ajouté dans la version 3.11.

   __bool__(self):

      Renvoie *True* s'il y a un membre dans les bits de *Flag*,
      *False* sinon :

         >>> bool(Color.GREEN)
         True
         >>> bool(white)
         True
         >>> black = Color(0)
         >>> bool(black)
         False

   __or__(self, other)

      Renvoie le *OU* logique entre le membre et *other* :

         >>> Color.RED | Color.GREEN
         <Color.RED|GREEN: 3>

   __and__(self, other)

      Renvoie le *ET* logique entre le membre et *other* :

         >>> purple & white
         <Color.RED|BLUE: 5>
         >>> purple & Color.GREEN
         <Color: 0>

   __xor__(self, other)

      Renvoie le *OU Exclusif* logique entre le membre et *other* :

         >>> purple ^ white
         <Color.GREEN: 2>
         >>> purple ^ Color.GREEN
         <Color.RED|GREEN|BLUE: 7>

   __invert__(self):

      Returns all the flags in *type(self)* that are not in *self*:

         >>> ~white
         <Color: 0>
         >>> ~purple
         <Color.GREEN: 2>
         >>> ~Color.RED
         <Color.GREEN|BLUE: 6>

   _numeric_repr_()

      Fonction utilisée pour formater toutes les valeurs numériques
      sans nom restantes. La valeur par défaut est la représentation
      de la valeur ; les choix courants sont "hex()" et "oct()".

   Note:

     L'utilisation de "auto" avec "Flag" donne des entiers qui sont
     des puissances de deux, en commençant par "1".

   Modifié dans la version 3.11: The *repr()* of zero-valued flags has
   changed.  It is now:

   >>> Color(0)
   <Color: 0>

class enum.IntFlag

   "IntFlag" is the same as "Flag", but its members are also integers
   and can be used anywhere that an integer can be used.

   >>> from enum import IntFlag, auto
   >>> class Color(IntFlag):
   ...     RED = auto()
   ...     GREEN = auto()
   ...     BLUE = auto()
   ...
   >>> Color.RED & 2
   <Color: 0>
   >>> Color.RED | 2
   <Color.RED|GREEN: 3>

   Si une opération sur un entier est effectuée avec un membre d'un
   *IntFlag*, le résultat n'est pas un *IntFlag* :

      >>> Color.RED + 2
      3

   If a "Flag" operation is performed with an *IntFlag* member and:

   * le résultat est un *IntFlag* valide : un *IntFlag* est renvoyé ;

   * the result is not a valid *IntFlag*: the result depends on the
     "FlagBoundary" setting

   The "repr()" of unnamed zero-valued flags has changed.  It is now:

      >>> Color(0)
      <Color: 0>

   Note:

     L'utilisation de "auto" avec "IntFlag" donne des entiers qui sont
     des puissances de deux, en commençant par "1".

   Modifié dans la version 3.11: "__str__()" is now "int.__str__()" to
   better support the *replacement of existing constants* use-case.
   "__format__()" was already "int.__format__()" for that same
   reason.Inversion of an "IntFlag" now returns a positive value that
   is the union of all flags not in the given flag, rather than a
   negative value. This matches the existing "Flag" behavior.

class enum.ReprEnum

   "ReprEnum" uses the "repr()" of "Enum", but the "str()" of the
   mixed-in data type:

   * "int.__str__()" for "IntEnum" and "IntFlag"

   * "str.__str__()" for "StrEnum"

   Inherit from "ReprEnum" to keep the "str()" / "format()" of the
   mixed-in data type instead of using the "Enum"-default "str()".

   Ajouté dans la version 3.11.

class enum.EnumCheck

   *EnumCheck* contient les options utilisées par le décorateur
   "verify()" pour assurer diverses contraintes ; si une contrainte
   n'est pas validée, une "ValueError" est levée.

   UNIQUE

      Assure que chaque valeur n'a qu'un seul nom :

         >>> from enum import Enum, verify, UNIQUE
         >>> @verify(UNIQUE)
         ... class Color(Enum):
         ...     RED = 1
         ...     GREEN = 2
         ...     BLUE = 3
         ...     CRIMSON = 1
         Traceback (most recent call last):
         ...
         ValueError: aliases found in <enum 'Color'>: CRIMSON -> RED

   CONTINUOUS

      Assure qu'il n'y a pas de valeurs manquantes entre le membre
      ayant la valeur la plus faible et le membre ayant la valeur la
      plus élevée :

         >>> from enum import Enum, verify, CONTINUOUS
         >>> @verify(CONTINUOUS)
         ... class Color(Enum):
         ...     RED = 1
         ...     GREEN = 2
         ...     BLUE = 5
         Traceback (most recent call last):
         ...
         ValueError: invalid enum 'Color': missing values 3, 4

   NAMED_FLAGS

      Ensure that any flag groups/masks contain only named flags --
      useful when values are specified instead of being generated by
      "auto()":

         >>> from enum import Flag, verify, NAMED_FLAGS
         >>> @verify(NAMED_FLAGS)
         ... class Color(Flag):
         ...     RED = 1
         ...     GREEN = 2
         ...     BLUE = 4
         ...     WHITE = 15
         ...     NEON = 31
         Traceback (most recent call last):
         ...
         ValueError: invalid Flag 'Color': aliases WHITE and NEON are missing combined values of 0x18 [use enum.show_flag_values(value) for details]

   Note:

     CONTINUOUS et NAMED_FLAGS sont conçus pour fonctionner avec des
     membres à valeur entière.

   Ajouté dans la version 3.11.

class enum.FlagBoundary

   "FlagBoundary" controls how out-of-range values are handled in
   "Flag" and its subclasses.

   STRICT

      Out-of-range values cause a "ValueError" to be raised. This is
      the default for "Flag":

         >>> from enum import Flag, STRICT, auto
         >>> class StrictFlag(Flag, boundary=STRICT):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> StrictFlag(2**2 + 2**4)
         Traceback (most recent call last):
         ...
         ValueError: <flag 'StrictFlag'> invalid value 20
             given 0b0 10100
           allowed 0b0 00111

   CONFORM

      Out-of-range values have invalid values removed, leaving a valid
      "Flag" value:

         >>> from enum import Flag, CONFORM, auto
         >>> class ConformFlag(Flag, boundary=CONFORM):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> ConformFlag(2**2 + 2**4)
         <ConformFlag.BLUE: 4>

   EJECT

      Out-of-range values lose their "Flag" membership and revert to
      "int".

      >>> from enum import Flag, EJECT, auto
      >>> class EjectFlag(Flag, boundary=EJECT):
      ...     RED = auto()
      ...     GREEN = auto()
      ...     BLUE = auto()
      ...
      >>> EjectFlag(2**2 + 2**4)
      20

   KEEP

      Out-of-range values are kept, and the "Flag" membership is kept.
      This is the default for "IntFlag":

         >>> from enum import Flag, KEEP, auto
         >>> class KeepFlag(Flag, boundary=KEEP):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> KeepFlag(2**2 + 2**4)
         <KeepFlag.BLUE|16: 20>

   Ajouté dans la version 3.11.

class enum.EnumDict

   *EnumDict* is a subclass of "dict" that is used as the namespace
   for defining enum classes (see Préparation de l'espace de nommage
   de la classe). It is exposed to allow subclasses of "EnumType" with
   advanced behavior like having multiple values per member. It should
   be called with the name of the enum class being created, otherwise
   private names and internal classes will not be handled correctly.

   Note that only the "MutableMapping" interface ("__setitem__()" and
   "update()") is overridden. It may be possible to bypass the checks
   using other "dict" operations like "|=".

   member_names

      A list of member names.

   Ajouté dans la version 3.13.

======================================================================


Noms de la forme "__dunder__" disponibles
-----------------------------------------

"__members__" is a read-only ordered mapping of "member_name":"member"
items.  It is only available on the class.

"__new__()", if specified, must create and return the enum members; it
is also a very good idea to set the member's "_value_" appropriately.
Once all the members are created it is no longer used.


Noms de la forme "_sunder_" disponibles
---------------------------------------

* "_name_" -- name of the member

* "_value_" -- value of the member; can be set in "__new__"

* "_missing_()" -- a lookup function used when a value is not found;
  may be overridden

* "_ignore_" -- a list of names, either as a "list" or a "str", that
  will not be transformed into members, and will be removed from the
  final class

* "_order_" -- no longer used, kept for backward compatibility (class
  attribute, removed during class creation)

* "_generate_next_value_()" -- used to get an appropriate value for an
  enum member; may be overridden

* "_add_alias_()" -- adds a new name as an alias to an existing
  member.

* "_add_value_alias_()" -- adds a new value as an alias to an existing
  member.

* While "_sunder_" names are generally reserved for the further
  development of the "Enum" class and can not be used, some are
  explicitly allowed:

  * "_repr_*" (e.g. "_repr_html_"), as used in IPython's rich display

Ajouté dans la version 3.6: "_missing_", "_order_",
"_generate_next_value_"

Ajouté dans la version 3.7: "_ignore_"

Ajouté dans la version 3.13: "_add_alias_", "_add_value_alias_",
"_repr_*"

======================================================================


Utilities and decorators
========================

class enum.auto

   *auto* can be used in place of a value.  If used, the *Enum*
   machinery will call an "Enum"'s "_generate_next_value_()" to get an
   appropriate value. For "Enum" and "IntEnum" that appropriate value
   will be the last value plus one; for "Flag" and "IntFlag" it will
   be the first power-of-two greater than the highest value; for
   "StrEnum" it will be the lower-cased version of the member's name.
   Care must be taken if mixing *auto()* with manually specified
   values.

   *auto* instances are only resolved when at the top level of an
   assignment, either by itself or as part of a tuple:

   * "FIRST = auto()" will work (auto() is replaced with "1");

   * "SECOND = auto(), -2" will work (auto is replaced with "2", so
     "2, -2" is used to create the "SECOND" enum member;

   * "THREE = [auto(), -3]" will *not* work ("[<auto instance>, -3]"
     is used to create the "THREE" enum member)

   Modifié dans la version 3.11.1: In prior versions, "auto()" had to
   be the only thing on the assignment line to work properly.

   "_generate_next_value_" peut être surchargée pour personnaliser les
   valeurs produites par *auto*.

   Note:

     in 3.13 the default "_generate_next_value_" will always return
     the highest member value incremented by 1, and will fail if any
     member is an incompatible type.

@enum.property

   Décorateur similaire au *property* natif, mais spécifique aux
   énumérations. Il permet aux attributs de membre d'avoir les mêmes
   noms que les membres eux-mêmes.

   Note:

     *property* et le membre doivent être définis dans des classes
     distinctes ; par exemple, les attributs *value* et *name* sont
     définis dans la classe *Enum*, et les sous-classes d'*Enum*
     peuvent définir des membres avec les noms "value" et "name".

   Ajouté dans la version 3.11.

@enum.unique

   A "class" decorator specifically for enumerations.  It searches an
   enumeration's "__members__", gathering any aliases it finds; if any
   are found "ValueError" is raised with the details:

      >>> from enum import Enum, unique
      >>> @unique
      ... class Mistake(Enum):
      ...     ONE = 1
      ...     TWO = 2
      ...     THREE = 3
      ...     FOUR = 3
      ...
      Traceback (most recent call last):
      ...
      ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE

@enum.verify

   Décorateur de "classe" spécifique aux énumérations. Utilisé pour
   spécifier quelles contraintes doivent être vérifiées par les
   membres de l'"EnumCheck" décorée.

   Ajouté dans la version 3.11.

@enum.member

   Décorateur à utiliser dans les énumérations : sa cible devient un
   membre.

   Ajouté dans la version 3.11.

@enum.nonmember

   Décorateur à utiliser dans les énumérations : sa cible ne devient
   pas un membre.

   Ajouté dans la version 3.11.

@enum.global_enum

   A decorator to change the "str()" and "repr()" of an enum to show
   its members as belonging to the module instead of its class. Should
   only be used when the enum members are exported to the module
   global namespace (see "re.RegexFlag" for an example).

   Ajouté dans la version 3.11.

enum.show_flag_values(value)

   Return a list of all power-of-two integers contained in a flag
   *value*.

   Ajouté dans la version 3.11.

enum.bin(num, max_bits=None)

   Like built-in "bin()", except negative values are represented in
   two's complement, and the leading bit always indicates sign ("0"
   implies positive, "1" implies negative).

   >>> import enum
   >>> enum.bin(10)
   '0b0 1010'
   >>> enum.bin(~10)   # ~10 is -11
   '0b1 0101'

   Ajouté dans la version 3.11.

======================================================================


Notes
=====

"IntEnum", "StrEnum" et "IntFlag"

   Ces trois types d'énumération sont conçus pour remplacer
   directement les valeurs existantes basées sur des entiers et des
   chaînes ; en tant que tels, ils ont des limitations supplémentaires
   :

   * "__str__" utilise la valeur et pas le nom du membre de
     l'énumération

   * "__format__", parce qu'elle fait appel à "__str__", utilise
     également la valeur du membre de l'énumération au lieu de son nom

   Si ces limitations ne vous conviennent pas, vous pouvez créer votre
   propre classe mère en mélangeant vous-même le type "int" ou "str" :

      >>> from enum import Enum
      >>> class MyIntEnum(int, Enum):
      ...     pass

   ou vous pouvez réassigner la "str()" appropriée, etc., dans votre
   énumération :

      >>> from enum import Enum, IntEnum
      >>> class MyIntEnum(IntEnum):
      ...     __str__ = Enum.__str__
