enum_class._member_map_ = {} # name->value map
enum_class._member_type_ = member_type
- # save attributes from super classes so we know if we can take
- # the shortcut of storing members in the class dict
- base_attributes = {a for b in enum_class.mro() for a in b.__dict__}
+ # save DynamicClassAttribute attributes from super classes so we know
+ # if we can take the shortcut of storing members in the class dict
+ dynamic_attributes = {k for c in enum_class.mro()
+ for k, v in c.__dict__.items()
+ if isinstance(v, DynamicClassAttribute)}
# Reverse value->name map for hashable values.
enum_class._value2member_map_ = {}
enum_class._member_names_.append(member_name)
# performance boost for any member that would not shadow
# a DynamicClassAttribute
- if member_name not in base_attributes:
+ if member_name not in dynamic_attributes:
setattr(enum_class, member_name, enum_member)
# now add to _member_map_
enum_class._member_map_[member_name] = enum_member
return enum_class
+ def _convert_(cls, name, module, filter, source=None):
+ """
+ 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 = vars(sys.modules[module])
+ if source:
+ source = vars(source)
+ 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])
+ cls = cls(name, members, module=module)
+ cls.__reduce_ex__ = _reduce_ex_by_name
+ module_globals.update(cls.__members__)
+ module_globals[name] = cls
+ return cls
+
+ def _convert(cls, *args, **kwargs):
+ import warnings
+ warnings.warn("_convert is deprecated and will be removed in 3.9, use "
+ "_convert_ instead.", DeprecationWarning, stacklevel=2)
+ return cls._convert_(*args, **kwargs)
+
@staticmethod
def _get_mixins_(bases):
"""Returns the type for creating enum members, and the first inherited
"""The value of the Enum member."""
return self._value_
- @classmethod
- def _convert(cls, name, module, filter, source=None):
- """
- 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 = vars(sys.modules[module])
- if source:
- source = vars(source)
- 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])
- cls = cls(name, members, module=module)
- cls.__reduce_ex__ = _reduce_ex_by_name
- module_globals.update(cls.__members__)
- module_globals[name] = cls
- return cls
-
class IntEnum(int, Enum):
"""Enum where members are also (and must be) ints"""
import enum
import inspect
import pydoc
+import sys
import unittest
import threading
from collections import OrderedDict
yellow = 6
self.assertEqual(MoreColor.magenta.hex(), '5 hexlified!')
+ def test_subclass_duplicate_name(self):
+ class Base(Enum):
+ def test(self):
+ pass
+ class Test(Base):
+ test = 1
+ self.assertIs(type(Test.test), Test)
+
+ def test_subclass_duplicate_name_dynamic(self):
+ from types import DynamicClassAttribute
+ class Base(Enum):
+ @DynamicClassAttribute
+ def test(self):
+ return 'dynamic'
+ class Test(Base):
+ test = 1
+ self.assertEqual(Test.test.test, 'dynamic')
def test_no_duplicates(self):
class UniqueEnum(Enum):
class TestIntEnumConvert(unittest.TestCase):
def test_convert_value_lookup_priority(self):
- test_type = enum.IntEnum._convert(
+ test_type = enum.IntEnum._convert_(
'UnittestConvert',
('test.test_enum', '__main__')[__name__=='__main__'],
filter=lambda x: x.startswith('CONVERT_TEST_'))
self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
def test_convert(self):
- test_type = enum.IntEnum._convert(
+ test_type = enum.IntEnum._convert_(
'UnittestConvert',
('test.test_enum', '__main__')[__name__=='__main__'],
filter=lambda x: x.startswith('CONVERT_TEST_'))
if name[0:2] not in ('CO', '__')],
[], msg='Names other than CONVERT_TEST_* found.')
+ @unittest.skipUnless(sys.version_info[:2] == (3, 8),
+ '_convert was deprecated in 3.8')
+ def test_convert_warn(self):
+ with self.assertWarns(DeprecationWarning):
+ enum.IntEnum._convert(
+ 'UnittestConvert',
+ ('test.test_enum', '__main__')[__name__=='__main__'],
+ filter=lambda x: x.startswith('CONVERT_TEST_'))
+
+ @unittest.skipUnless(sys.version_info >= (3, 9),
+ '_convert was removed in 3.9')
+ def test_convert_raise(self):
+ with self.assertRaises(AttributeError):
+ enum.IntEnum._convert(
+ 'UnittestConvert',
+ ('test.test_enum', '__main__')[__name__=='__main__'],
+ filter=lambda x: x.startswith('CONVERT_TEST_'))
+
if __name__ == '__main__':
unittest.main()
projects / python / commitdiff