import sys

import builtins as bltns

from types import MappingProxyType, DynamicClassAttribute

from operator import or_ as _or_

from functools import reduce

__all__ = [

'EnumType', 'EnumMeta',

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

]

# Dummy value for Enum and Flag as there are explicit checks for them

# before they have been created.

# This is also why there are checks in EnumType like `if Enum is not None`

Enum = Flag = EJECT = _stdlib_enums = ReprEnum = None

class nonmember(object):

"""

Protects item from becaming an Enum member during class creation.

"""

def __init__(self, value):

self.value = value

class member(object):

"""

Forces item to became an Enum member during class creation.

"""

def __init__(self, value):

self.value = value

def _is_descriptor(obj):

"""

Returns True if obj is a descriptor, False otherwise.

"""

return (

hasattr(obj, '__get__') or

hasattr(obj, '__set__') or

hasattr(obj, '__delete__')

)

def _is_dunder(name):

"""

Returns True if a __dunder__ name, False otherwise.

"""

return (

len(name) > 4 and

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

name[2] != '_' and

name[-3] != '_'

)

def _is_sunder(name):

"""

Returns True if a _sunder_ name, False otherwise.

"""

return (

len(name) > 2 and

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

name[1:2] != '_' and

name[-2:-1] != '_'

)

def _is_internal_class(cls_name, obj):

# 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

return qualname == s_pattern or qualname.endswith(e_pattern)

def _is_private(cls_name, name):

# 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[pat_len:pat_len+1] != ['_']

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

):

return True

else:

return False

def _is_single_bit(num):

"""

True if only one bit set in num (should be an int)

"""

if num == 0:

return False

num &= num - 1

return num == 0

def _make_class_unpicklable(obj):

"""

Make the given obj un-picklable.

obj should be either a dictionary, or an Enum

"""

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)

setattr(obj, '__module__', '<unknown>')

def _iter_bits_lsb(num):

# num must be an integer

if isinstance(num, Enum):

num = num.value

while num:

b = num & (~num + 1)

yield b

num ^= b

def show_flag_values(value):

return list(_iter_bits_lsb(value))

def bin(num, max_bits=None):

"""

Like built-in bin(), except negative values are represented in

twos-compliment, and the leading bit always indicates sign

(0=positive, 1=negative).

>>> bin(10)

'0b0 1010'

>>> bin(~10) # ~10 is -11

'0b1 0101'

"""

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

return "%s %s" % (sign, digits)

def _dedent(text):

"""

Like textwrap.dedent. Rewritten because we cannot import textwrap.

"""

lines = text.split('\n')

blanks = 0

for i, ch in enumerate(lines[0]):

if ch != ' ':

break

for j, l in enumerate(lines):

lines[j] = l[i:]

return '\n'.join(lines)

class _auto_null:

def __repr__(self):

return '_auto_null'

_auto_null = _auto_null()

class auto:

"""

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

"""

value = _auto_null

def __repr__(self):

return "auto(%r)" % self.value

