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