def withLimits(enumeration: enum.EnumMeta) -> enum.EnumMeta:
none_flag = enumeration(0)
# Only add ALL flag if enum is non empty to avoid exception.
if len(enumeration) > 0:
all_flag = enumeration(functools.reduce(operator.ior, enumeration))
enumeration._member_map_['ALL'] = all_flag
enumeration._member_map_['NONE'] = none_flag
return enumeration
def _to_enum_contents(name: str, bases: Bases,
contents: Dict[str, Any]) -> Dict[str, Any]:
result = EnumMeta.__prepare__(name, bases)
# can't use `update` method because `_EnumDict` overloads `__setitem__`
for name, content in contents.items():
result[name] = content
return result
def __symEnumDerivedNew(metacls, cls, bases, classdict):
"update class fields defined as SymEnumValue to register external names"
extNameMap = classdict["__extNameMap__"] = _SysEnumExternalNameMap()
for name in classdict.iterkeys():
if isinstance(classdict[name], SymEnumValue):
SymEnumMeta.__symEnumValueUpdate(classdict, name, extNameMap)
return EnumMeta.__new__(metacls, cls, bases, classdict)
def __new__(cls, name, bases, attrs):
classes = {}
for n, v in filter(lambda i: inspect.isclass(i[1]), attrs.items()):
ln = n.lower()
if ln in classes:
raise AttributeError('Member ' + ln + ' already exists.\
Please check that no [class name].lower() conflicts.')
classes[ln] = (n, v)
for n, _ in classes.values():
del attrs[n]
if hasattr(attrs, '_member_names'):
attrs._member_names.remove(n)
enum = BaseEnumMeta.__new__(cls, name, bases, attrs)
for member in enum:
for ln, clas in [(ln, v[1]) for ln, v in classes.items()]:
try:
setattr(member, ln, getattr(clas, member.name))
except AttributeError:
pass
if not hasattr(member, "label"):
member.label = member.name.replace('_', ' ').title()
return enum
def __symEnumDerivedNew(metacls, cls, bases, classdict):
"update class fields defined as SymEnumValue to register external names"
extNameMap = classdict["__extNameMap__"] = _SysEnumExternalNameMap()
for name in classdict.iterkeys():
if isinstance(classdict[name], SymEnumValue):
SymEnumMeta.__symEnumValueUpdate(classdict, name, extNameMap)
return EnumMeta.__new__(metacls, cls, bases, classdict)
def __getitem__(cls, name):
try:
return _EnumMeta.__getitem__(cls, name)
except KeyError:
pass
raise ValueError('kind must be one of: {}'.format(', '.join(
"'{}'".format(i.name) for i in cls)))
def __new__(metacls, cls, bases, classdict):
enum_class = EnumMeta.__new__(metacls, cls, bases, classdict)
for name, enum_value in enum_class._member_map_.items():
prop_name = 'is_{}'.format(name.lower())
setattr(enum_class, prop_name, is_member_factory(enum_value))
return enum_class
def random_enum(e: enum.EnumMeta) -> enum.EnumMeta:
"""
随机从枚举中取一个值
:param e:
:return:
"""
return random_list(list(e.__iter__()))
def __new__(cls, name, bases, attrs):
Labels = attrs.get('Labels')
obj = BaseEnumMeta.__new__(cls, name, bases, attrs)
for m in obj:
try:
m.label = getattr(Labels, m.name)
except AttributeError:
m.label = m.name.replace('_', ' ').title()
return obj
def __getattr__(cls, name):
# first test for empty element
if name == DynamicEnumMeta.empty_attr:
return EnumMeta.__getattr__(
cls.__get_dynamic_enum_class(
{DynamicEnumMeta.empty_attr: object()}),
DynamicEnumMeta.empty_attr)
# ignore dunder attributes
elif _is_dunder(name):
return EnumMeta.__getattr__(cls, name)
# this avoids recursion
enum_dict = cls.dynamic_enum_dict
if name in enum_dict:
return EnumMeta.__getattr__(
cls.__get_dynamic_enum_class(enum_dict), name)
else:
return EnumMeta.__getattr__(cls, name)
def __call__(cls, value, names=None, module=None, typ=None):
"look up a value object, either by name or value"
if (names is None) and isinstance(value, str):
return SymEnumMeta._lookUpByStr(cls, value)
else:
return EnumMeta.__call__(cls,
value,
names,
module=module,
type=typ)
def __call__(cls, value, *args, **kw):
if isinstance(value, str):
found = cls.findByUUID(value)
if found != None:
return found
if isinstance(value, int):
found = cls.findByHandle(value)
if found != None:
return found
return EnumMeta.__call__(cls, value, *args, **kw)
def __call__(cls, value, names=None, module=None, typ=None):
"look up a value object, either by name of value,"
if (names is None) and isinstance(value, str):
# map string name to instance, check for external name
value = cls.__extNameMap__.toIntName(value)
member = cls._member_map_.get(value)
if member is None:
raise ValueError("'%s' is not a member or alias of %s" % (value, cls.__name__))
else:
return member
else:
return EnumMeta.__call__(cls, value, names, module, typ)
def __call__(cls, value, names=None, module=None, typ=None):
"look up a value object, either by name of value,"
if (names is None) and isinstance(value, str):
# map string name to instance, check for external name
value = cls.__extNameMap__.toIntName(value)
member = cls._member_map_.get(value)
if member is None:
raise ValueError("'%s' is not a member or alias of %s" %
(value, cls.__name__))
else:
return member
else:
return EnumMeta.__call__(cls, value, names, module, typ)
def __new__(cls, name, bases, attrs):
Labels = attrs.get('Labels')
if Labels is not None and inspect.isclass(Labels):
del attrs['Labels']
obj = EnumMeta.__new__(cls, name, bases, attrs)
for m in obj:
try:
m.label = getattr(Labels, m.name)
except AttributeError:
m.label = m.name.replace('_', ' ').title()
return obj
def _parse_enum(self, location: str, raw_value: tp.Any, metaclass: enum.EnumMeta):
if not isinstance(raw_value, str):
return self._error(location, f"Expected {metaclass.__name__} (string), got {str(raw_value)}")
try:
enum_value = self._parse_enum_value(raw_value, metaclass)
if isinstance(enum_value.value, tuple):
enum_value._value_ = enum_value.value[0]
return metaclass.__new__(metaclass, enum_value)
except KeyError:
return self._error(location, f"Invalid value for {metaclass.__name__}: {raw_value}")
def __call__(cls,
value,
names=None,
*,
module=None,
qualname=None,
type=None,
start=1): # noqa
return EnumMeta.__call__(cls.__get_dynamic_enum_class(
cls.dynamic_enum_dict),
value,
names=names,
module=module,
qualname=qualname,
type=type,
start=start)
def __new__(mcs, name, bases, attrs):
Labels = attrs.get('Labels')
if Labels is not None and inspect.isclass(Labels):
del attrs['Labels']
if hasattr(attrs, '_member_names'):
attrs._member_names.remove('Labels')
obj = BaseEnumMeta.__new__(mcs, name, bases, attrs)
for m in obj:
try:
m.label = getattr(Labels, m.name)
except AttributeError:
m.label = m.name.replace('_', ' ').title()
return obj
def __new__(mcs, name, bases, attrs):
Labels = attrs.get('Labels')
if Labels is not None and inspect.isclass(Labels):
del attrs['Labels']
if hasattr(attrs, '_member_names'):
attrs._member_names.remove('Labels')
obj = BaseEnumMeta.__new__(mcs, name, bases, attrs)
for m in obj:
try:
m.label = getattr(Labels, m.name)
except AttributeError:
m.label = m.name.replace('_', ' ').title()
return obj
def __contains__(cls, member):
"""
gets a value indicating that given input existed in
the enumeration values.
this method is overridden to be able to check
for existence with `in` keyword. for example:
has_value = 'value' in SomeEnum
:param int | str | CoreEnum member: value to be checked for existence.
:rtype: bool
"""
if isinstance(member, CoreEnum):
return EnumMeta.__contains__(cls, member)
return member in cls._get_values()
def __new__(metacls, cls, bases, classdict):
if type(classdict) is dict:
original_dict = classdict
classdict = _EnumDict()
for k, v in original_dict.items():
classdict[k] = v
temp = _EnumDict()
for k, v in classdict.items():
if k in classdict._member_names:
if v == ():
v = metacls._i
else:
metacls._i = v
metacls._i += 1
temp[k] = v
else:
temp[k] = classdict[k]
return EnumMeta.__new__(metacls, cls, bases, temp)
def _process_enum(cls: EnumMeta,
name: Optional[str] = None,
description: Optional[str] = None) -> EnumMeta:
if not isinstance(cls, EnumMeta):
raise NotAnEnum()
if not name:
name = cls.__name__
description = description
values = [EnumValue(item.name, item.value) for item in cls] # type: ignore
cls._enum_definition = EnumDefinition( # type: ignore
name=name,
values=values,
description=description,
)
return cls
def __new__(mcs, name, bases, attrs):
member_names = attrs._member_names
choices = {
name: attrs[name] if isinstance(attrs[name], Choice)
else Choice(attrs[name], name.replace('_', ' ').title())
for name in member_names
}
attrs._member_names = []
for member_name in member_names:
attrs.pop(member_name)
attrs[member_name] = choices[member_name].value
attrs._member_names = member_names
obj = BaseEnumMeta.__new__(mcs, name, bases, attrs)
for name, choice in choices.items():
m = obj[name]
for k, v in choice.__dict__.items():
if k != 'value':
setattr(m, k, v)
return obj
def __new__(cls, name, bases, clsdict, *, _entity=Entity, **kwargs):
base_entity = _entity
if bases:
base_entities = [
base._entity_ for base in bases if hasattr(base, "_entity_")
]
if base_entities:
base_entity = base_entities[0]
__init__ = clsdict.pop("__init__", None)
__json__ = clsdict.pop("__json__", None)
new_ent = EntityType(name, (base_entity, ), clsdict, **kwargs)
if __init__ is not None:
dict.__setitem__(clsdict, "__init__", __init__)
if __json__ is not None:
dict.__setitem__(clsdict, "__json__", __json__)
new_ent.__fix_entries__ = []
ignore = []
for field in new_ent.__fields__:
key = field._key_
ignore.append(key)
try:
idx = clsdict._member_names.index(key)
except ValueError:
continue
else:
clsdict._member_names.pop(idx)
clsdict._last_values.pop(idx)
cignore = clsdict.get("_ignore_", [])
cignore.extend(ignore)
clsdict["_ignore_"] = ignore
dict.__setitem__(clsdict, "_entity_", new_ent)
return _EnumMeta.__new__(cls, name, bases, clsdict)
def __new__(*args, **kwargs):
cls = EnumMeta.__new__(*args, **kwargs)
models.update({v: {} for v in cls.__members__.values()})
return cls
def __reversed__(cls):
return EnumMeta.__reversed__(
cls.__get_dynamic_enum_class(cls.dynamic_enum_dict))
def __members__(cls):
return EnumMeta.__members__(
cls.__get_dynamic_enum_class(cls.dynamic_enum_dict))
def __get_dynamic_enum_class(cls, enum_dict):
# avoid enum extension error if accessing via the _empty attribute
if (len(cls._member_names_) == 1
and cls._member_names_[0] == DynamicEnumMeta.empty_attr):
cls._member_names_.clear()
return EnumMeta.__call__(cls, cls.__name__, names=enum_dict)
def __iter__(cls):
return EnumMeta.__iter__(
cls.__get_dynamic_enum_class(cls.dynamic_enum_dict))
def __contains__(cls, member):
return EnumMeta.__contains__(
cls.__get_dynamic_enum_class(cls.dynamic_enum_dict), member)
def __new__(metacls, cls, bases, classdict):
if SymEnum in bases:
return SymEnumMeta.__symEnumDerivedNew(metacls, cls, bases,
classdict)
else:
return EnumMeta.__new__(metacls, cls, bases, classdict)
def _to_enum(name: str, bases: Bases, contents: Dict[str, Any]) -> type:
contents = _to_enum_contents(name, bases, contents)
return EnumMeta(name, bases, contents)
def __getitem__(cls, name):
return EnumMeta.__getitem__(
cls.__get_dynamic_enum_class(cls.dynamic_enum_dict), name)
def __delattr__(cls, attr):
EnumMeta.__delattr__(
cls.__get_dynamic_enum_class(cls.dynamic_enum_dict), attr)
def __new__(metacls, cls, bases, classdict):
if SymEnum in bases:
return SymEnumMeta.__symEnumDerivedNew(metacls, cls, bases, classdict)
else:
return EnumMeta.__new__(metacls, cls, bases, classdict)
