'EnumType', 'EnumMeta', 'EnumDict',

'Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag', 'ReprEnum',

'auto', 'unique', 'property', 'verify', 'member', 'nonmember',

'FlagBoundary', 'STRICT', 'CONFORM', 'EJECT', 'KEEP',

'global_flag_repr', 'global_enum_repr', 'global_str', 'global_enum',

'EnumCheck', 'CONTINUOUS', 'NAMED_FLAGS', 'UNIQUE',

'pickle_by_global_name', 'pickle_by_enum_name',

"""

def __init__(self, value):

"""

def __init__(self, value):

"""

return (

hasattr(obj, '__get__') or

hasattr(obj, '__set__') or

hasattr(obj, '__delete__')

"""

return (

len(name) > 4 and

name[:2] == name[-2:] == '__' and

name[2] != '_' and

name[-3] != '_'

"""

return (

len(name) > 2 and

name[0] == name[-1] == '_' and

name[1] != '_' and

name[-2] != '_'

# do not use `re` as `re` imports `enum`

if not isinstance(obj, type):

return False

qualname = getattr(obj, '__qualname__', '')

s_pattern = cls_name + '.' + getattr(obj, '__name__', '')

e_pattern = '.' + s_pattern

# do not use `re` as `re` imports `enum`

pattern = '_%s__' % (cls_name, )

pat_len = len(pattern)

if (

len(name) > pat_len

and name.startswith(pattern)

and (name[-1] != '_' or name[-2] != '_')

):

return True

else:

"""

if num == 0:

return False

num &= num - 1

"""

def _break_on_call_reduce(self, proto):

raise TypeError('%r cannot be pickled' % self)

if isinstance(obj, dict):

obj['__reduce_ex__'] = _break_on_call_reduce

obj['__module__'] = '<unknown>'

else:

setattr(obj, '__reduce_ex__', _break_on_call_reduce)

# num must be a positive integer

original = num

if isinstance(num, Enum):

num = num.value

if num < 0:

raise ValueError('%r is not a positive integer' % original)

while num:

b = num & (~num + 1)

yield b

"""

num = num.__index__()

ceiling = 2 ** (num).bit_length()

if num >= 0:

s = bltns.bin(num + ceiling).replace('1', '0', 1)

else:

s = bltns.bin(~num ^ (ceiling - 1) + ceiling)

sign = s[:3]

digits = s[3:]

if max_bits is not None:

if len(digits) < max_bits:

digits = (sign[-1] * max_bits + digits)[-max_bits:]

"""

def __init__(self, value=_auto_null):

self.value = value

def __repr__(self):

"""

member = None

_attr_type = None

_cls_type = None

def __get__(self, instance, ownerclass=None):

if instance is None:

if self.member is not None:

return self.member

else:

raise AttributeError(

'%r has no attribute %r' % (ownerclass, self.name)

)

if self.fget is not None:

# use previous enum.property

return self.fget(instance)

elif self._attr_type == 'attr':

# look up previous attribute

return getattr(self._cls_type, self.name)

elif self._attr_type == 'desc':

# use previous descriptor

return getattr(instance._value_, self.name)

# look for a member by this name.

try:

return ownerclass._member_map_[self.name]

except KeyError:

raise AttributeError(

'%r has no attribute %r' % (ownerclass, self.name)

) from None

def __set__(self, instance, value):

if self.fset is not None:

return self.fset(instance, value)

raise AttributeError(

"<enum %r> cannot set attribute %r" % (self.clsname, self.name)

)

def __delete__(self, instance):

if self.fdel is not None:

return self.fdel(instance)

raise AttributeError(

"<enum %r> cannot delete attribute %r" % (self.clsname, self.name)

)

def __set_name__(self, ownerclass, name):

self.name = name

"""

def __init__(self, value):

self.value = value

def __set_name__(self, enum_class, member_name):

"""

# first step: remove ourself from enum_class

delattr(enum_class, member_name)

# second step: create member based on enum_class

value = self.value

if not isinstance(value, tuple):

args = (value, )

else:

args = value

if enum_class._member_type_ is tuple: # special case for tuple enums

args = (args, ) # wrap it one more time

if not enum_class._use_args_:

enum_member = enum_class._new_member_(enum_class)

else:

enum_member = enum_class._new_member_(enum_class, *args)

if not hasattr(enum_member, '_value_'):

if enum_class._member_type_ is object:

enum_member._value_ = value

else:

try:

enum_member._value_ = enum_class._member_type_(*args)

except Exception as exc:

new_exc = TypeError(

'_value_ not set in __new__, unable to create it'

)

new_exc.__cause__ = exc

raise new_exc

value = enum_member._value_

enum_member._name_ = member_name

enum_member.__objclass__ = enum_class

enum_member.__init__(*args)

enum_member._sort_order_ = len(enum_class._member_names_)

if Flag is not None and issubclass(enum_class, Flag):

if isinstance(value, int):

enum_class._flag_mask_ |= value

if _is_single_bit(value):

enum_class._singles_mask_ |= value

enum_class._all_bits_ = 2 ** ((enum_class._flag_mask_).bit_length()) - 1

# If another member with the same value was already defined, the

# new member becomes an alias to the existing one.

try:

try:

# try to do a fast lookup to avoid the quadratic loop

enum_member = enum_class._value2member_map_[value]

except TypeError:

for name, canonical_member in enum_class._member_map_.items():

if canonical_member._value_ == value:

enum_member = canonical_member

break

else:

raise KeyError

except KeyError:

# this could still be an alias if the value is multi-bit and the

# class is a flag class

if (

Flag is None

or not issubclass(enum_class, Flag)

):

# no other instances found, record this member in _member_names_

enum_class._member_names_.append(member_name)

elif (

Flag is not None

and issubclass(enum_class, Flag)

and isinstance(value, int)

and _is_single_bit(value)

):

# no other instances found, record this member in _member_names_

enum_class._member_names_.append(member_name)

enum_class._add_member_(member_name, enum_member)

try:

# This may fail if value is not hashable. We can't add the value

# to the map, and by-value lookups for this value will be

# linear.

enum_class._value2member_map_.setdefault(value, enum_member)

if value not in enum_class._hashable_values_:

enum_class._hashable_values_.append(value)

except TypeError:

# keep track of the value in a list so containment checks are quick

enum_class._unhashable_values_.append(value)

"""

def __init__(self, cls_name=None):

super().__init__()

self._member_names = {} # use a dict -- faster look-up than a list, and keeps insertion order since 3.7

self._last_values = []

self._ignore = []

self._auto_called = False

self._cls_name = cls_name

def __setitem__(self, key, value):

"""

if self._cls_name is not None and _is_private(self._cls_name, key):

# do nothing, name will be a normal attribute

pass

elif _is_sunder(key):

if key not in (

'_order_',

'_generate_next_value_', '_numeric_repr_', '_missing_', '_ignore_',

'_iter_member_', '_iter_member_by_value_', '_iter_member_by_def_',

'_add_alias_', '_add_value_alias_',

# While not in use internally, those are common for pretty

# printing and thus excluded from Enum's reservation of

# _sunder_ names

) and not key.startswith('_repr_'):

raise ValueError(

'_sunder_ names, such as %r, are reserved for future Enum use'

% (key, )

)

if key == '_generate_next_value_':

# check if members already defined as auto()

if self._auto_called:

raise TypeError("_generate_next_value_ must be defined before members")

_gnv = value.__func__ if isinstance(value, staticmethod) else value

setattr(self, '_generate_next_value', _gnv)

elif key == '_ignore_':

if isinstance(value, str):

value = value.replace(',',' ').split()

else:

value = list(value)

self._ignore = value

already = set(value) & set(self._member_names)

if already:

raise ValueError(

'_ignore_ cannot specify already set names: %r'

% (already, )

)

elif _is_dunder(key):

if key == '__order__':

key = '_order_'

elif key in self._member_names:

# descriptor overwriting an enum?

raise TypeError('%r already defined as %r' % (key, self[key]))

elif key in self._ignore:

pass

elif isinstance(value, nonmember):

# unwrap value here; it won't be processed by the below `else`

value = value.value

elif _is_descriptor(value):

pass

elif self._cls_name is not None and _is_internal_class(self._cls_name, value):

# do nothing, name will be a normal attribute

pass

else:

if key in self:

# enum overwriting a descriptor?

raise TypeError('%r already defined as %r' % (key, self[key]))

elif isinstance(value, member):

# unwrap value here -- it will become a member

value = value.value

non_auto_store = True

single = False

if isinstance(value, auto):

single = True

value = (value, )

if isinstance(value, tuple) and any(isinstance(v, auto) for v in value):

# insist on an actual tuple, no subclasses, in keeping with only supporting

# top-level auto() usage (not contained in any other data structure)

auto_valued = []

t = type(value)

for v in value:

if isinstance(v, auto):

non_auto_store = False

if v.value == _auto_null:

v.value = self._generate_next_value(

key, 1, len(self._member_names), self._last_values[:],

)

self._auto_called = True

v = v.value

self._last_values.append(v)

auto_valued.append(v)

if single:

value = auto_valued[0]

else:

try:

# accepts iterable as multiple arguments?

value = t(auto_valued)

except TypeError:

# then pass them in singly

value = t(*auto_valued)

self._member_names[key] = None

if non_auto_store:

self._last_values.append(value)

super().__setitem__(key, value)

@property

def member_names(self):

return list(self._member_names)

def update(self, members, **more_members):

try:

for name in members.keys():

self[name] = members[name]

except AttributeError:

for name, value in members:

self[name] = value

for name, value in more_members.items():

"""

@classmethod

def __prepare__(metacls, cls, bases, **kwds):

# check that previous enum members do not exist

metacls._check_for_existing_members_(cls, bases)

# create the namespace dict

enum_dict = EnumDict(cls)

# inherit previous flags and _generate_next_value_ function

member_type, first_enum = metacls._get_mixins_(cls, bases)

if first_enum is not None:

enum_dict['_generate_next_value_'] = getattr(

first_enum, '_generate_next_value_', None,

)

return enum_dict

def __new__(metacls, cls, bases, classdict, *, boundary=None, _simple=False, **kwds):

# an Enum class is final once enumeration items have been defined; it

# cannot be mixed with other types (int, float, etc.) if it has an

# inherited __new__ unless a new __new__ is defined (or the resulting

# class will fail).

#

if _simple:

return super().__new__(metacls, cls, bases, classdict, **kwds)

#

# remove any keys listed in _ignore_

classdict.setdefault('_ignore_', []).append('_ignore_')

ignore = classdict['_ignore_']

for key in ignore:

classdict.pop(key, None)

#

# grab member names

member_names = classdict._member_names

#

# check for illegal enum names (any others?)

invalid_names = set(member_names) & {'mro', ''}

if invalid_names:

raise ValueError('invalid enum member name(s) %s' % (

','.join(repr(n) for n in invalid_names)

))

#

# adjust the sunders

_order_ = classdict.pop('_order_', None)

_gnv = classdict.get('_generate_next_value_')

if _gnv is not None and type(_gnv) is not staticmethod:

_gnv = staticmethod(_gnv)

# convert to normal dict

classdict = dict(classdict.items())

if _gnv is not None:

classdict['_generate_next_value_'] = _gnv

#

# data type of member and the controlling Enum class

member_type, first_enum = metacls._get_mixins_(cls, bases)

__new__, save_new, use_args = metacls._find_new_(

classdict, member_type, first_enum,

)

classdict['_new_member_'] = __new__

classdict['_use_args_'] = use_args

#

# convert future enum members into temporary _proto_members

for name in member_names:

value = classdict[name]

classdict[name] = _proto_member(value)

#

# house-keeping structures

classdict['_member_names_'] = []

classdict['_member_map_'] = {}

classdict['_value2member_map_'] = {}

classdict['_hashable_values_'] = [] # for comparing with non-hashable types

classdict['_unhashable_values_'] = [] # e.g. frozenset() with set()

classdict['_unhashable_values_map_'] = {}

classdict['_member_type_'] = member_type

# now set the __repr__ for the value

classdict['_value_repr_'] = metacls._find_data_repr_(cls, bases)

#

# Flag structures (will be removed if final class is not a Flag

classdict['_boundary_'] = (

boundary

or getattr(first_enum, '_boundary_', None)

)

classdict['_flag_mask_'] = 0

classdict['_singles_mask_'] = 0

classdict['_all_bits_'] = 0

classdict['_inverted_'] = None

try:

classdict['_%s__in_progress' % cls] = True

enum_class = super().__new__(metacls, cls, bases, classdict, **kwds)

classdict['_%s__in_progress' % cls] = False

delattr(enum_class, '_%s__in_progress' % cls)

except Exception as e:

# since 3.12 the note "Error calling __set_name__ on '_proto_member' instance ..."

# is tacked on to the error instead of raising a RuntimeError, so discard it

if hasattr(e, '__notes__'):

del e.__notes__

raise

# update classdict with any changes made by __init_subclass__

classdict.update(enum_class.__dict__)

#

# double check that repr and friends are not the mixin's or various

# things break (such as pickle)

# however, if the method is defined in the Enum itself, don't replace

# it

#

# Also, special handling for ReprEnum

if ReprEnum is not None and ReprEnum in bases:

if member_type is object:

raise TypeError(

'ReprEnum subclasses must be mixed with a data type (i.e.'

' int, str, float, etc.)'

)

if '__format__' not in classdict:

enum_class.__format__ = member_type.__format__

classdict['__format__'] = enum_class.__format__

if '__str__' not in classdict:

method = member_type.__str__

if method is object.__str__:

# if member_type does not define __str__, object.__str__ will use

# its __repr__ instead, so we'll also use its __repr__

method = member_type.__repr__

enum_class.__str__ = method

classdict['__str__'] = enum_class.__str__

for name in ('__repr__', '__str__', '__format__', '__reduce_ex__'):

if name not in classdict:

# check for mixin overrides before replacing

enum_method = getattr(first_enum, name)

found_method = getattr(enum_class, name)

object_method = getattr(object, name)

data_type_method = getattr(member_type, name)

if found_method in (data_type_method, object_method):

setattr(enum_class, name, enum_method)

#

# for Flag, add __or__, __and__, __xor__, and __invert__

if Flag is not None and issubclass(enum_class, Flag):

for name in (

'__or__', '__and__', '__xor__',

'__ror__', '__rand__', '__rxor__',

'__invert__'

):

if name not in classdict:

enum_method = getattr(Flag, name)

setattr(enum_class, name, enum_method)

classdict[name] = enum_method

#

# replace any other __new__ with our own (as long as Enum is not None,

# anyway) -- again, this is to support pickle

if Enum is not None:

# if the user defined their own __new__, save it before it gets

# clobbered in case they subclass later

if save_new:

enum_class.__new_member__ = __new__

enum_class.__new__ = Enum.__new__

#

# py3 support for definition order (helps keep py2/py3 code in sync)

#

# _order_ checking is spread out into three/four steps

# - if enum_class is a Flag:

# - remove any non-single-bit flags from _order_

# - remove any aliases from _order_

# - check that _order_ and _member_names_ match

#

# step 1: ensure we have a list

if _order_ is not None:

if isinstance(_order_, str):

_order_ = _order_.replace(',', ' ').split()

#

# remove Flag structures if final class is not a Flag

if (

Flag is None and cls != 'Flag'

or Flag is not None and not issubclass(enum_class, Flag)

):

delattr(enum_class, '_boundary_')

delattr(enum_class, '_flag_mask_')

delattr(enum_class, '_singles_mask_')

delattr(enum_class, '_all_bits_')

delattr(enum_class, '_inverted_')

elif Flag is not None and issubclass(enum_class, Flag):

# set correct __iter__

member_list = [m._value_ for m in enum_class]

if member_list != sorted(member_list):

enum_class._iter_member_ = enum_class._iter_member_by_def_

if _order_:

# _order_ step 2: remove any items from _order_ that are not single-bit

_order_ = [

o

for o in _order_

if o not in enum_class._member_map_ or _is_single_bit(enum_class[o]._value_)

]

#

if _order_:

# _order_ step 3: remove aliases from _order_

_order_ = [

o

for o in _order_

if (

o not in enum_class._member_map_

or

(o in enum_class._member_map_ and o in enum_class._member_names_)

)]

# _order_ step 4: verify that _order_ and _member_names_ match

if _order_ != enum_class._member_names_:

raise TypeError(

'member order does not match _order_:\n %r\n %r'

% (enum_class._member_names_, _order_)

)

#

return enum_class

def __bool__(cls):

"""

return True

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

"""

if cls._member_map_:

# simple value lookup if members exist

if names is not _not_given:

value = (value, names) + values

return cls.__new__(cls, value)

# otherwise, functional API: we're creating a new Enum type

if names is _not_given and type is None:

# no body? no data-type? possibly wrong usage

raise TypeError(

f"{cls} has no members; specify `names=()` if you meant to create a new, empty, enum"

)

return cls._create_(

class_name=value,

names=None if names is _not_given else names,

module=module,

qualname=qualname,

type=type,

start=start,

boundary=boundary,

)

def __contains__(cls, value):

"""Return True if `value` is in `cls`.

if isinstance(value, cls):

return True

if issubclass(cls, Flag):

try:

result = cls._missing_(value)

return isinstance(result, cls)

except ValueError:

pass

return (

value in cls._unhashable_values_ # both structures are lists

or value in cls._hashable_values_

)

def __delattr__(cls, attr):

# nicer error message when someone tries to delete an attribute

# (see issue19025).

if attr in cls._member_map_:

raise AttributeError("%r cannot delete member %r." % (cls.__name__, attr))

super().__delattr__(attr)

def __dir__(cls):

interesting = set([

'__class__', '__contains__', '__doc__', '__getitem__',

'__iter__', '__len__', '__members__', '__module__',

'__name__', '__qualname__',

]

+ cls._member_names_

)

if cls._new_member_ is not object.__new__:

interesting.add('__new__')

if cls.__init_subclass__ is not object.__init_subclass__:

interesting.add('__init_subclass__')

if cls._member_type_ is object:

return sorted(interesting)

else:

# return whatever mixed-in data type has

return sorted(set(dir(cls._member_type_)) | interesting)

def __getitem__(cls, name):

"""

return cls._member_map_[name]

def __iter__(cls):

"""

return (cls._member_map_[name] for name in cls._member_names_)

def __len__(cls):

"""

return len(cls._member_names_)

@bltns.property

def __members__(cls):

"""

return MappingProxyType(cls._member_map_)

def __repr__(cls):

if Flag is not None and issubclass(cls, Flag):

return "<flag %r>" % cls.__name__

else:

return "<enum %r>" % cls.__name__

def __reversed__(cls):

"""

return (cls._member_map_[name] for name in reversed(cls._member_names_))

def __setattr__(cls, name, value):

"""

member_map = cls.__dict__.get('_member_map_', {})

if name in member_map:

raise AttributeError('cannot reassign member %r' % (name, ))

super().__setattr__(name, value)

def _create_(cls, class_name, names, *, module=None, qualname=None, type=None, start=1, boundary=None):

"""

metacls = cls.__class__

bases = (cls, ) if type is None else (type, cls)

_, first_enum = cls._get_mixins_(class_name, bases)

classdict = metacls.__prepare__(class_name, bases)

# special processing needed for names?

if isinstance(names, str):

names = names.replace(',', ' ').split()

if isinstance(names, (tuple, list)) and names and isinstance(names[0], str):

original_names, names = names, []

last_values = []

for count, name in enumerate(original_names):

value = first_enum._generate_next_value_(name, start, count, last_values[:])

last_values.append(value)

names.append((name, value))

if names is None:

names = ()

# Here, names is either an iterable of (name, value) or a mapping.

for item in names:

if isinstance(item, str):

member_name, member_value = item, names[item]

else:

member_name, member_value = item

classdict[member_name] = member_value

if module is None:

try:

module = sys._getframemodulename(2)

except AttributeError:

# Fall back on _getframe if _getframemodulename is missing

try:

module = sys._getframe(2).f_globals['__name__']

except (AttributeError, ValueError, KeyError):

pass

if module is None:

_make_class_unpicklable(classdict)

else:

classdict['__module__'] = module

if qualname is not None:

classdict['__qualname__'] = qualname

return metacls.__new__(metacls, class_name, bases, classdict, boundary=boundary)

def _convert_(cls, name, module, filter, source=None, *, boundary=None, as_global=False):

"""

# convert all constants from source (or module) that pass filter() to

# a new Enum called name, and export the enum and its members back to

# module;

# also, replace the __reduce_ex__ method so unpickling works in

# previous Python versions

module_globals = sys.modules[module].__dict__

if source:

source = source.__dict__

else:

source = module_globals

# _value2member_map_ is populated in the same order every time

# for a consistent reverse mapping of number to name when there

# are multiple names for the same number.

members = [

(name, value)

for name, value in source.items()

if filter(name)]

try:

# sort by value

members.sort(key=lambda t: (t[1], t[0]))

except TypeError:

# unless some values aren't comparable, in which case sort by name

members.sort(key=lambda t: t[0])

body = {t[0]: t[1] for t in members}

body['__module__'] = module

tmp_cls = type(name, (object, ), body)

cls = _simple_enum(etype=cls, boundary=boundary or KEEP)(tmp_cls)

if as_global:

global_enum(cls)

else:

sys.modules[cls.__module__].__dict__.update(cls.__members__)

module_globals[name] = cls

return cls

@classmethod

def _check_for_existing_members_(mcls, class_name, bases):

for chain in bases:

for base in chain.__mro__:

if isinstance(base, EnumType) and base._member_names_:

raise TypeError(

"<enum %r> cannot extend %r"

% (class_name, base)

)

@classmethod

def _get_mixins_(mcls, class_name, bases):

"""

if not bases:

return object, Enum

# ensure final parent class is an Enum derivative, find any concrete

# data type, and check that Enum has no members

first_enum = bases[-1]

if not isinstance(first_enum, EnumType):

raise TypeError("new enumerations should be created as "

"`EnumName([mixin_type, ...] [data_type,] enum_type)`")

member_type = mcls._find_data_type_(class_name, bases) or object

return member_type, first_enum

@classmethod

def _find_data_repr_(mcls, class_name, bases):

for chain in bases:

for base in chain.__mro__:

if base is object:

continue

elif isinstance(base, EnumType):

# if we hit an Enum, use it's _value_repr_

return base._value_repr_

elif '__repr__' in base.__dict__:

# this is our data repr

# double-check if a dataclass with a default __repr__

if (

'__dataclass_fields__' in base.__dict__

and '__dataclass_params__' in base.__dict__

and base.__dict__['__dataclass_params__'].repr

):

return _dataclass_repr

else:

return base.__dict__['__repr__']

return None

@classmethod

def _find_data_type_(mcls, class_name, bases):

# a datatype has a __new__ method, or a __dataclass_fields__ attribute

data_types = set()

base_chain = set()

for chain in bases:

candidate = None

for base in chain.__mro__:

base_chain.add(base)

if base is object:

continue

elif isinstance(base, EnumType):

if base._member_type_ is not object:

data_types.add(base._member_type_)

break

elif '__new__' in base.__dict__ or '__dataclass_fields__' in base.__dict__:

data_types.add(candidate or base)

break

else:

candidate = candidate or base

if len(data_types) > 1:

raise TypeError('too many data types for %r: %r' % (class_name, data_types))

elif data_types:

return data_types.pop()

else:

return None

@classmethod

def _find_new_(mcls, classdict, member_type, first_enum):

"""