"enum" --- Suporte a enumerações
********************************

Novo na versão 3.4.

**Código-fonte:** Lib/enum.py


Important
^^^^^^^^^

Esta página contêm informação de referência da API. Para tutorial e
discussão de tópicos mais avançados, consulte

* Tutorial básico

* Tutorial avançado

* Livro de receitas de enum

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

Uma enumeração:

* é um conjunto de nomes simbólicos (membros) vinculados a valores
  únicos

* pode ser iterado para retornar seus membros canônicos (ou seja, não
  incluindo apelidos) na ordem de definição

* usa a sintaxe *call* para retornar membros por valor

* usa a sintaxe *index* para retornar membros por nome

As enumerações são criadas usando a sintaxe de "class" ou usando a
sintaxe de chamada de função:

   >>> from enum import Enum

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

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

Embora possamos usar a sintaxe "class" para criar Enums, Enums não são
classes Python normais. Veja Como Enums são diferentes? para mais
detalhes.

Nota:

  Nomenclatura

  * A classe "Color" é uma *enumeração* (ou *enum*)

  * Os atributos "Color.RED", "Color.GREEN", etc., são *membros de
    enumeração* (ou *membros*) e são constantes funcionalmente.

  * Os membros enum têm *nomes* e *valores* (o nome de "Color.RED" é
    "RED", o valor de "Color.BLUE" é "3", etc.)

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


Conteúdo do módulo
==================

   "EnumType"

      O "type" para Enum e suas subclasses.

   "Enum"

      Classe base para criação de constantes enumeradas.

   "IntEnum"

      Classe base para criar constantes enumeradas que também são
      subclasses de "int". (Notas)

   "StrEnum"

      Classe base para criar constantes enumeradas que também são
      subclasses de "str". (Notas)

   "Flag"

      Classe base para criar constantes enumeradas que podem ser
      combinadas usando operações bit a bit sem perder sua associação
      "Flag".

   "IntFlag"

      Classe base para criar constantes enumeradas que podem ser
      combinadas usando operadores bit a bit sem perder sua associação
      "IntFlag". Membros de "IntFlag" também são subclasses de "int".
      (Notas)

   "ReprEnum"

      Usado por "IntEnum", "StrEnum" e "IntFlag" para manter o "str()"
      do tipo misto.

   "EnumCheck"

      Uma enumeração com os valores "CONTINUOUS", "NAMED_FLAGS" e
      "UNIQUE", para uso com "verify()" para garantir que várias
      restrições sejam atendidas por uma determinada enumeração.

   "FlagBoundary"

      Uma enumeração com os valores "STRICT", "CONFORM", "EJECT" e
      "KEEP" que permite um controle mais refinado sobre como valores
      inválidos são tratados em uma enumeração.

   "auto"

      As instâncias são substituídas por um valor apropriado para
      membros Enum. "StrEnum" assume como padrão a versão em
      minúsculas do nome do membro, enquanto outros Enums assumem como
      padrão 1 e aumentam a partir daí.

   "property()"

      Allows "Enum" members to have attributes without conflicting
      with member names.

   "unique()"

      Decorador de classe Enum que garante que apenas um nome seja
      vinculado a cada valor.

   "verify()"

      Decorador de classe Enum que verifica restrições selecionáveis
      pelo usuário em uma enumeração.

   "member()"

      Torna "obj" um membro. Pode ser usado como um decorador.

   "nonmember()"

      Não torna "obj" um membro. Pode ser usado como um decorador.

   "global_enum()"

      Modifica "str()" e "repr()" de uma enumeração para mostrar seus
      membros como pertencentes ao módulo em vez de sua classe, e
      exporta os membros da enumeração para o espaço de nomes global.

   "show_flag_values()"

      Retorna uma lista de todos os inteiros de potência de dois
      contidos em um sinalizador.

Novo na versão 3.6: "Flag", "IntFlag", "auto"

Novo na versão 3.11: "StrEnum", "EnumCheck", "ReprEnum",
"FlagBoundary", "property", "member", "nonmember", "global_enum",
"show_flag_values"

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


Tipos de Dados
==============