class property(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.

"""

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

if instance is None:

try:

return ownerclass._member_map_[self.name]

except KeyError:

raise AttributeError(

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

)

else:

if self.fget is None:

raise AttributeError(

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

)

else:

return self.fget(instance)

def __set__(self, instance, value):

if self.fset is None:

raise AttributeError(

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

)

else:

return self.fset(instance, value)

def __delete__(self, instance):

if self.fdel is None:

raise AttributeError(

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

)

else:

return self.fdel(instance)

def __set_name__(self, ownerclass, name):

self.name = name

self.clsname = ownerclass.__name__

class _proto_member:

"""

intermediate step for enum members between class execution and final creation

"""

def __init__(self, value):

self.value = value

def __set_name__(self, enum_class, member_name):

"""

convert each quasi-member into an instance of the new enum class

"""

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

if not hasattr(enum_member, '_value_'):

try:

enum_member._value_ = enum_class._member_type_(*args)

except Exception as exc:

enum_member._value_ = value

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:

raise TypeError(

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

) from None

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 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 _is_single_bit(value)

):

# no other instances found, record this member in _member_names_

enum_class._member_names_.append(member_name)

# get redirect in place before adding to _member_map_

# but check for other instances in parent classes first

need_override = False

descriptor = None

for base in enum_class.__mro__[1:]:

descriptor = base.__dict__.get(member_name)

if descriptor is not None:

if isinstance(descriptor, (property, DynamicClassAttribute)):

break

else:

need_override = True

# keep looking for an enum.property

if descriptor and not need_override:

# previous enum.property found, no further action needed

pass

elif descriptor and need_override:

redirect = property()

redirect.__set_name__(enum_class, member_name)

# Previous enum.property found, but some other inherited attribute

# is in the way; copy fget, fset, fdel to this one.

redirect.fget = descriptor.fget

redirect.fset = descriptor.fset

redirect.fdel = descriptor.fdel

setattr(enum_class, member_name, redirect)

else:

setattr(enum_class, member_name, enum_member)

# now add to _member_map_ (even aliases)

enum_class._member_map_[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)

except TypeError:

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

enum_class._unhashable_values_.append(value)

class _EnumDict(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.

"""

def __init__(self):

super().__init__()

self._member_names = {} # use a dict to keep insertion order

self._last_values = []

self._ignore = []

self._auto_called = False

def __setitem__(self, key, value):

"""

Changes anything not dundered or not a descriptor.

If an enum member name is used twice, an error is raised; duplicate

values are not checked for.

Single underscore (sunder) names are reserved.

"""

if _is_internal_class(self._cls_name, value):

import warnings

warnings.warn(

"In 3.13 classes created inside an enum will not become a member. "

"Use the `member` decorator to keep the current behavior.",

DeprecationWarning,

stacklevel=2,

)

if _is_private(self._cls_name, key):

# also 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_',

):

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

# TODO: uncomment next three lines in 3.12

# elif _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

if isinstance(value, auto):

if value.value == _auto_null:

value.value = self._generate_next_value(

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

)

self._auto_called = True

value = value.value

self._member_names[key] = None

self._last_values.append(value)

super().__setitem__(key, value)

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

self[name] = value

class EnumType(type):

"""

Metaclass for Enum

"""

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

enum_dict._cls_name = 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)

# convert to normal dict

classdict = dict(classdict.items())

#

# 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

# and record integer values in case this will be a Flag

flag_mask = 0

for name in member_names:

value = classdict[name]

if isinstance(value, int):

flag_mask |= value

classdict[name] = _proto_member(value)

#

# house-keeping structures

classdict['_member_names_'] = []

classdict['_member_map_'] = {}

classdict['_value2member_map_'] = {}

classdict['_unhashable_values_'] = []

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_'] = flag_mask

classdict['_all_bits_'] = 2 ** ((flag_mask).bit_length()) - 1

classdict['_inverted_'] = None

try:

exc = None

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

except RuntimeError as e:

# any exceptions raised by member.__new__ will get converted to a

# RuntimeError, so get that original exception back and raise it instead

exc = e.__cause__ or e

if exc is not None:

raise exc

#

# 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, '_all_bits_')

delattr(enum_class, '_inverted_')

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

# ensure _all_bits_ is correct and there are no missing flags

single_bit_total = 0

multi_bit_total = 0

for flag in enum_class._member_map_.values():

flag_value = flag._value_

if _is_single_bit(flag_value):

single_bit_total |= flag_value

else:

# multi-bit flags are considered aliases

multi_bit_total |= flag_value

enum_class._flag_mask_ = single_bit_total

#

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

"""

classes/types should always be True.

"""

return True

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

"""

Either returns an existing member, or creates a new enum class.

This method is used both when an enum class is given a value to match

to an enumeration member (i.e. Color(3)) and for the functional API

(i.e. Color = Enum('Color', names='RED GREEN BLUE')).

When used for the functional API:

`value` will be the name of the new class.

`names` should be either a string of white-space/comma delimited names

(values will start at `start`), or an iterator/mapping of name, value pairs.

`module` should be set to the module this class is being created in;

if it is not set, an attempt to find that module will be made, but if

it fails the class will not be picklable.

`qualname` should be set to the actual location this class can be found

at in its module; by default it is set to the global scope. If this is

not correct, unpickling will fail in some circumstances.

`type`, if set, will be mixed in as the first base class.

"""

