enum

class enum.Enum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: object

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

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

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

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

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

class enum.EnumCheck(*values)

Bases: StrEnum

various conditions to check an enumeration for

CONTINUOUS = 'no skipped integer values'

NAMED_FLAGS = 'multi-flag aliases may not contain unnamed flags'

UNIQUE = 'one name per value'

class enum.EnumDict(cls_name=None)

Bases: dict

Track enum member order and ensure member names are not reused.

EnumType will use the names found in self._member_names as the enumeration member names.

member_names

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

enum.EnumMeta

alias of EnumType

class enum.EnumType(cls, bases, classdict, *, boundary=None, _simple=False, **kwds)

Bases: type

Metaclass for Enum

class enum.Flag(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Support for flags

class enum.FlagBoundary(*values)

Bases: StrEnum

control how out of range values are handled “strict” -> error is raised [default for Flag] “conform” -> extra bits are discarded “eject” -> lose flag status “keep” -> keep flag status and all bits [default for IntFlag]

CONFORM = 'conform'

EJECT = 'eject'

KEEP = 'keep'

STRICT = 'strict'

class enum.IntEnum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: int, ReprEnum

Enum where members are also (and must be) ints

class enum.IntFlag(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: int, ReprEnum, Flag

Support for integer-based Flags

class enum.ReprEnum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Only changes the repr(), leaving str() and format() to the mixed-in type.

class enum.StrEnum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, ReprEnum

Enum where members are also (and must be) strings

class enum.auto(value=_auto_null)

Bases: object

Instances are replaced with an appropriate value in Enum class suites.

enum.global_enum(cls, update_str=False)

decorator that makes the repr() of an enum member reference its module instead of its class; also exports all members to the enum’s module’s global namespace

enum.global_enum_repr(self)

use module.enum_name instead of class.enum_name

the module is the last module in case of a multi-module name

enum.global_flag_repr(self)

use module.flag_name instead of class.flag_name

the module is the last module in case of a multi-module name

enum.global_str(self)

use enum_name instead of class.enum_name

class enum.member(value)

Bases: object

Forces item to become an Enum member during class creation.

class enum.nonmember(value)

Bases: object

Protects item from becoming an Enum member during class creation.

enum.pickle_by_enum_name(self, proto)

enum.pickle_by_global_name(self, proto)

class enum.property(fget=None, fset=None, fdel=None, doc=None)

Bases: DynamicClassAttribute

This is a descriptor, used to define attributes that act differently when accessed through an enum member and through an enum class. Instance access is the same as property(), but access to an attribute through the enum class will instead look in the class’ _member_map_ for a corresponding enum member.

member = None

enum.unique(enumeration)

Class decorator for enumerations ensuring unique member values.

class enum.verify(*checks)

Bases: object

Check an enumeration for various constraints. (see EnumCheck)