class enum.EnumType

   *EnumType* é a *metaclasse* para enumerações *enum*. É possível
   criar subclasse de *EnumType* -- veja Criando subclasses de
   EnumType para detalhes.

   *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.

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

      Este método é chamado de formas diferentes:

      * para procurar um membro existente:

           cls:
              A classe enum sendo chamada.

           valor:
              O valor para procurar.

      * para usar a enumeração "cls" para criar uma nova enumeração
        (somente se a enumeração existente não tiver nenhum membro):

           cls:
              A classe enum sendo chamada.

           valor:
              O nome do novo Enum para criar.

           nomes:
              Os nomes/valores dos membros para o novo Enum.

           módulo:
              O nome do módulo no qual o novo Enum é criado.

           qualname:
              O local real no módulo onde este Enum pode ser
              encontrado.

           tipo:
              Um tipo de mix-in para o novo Enum.

           start:
              O primeiro valor inteiro para o Enum (usado por "auto").

           boundary:
              Como lidar com valores fora do intervalo de operações de
              bits (somente "Flag").

   __contains__(cls, member)

      Retorna "True" se o membro pertencer a "cls":

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

      Nota:

        In Python 3.12 it will be possible to check for member values
        and not just members; until then, a "TypeError" will be raised
        if a non-Enum-member is used in a containment check.

   __dir__(cls)

      Retorna "['__class__', '__doc__', '__members__', '__module__']"
      e os nomes dos membros em *cls*:

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

   __getattr__(cls, name)

      Returns the Enum member in *cls* matching *name*, or raises an
      "AttributeError":

         >>> Color.GREEN
         <Color.GREEN: 2>

   __getitem__(cls, name)

      Retorna o membro Enum em *cls* correspondente a *name* ou
      levanta "KeyError":

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

   __iter__(cls)

      Retorna cada membro em *cls* na ordem de definição:

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

   __len__(cls)

      Retorna o número de membros em *cls*:

         >>> len(Color)
         3

   __reversed__(cls)

      Retorna cada membro em *cls* na ordem inversa de definição:

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

   Novo na versão 3.11: Before 3.11 "enum" used "EnumMeta" type, which
   is kept as an alias.

class enum.Enum

   *Enum* é a classe base para todas as enumerações *enum*.

   name

      O nome usado para definir o membro "Enum":

         >>> Color.BLUE.name
         'BLUE'

   value

      O valor dado ao membro "Enum":

         >>> Color.RED.value
         1

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

      Nota:

        Valores de membros de EnumOs valores dos membros podem ser
        qualquer coisa: "int", "str", etc. Se o valor exato não for
        importante, você pode usar instâncias de "auto" e um valor
        apropriado será escolhido para você. Consulte "auto" para
        obter detalhes.Embora valores mutáveis/não hasheáveis, como
        "dict", "list" ou um mutável "dataclass", possam ser usados,
        eles terão um impacto quadrático no desempenho durante a
        criação em relação ao número total de valores mutáveis/não
        hasheáveis na enumeração.

   _name_

      Nome do membro.

   _value_

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

   _order_

      Não é mais usado, mantido para compatibilidade com versões
      anteriores. (atributo de classe, removido durante a criação da
      classe).

   _ignore_

      "_ignore_" é usado somente durante a criação e é removido da
      enumeração quando a criação é concluída.

      "_ignore_" é uma lista de nomes que não se tornarão membros e
      cujos nomes também serão removidos da enumeração concluída. Veja
      TimePeriod para um exemplo.

   __dir__(self)

      Retorna "['__class__', '__doc__', '__module__', 'name',
      'value']" e quaisquer métodos públicos definidos em
      *self.__class__*:

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

   _generate_next_value_(name, start, count, last_values)

         nome:
            O nome do membro que está sendo definido (por exemplo,
            'RED').

         start:
            O valor inicial do Enum; o padrão é 1.

         count:
            O número de membros atualmente definido, sem incluir este.

         last_values:
            Uma lista de valores anteriores.

      Um *staticmethod* que é usado para determinar o próximo valor
      retornado por "auto":

         >>> from enum import auto
         >>> 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

   __init_subclass__(cls, **kwds)

      Um *classmethod* usado para configurar subclasses subsequentes.
      Por padrão, não faz nada.

   _missing_(cls, value)

      Um *classmethod* para procurar valores não encontrados em *cls*.
      Por padrão, ele não faz nada, mas pode ser substituído para
      implementar um comportamento de pesquisa personalizado:

         >>> from enum import 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'>

   __repr__(self)

      Returns the string used for *repr()* calls.  By default, returns
      the *Enum* name, member name, and value, but can be overridden:

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

      Returns the string used for *str()* calls.  By default, returns
      the *Enum* name and member name, but can be overridden:

         >>> 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:

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

   Nota:

     Using "auto" with "Enum" results in integers of increasing value,
     starting with "1".

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

   Nota:

     Using "auto" with "IntEnum" results in integers of increasing
     value, starting with "1".

   Alterado na versão 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.

   Nota:

     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(StrEnum.member)".

   Nota:

     Using "auto" with "StrEnum" results in the lower-cased member
     name as the value.

   Nota:

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

   Novo na versão 3.11.