if names is None: # simple value lookup

return cls.__new__(cls, value)

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

return cls._create_(

value,

names,

module=module,

qualname=qualname,

type=type,

start=start,

boundary=boundary,

)

def __contains__(cls, member):

"""

Return True if member is a member of this enum

raises TypeError if member is not an enum member

note: in 3.12 TypeError will no longer be raised, and True will also be

returned if member is the value of a member in this enum

"""

if not isinstance(member, Enum):

import warnings

warnings.warn(

"in 3.12 __contains__ will no longer raise TypeError, but will return True or\n"

"False depending on whether the value is a member or the value of a member",

DeprecationWarning,

stacklevel=2,

)

raise TypeError(

"unsupported operand type(s) for 'in': '%s' and '%s'" % (

type(member).__qualname__, cls.__class__.__qualname__))

return isinstance(member, cls) and member._name_ in cls._member_map_

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 __getattr__(cls, name):

"""

Return the enum member matching `name`

We use __getattr__ instead of descriptors or inserting into the enum

class' __dict__ in order to support `name` and `value` being both

properties for enum members (which live in the class' __dict__) and

enum members themselves.

"""

if _is_dunder(name):

raise AttributeError(name)

try:

return cls._member_map_[name]

except KeyError:

raise AttributeError(name) from None

def __getitem__(cls, name):

"""

Return the member matching `name`.

"""

return cls._member_map_[name]

def __iter__(cls):

"""

Return members in definition order.

"""

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

def __len__(cls):

"""

Return the number of members (no aliases)

"""

return len(cls._member_names_)

@bltns.property

def __members__(cls):

"""

Returns a mapping of member name->value.

This mapping lists all enum members, including aliases. Note that this

is a read-only view of the internal mapping.

"""

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 members in reverse definition order.

"""

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

def __setattr__(cls, name, value):

"""

Block attempts to reassign Enum members.

A simple assignment to the class namespace only changes one of the

several possible ways to get an Enum member from the Enum class,

resulting in an inconsistent Enumeration.

"""

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

"""

Convenience method to create a new Enum class.

`names` can be:

* A string containing member names, separated either with spaces or

commas. Values are incremented by 1 from `start`.

* An iterable of member names. Values are incremented by 1 from `start`.

* An iterable of (member name, value) pairs.

* A mapping of member name -> value pairs.

"""

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

# 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

# TODO: replace the frame hack if a blessed way to know the calling

# module is ever developed

if module is None:

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

"""

Create a new Enum subclass that replaces a collection of global constants

"""

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

cls.__reduce_ex__ = _reduce_ex_by_global_name

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 issubclass(base, Enum) and base._member_names_:

raise TypeError(

"<enum %r> cannot extend %r"

% (class_name, base)

)

@classmethod

def _get_mixins_(mcls, class_name, bases):

"""

Returns the type for creating enum members, and the first inherited

enum class.

bases: the tuple of bases that was given to __new__

"""

if not bases:

return object, Enum

mcls._check_for_existing_members_(class_name, bases)

# 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 issubclass(first_enum, Enum):

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 issubclass(base, Enum):

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

return base._value_repr_

elif '__repr__' in base.__dict__:

# this is our data repr

return base.__dict__['__repr__']

return None

@classmethod

def _find_data_type_(mcls, class_name, bases):

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 issubclass(base, Enum):

if base._member_type_ is not object:

data_types.add(base._member_type_)

break

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

if issubclass(base, Enum):

continue

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

"""

Returns the __new__ to be used for creating the enum members.

classdict: the class dictionary given to __new__

member_type: the data type whose __new__ will be used by default

first_enum: enumeration to check for an overriding __new__

"""

# now find the correct __new__, checking to see of one was defined

# by the user; also check earlier enum classes in case a __new__ was

# saved as __new_member__

__new__ = classdict.get('__new__', None)