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 __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 __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 __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):
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 __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 __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 __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 __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__(metacls, cls, bases, classdict):
if SymEnum in bases:
return SymEnumMeta.__symEnumDerivedNew(metacls, cls, bases,
classdict)
else:
return EnumMeta.__new__(metacls, cls, bases, classdict)
def __new__(*args, **kwargs):
cls = EnumMeta.__new__(*args, **kwargs)
models.update({v: {} for v in cls.__members__.values()})
return cls
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)