class enum.Flag

   *Flag* members support the bitwise operators "&" (*AND*), "|"
   (*OR*), "^" (*XOR*), and "~" (*INVERT*); the results of those
   operators are members of the enumeration.

   __contains__(self, value)

      Returns *True* if value is in 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>]

      Novo na versão 3.11.

   __len__(self):

      Returns number of members in flag:

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

   __bool__(self):

      Returns *True* if any members in flag, *False* otherwise:

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

   __or__(self, other)

      Returns current flag binary or'ed with other:

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

   __and__(self, other)

      Returns current flag binary and'ed with other:

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

   __xor__(self, other)

      Returns current flag binary xor'ed with 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_()

      Function used to format any remaining unnamed numeric values.
      Default is the value's repr; common choices are "hex()" and
      "oct()".

   Nota:

     Using "auto" with "Flag" results in integers that are powers of
     two, starting with "1".

   Alterado na versão 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>

   If any integer operation is performed with an *IntFlag* member, the
   result is not an *IntFlag*:

      >>> Color.RED + 2
      3

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

   * the result is a valid *IntFlag*: an *IntFlag* is returned

   * 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>

   Nota:

     Using "auto" with "IntFlag" results in integers that are powers
     of two, starting with "1".

   Alterado na versão 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()".

   Novo na versão 3.11.

class enum.EnumCheck

   *EnumCheck* contains the options used by the "verify()" decorator
   to ensure various constraints; failed constraints result in a
   "ValueError".

   UNIQUE

      Ensure that each value has only one name:

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

      Ensure that there are no missing values between the lowest-
      valued member and the highest-valued member:

         >>> 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]

   Nota:

     CONTINUOUS and NAMED_FLAGS are designed to work with integer-
     valued members.

   Novo na versão 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>

Novo na versão 3.11.

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


Nomes "__dunder__" suportados
-----------------------------

"__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.


Nomes "_sunder_" suportados
---------------------------

* "_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

  Nota:

    Para classes "Enum" padrão, o próximo valor escolhido é o último
    valor visto incrementado em um.Para as classes "Flag" o próximo
    valor escolhido será a próxima potência de dois mais alta,
    independentemente do último valor visto.

Novo na versão 3.6: "_missing_", "_order_", "_generate_next_value_"

Novo na versão 3.7: "_ignore_"

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


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:

   * "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)

   Alterado na versão 3.11.1: In prior versions, "auto()" had to be
   the only thing on the assignment line to work properly.

   "_generate_next_value_" can be overridden to customize the values
   used by *auto*.

   Nota:

     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

   A decorator similar to the built-in *property*, but specifically
   for enumerations.  It allows member attributes to have the same
   names as members themselves.

   Nota:

     the *property* and the member must be defined in separate
     classes; for example, the *value* and *name* attributes are
     defined in the *Enum* class, and *Enum* subclasses can define
     members with the names "value" and "name".

   Novo na versão 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

   A "class" decorator specifically for enumerations.  Members from
   "EnumCheck" are used to specify which constraints should be checked
   on the decorated enumeration.

   Novo na versão 3.11.

@enum.member

   A decorator for use in enums: its target will become a member.

   Novo na versão 3.11.

@enum.nonmember

   A decorator for use in enums: its target will not become a member.

   Novo na versão 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).

   Novo na versão 3.11.

enum.show_flag_values(value)

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

   Novo na versão 3.11.

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


Notas
=====

"IntEnum", "StrEnum", and "IntFlag"

   These three enum types are designed to be drop-in replacements for
   existing integer- and string-based values; as such, they have extra
   limitations:

   * "__str__" uses the value and not the name of the enum member

   * "__format__", because it uses "__str__", will also use the value
     of the enum member instead of its name

   If you do not need/want those limitations, you can either create
   your own base class by mixing in the "int" or "str" type yourself:

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

   or you can reassign the appropriate "str()", etc., in your enum:

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