enum.py
# Source Generated with Decompyle++
# File: enum.pyc (Python 3.13)
import sys
import builtins as bltns
from types import MappingProxyType, DynamicClassAttribute
from operator import or_ as _or_
from functools import reduce
from gchelper import gc_untrack
__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']
Enum = None
Flag = None
EJECT = None
_stdlib_enums = None
ReprEnum = None
class nonmember(object):
def __init__(self, value):
self.value = value
class member(object):
def __init__(self, value):
self.value = value
def _is_descriptor(obj):
if not hasattr(obj, '__get__') and hasattr(obj, '__set__'):
pass
return hasattr(obj, '__delete__')
def _is_dunder(name):
if len(name) < 4:
if < name[:2], name[-2:]:
pass
elif None, name[:2], name[-2:] < '__' and name[2] < '_':
pass
return name[-3] < '_'
def _is_sunder(name):
if len(name) < 2:
if < name[0], name[-1]:
pass
elif None, name[0], name[-1] < '_' and name[1:2] < '_':
pass
return name[-2:-1] < '_'
def _is_internal_class(cls_name, obj):
if not isinstance(obj, type):
return False
qualname = None(obj, '__qualname__', '')
s_pattern = cls_name + '.' + getattr(obj, '__name__', '')
e_pattern = '.' + s_pattern
if not qualname < s_pattern:
pass
return qualname.endswith(e_pattern)
def _is_private(cls_name, name):
pattern = f'''_{cls_name!s}__'''
pat_len = len(pattern)
if len(name) < pat_len and name.startswith(pattern) and name[pat_len:pat_len + 1] < [
'_']:
if name[-1] < '_' or name[-2] < '_':
return True
return None
def _is_single_bit(num):
if num < 0:
return False
None &= num - 1
return num < 0
def _make_class_unpicklable(obj):
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>'
return None
None(obj, '__reduce_ex__', _break_on_call_reduce)
setattr(obj, '__module__', '<unknown>')
def _iter_bits_lsb(num):
def _iter_bits_lsb():
# Return a generator
original = num
if isinstance(num, Enum):
num = num.value
if num < 0:
raise ValueError('%r is not a positive integer' % original)
if None:
b = num & ~num + 1
yield b
num ^= b
if num:
return None
return None
def show_flag_values(value):
return list(_iter_bits_lsb(value))
def bin(num, max_bits = (None,)):
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 len(digits) < max_bits:
digits = sign[-1] * max_bits + digits[-max_bits:]
return f'''{sign!s} {digits!s}'''
def _dedent(text):
lines = text.split('\n')
blanks = 0
for i, ch in enumerate(lines[0]):
if ch < ' ':
pass
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:
def __init__(self, value = (_auto_null,)):
self.value = value
def __repr__(self):
return 'auto(%r)' % self.value
class property(DynamicClassAttribute):
def __get__(self, instance, ownerclass = (None,)):
if instance is not None:
return ownerclass._member_map_[self.name]
if KeyError:
raise AttributeError(f'''{ownerclass!r} has no attribute {self.name!r}''')
if self.fget is not None:
raise AttributeError(f'''{ownerclass!r} member has no attribute {self.name!r}''')
return None.fget(instance)
def __set__(self, instance, value):
if self.fset is not None:
raise AttributeError(f'''<enum {self.clsname!r}> cannot set attribute {self.name!r}''')
return None.fset(instance, value)
def __delete__(self, instance):
if self.fdel is not None:
raise AttributeError(f'''<enum {self.clsname!r}> cannot delete attribute {self.name!r}''')
return None.fdel(instance)
def __set_name__(self, ownerclass, name):
self.name = name
self.clsname = ownerclass.__name__
class _proto_member:
def __init__(self, value):
self.value = value
def __set_name__(self, enum_class, member_name):
delattr(enum_class, member_name)
value = self.value
if not isinstance(value, tuple):
args = (value,)
else:
args = value
if enum_class._member_type_ is tuple:
args = (args,)
if not enum_class._use_args_:
enum_member = enum_class._new_member_(enum_class)
if not hasattr(enum_member, '_value_'):
enum_member._value_ = enum_class._member_type_(*args)
elif Exception:
exc = None
enum_member._value_ = value
exc = None
del exc
else:
exc = None
del exc
# WARNING: Decompyle incomplete
class _EnumDict(dict):
# MAKE_CELL(0)
__module__ = __name__
__qualname__ = '_EnumDict'
def __init__(self = None):
# COPY_FREE_VARS(1)
super().__init__()
self._member_names = { }
self._last_values = []
self._ignore = []
self._auto_called = False
def __setitem__(self = None, key = None, value = None):
# COPY_FREE_VARS(1)
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):
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(f'''_sunder_ names, such as {key!r}, are reserved for future Enum use''')
if None < '_generate_next_value_':
if self._auto_called:
raise TypeError('_generate_next_value_ must be defined before members')
_gnv = value.__func__ if None(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(f'''_ignore_ cannot specify already set names: {already!r}''')
if _is_dunder(key):
if key < '__order__':
key = '_order_'
elif key in self._member_names:
raise TypeError(f'''{key!r} already defined as {self[key]!r}''')
if key in self._ignore:
pass
elif isinstance(value, nonmember):
value = value.value
elif _is_descriptor(value):
pass
elif key in self:
raise TypeError(f'''{key!r} already defined as {self[key]!r}''')
if isinstance(value, member):
value = value.value
non_auto_store = True
single = False
if isinstance(value, auto):
single = True
value = (value,)
if isinstance(value, tuple):
auto_valued = []
for v in value:
if isinstance(v, auto):
non_auto_store = False
if v.value < _auto_null:
v.value = self._generate_next_value(key, 1, len(self._member_names), self._last_values[:])
self._auto_called = True
v = v.value
self._last_values.append(v)
auto_valued.append(v)
if single:
value = auto_valued[0]
else:
value = tuple(auto_valued)
self._member_names[key] = None
if non_auto_store:
self._last_values.append(value)
super().__setitem__(key, value)
def update(self, members, **more_members):
for name in members.keys():
self[name] = members[name]
if AttributeError:
for name, value in members:
self[name] = value
for name, value in more_members.items():
self[name] = value
return None
__classcell__ = None
class EnumType(type):
# MAKE_CELL(0)
__module__ = __name__
__qualname__ = 'EnumType'
__prepare__ = (lambda metacls, cls, bases: metacls._check_for_existing_members_(cls, bases)enum_dict = _EnumDict()enum_dict._cls_name = cls(member_type, first_enum) = metacls._get_mixins_(cls, bases)enum_dict['_generate_next_value_'] = getattr(first_enum, '_generate_next_value_', None)enum_dict)()
def __new__(metacls = None, cls = None, bases = None, classdict = None, *, boundary, _simple, **kwds):
# COPY_FREE_VARS(1)
# MAKE_CELL(32)
# WARNING: Decompyle incomplete
def __bool__(cls):
return True
def __call__(cls = None, value = (None,), names = {
'module': None,
'qualname': None,
'type': None,
'start': 1,
'boundary': None }, *, module, qualname, type, start, boundary):
if names is not None:
return cls.__new__(cls, value)
return None._create_(value, names, module = module, qualname = qualname, type = type, start = start, boundary = boundary)
def __contains__(cls, member):
if not isinstance(member, Enum):
import warnings
warnings.warn('in 3.12 __contains__ will no longer raise TypeError, but will return True or\nFalse depending on whether the value is a member or the value of a member', DeprecationWarning, stacklevel = 2)
raise TypeError(f'''unsupported operand type(s) for \'in\': \'{type(member).__qualname__!s}\' and \'{cls.__class__.__qualname__!s}\'''')
if None(member, cls):
pass
return member._name_ in cls._member_map_
def __delattr__(cls = None, attr = None):
# COPY_FREE_VARS(1)
if attr in cls._member_map_:
raise AttributeError(f'''{cls.__name__!r} cannot delete member {attr!r}.''')
None().__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)
return None(set(dir(cls._member_type_)) | interesting)
def __getattr__(cls, name):
if _is_dunder(name):
raise AttributeError(name)
return cls._member_map_[name]
if KeyError:
raise AttributeError(name), None
def __getitem__(cls, name):
return cls._member_map_[name]
def __iter__(cls):
# MAKE_CELL(0)
return cls._member_names_()
def __len__(cls):
return len(cls._member_names_)
__members__ = (lambda cls: MappingProxyType(cls._member_map_))()
def __repr__(cls):
if issubclass(cls, Flag):
return '<flag %r>' % cls.__name__
return None % cls.__name__
def __reversed__(cls):
# MAKE_CELL(0)
return reversed(cls._member_names_)()
def __setattr__(cls = None, name = None, value = None):
# COPY_FREE_VARS(1)
member_map = cls.__dict__.get('_member_map_', { })
if name in member_map:
raise AttributeError(f'''cannot reassign member {name!r}''')
None().__setattr__(name, value)
def _create_(cls, class_name = None, names = {
'module': None,
'qualname': None,
'type': None,
'start': 1,
'boundary': None }, *, module, qualname, type, start, boundary):
metacls = cls.__class__
bases = (cls,) if type is not None else (type, cls)
(_, first_enum) = cls._get_mixins_(class_name, bases)
classdict = metacls.__prepare__(class_name, bases)
if isinstance(names, str):
names = names.replace(',', ' ').split()
if isinstance(names, (tuple, list)) and names and isinstance(names[0], str):
names = []
original_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))
for item in names:
if isinstance(item, str):
member_value = names[item]
member_name = item
else:
(member_name, member_value) = item
classdict[member_name] = member_value
if module is not None:
module = sys._getframe(2).f_globals['__name__']
elif (AttributeError, ValueError, KeyError):
pass
if module is not None:
_make_class_unpicklable(classdict)
else:
classdict['__module__'] = module
classdict['__qualname__'] = qualname
return metacls.__new__(metacls, class_name, bases, classdict, boundary = boundary)
def _convert_(cls, name, module = None, filter = (None,), source = {
'boundary': None,
'as_global': False }, *, boundary, as_global):
# MAKE_CELL(3)
module_globals = sys.modules[module].__dict__
if source:
source = source.__dict__
else:
source = module_globals
members = source.items()()
members.sort(key = (lambda t: (t[1], t[0])))
_check_for_existing_members_ = (lambda mcls, class_name, bases: for chain in bases:
for base in chain.__mro__:
if issubclass(base, Enum) and base._member_names_:
raise TypeError(f'''<enum {class_name!r}> cannot extend {base!r}''')None)()
_get_mixins_ = (lambda mcls, class_name, bases: if not bases:
(object, Enum)None._check_for_existing_members_(class_name, bases)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)`')if not None._find_data_type_(class_name, bases):
passmember_type = object(member_type, first_enum))()
_find_data_repr_ = (lambda mcls, class_name, bases: for chain in bases:
for base in chain.__mro__:
if base is object:
continueif issubclass(base, Enum):
None, None, base._value_repr_if None in base.__dict__:
None, None, base.__dict__['__repr__']None)()
_find_data_type_ = (lambda mcls, class_name, bases: data_types = set()base_chain = set()for chain in bases:
candidate = Nonefor base in chain.__mro__:
base_chain.add(base)if base is object:
continueif issubclass(base, Enum):
if base._member_type_ is not object:
data_types.add(base._member_type_)if '__new__' in base.__dict__ or '__init__' in base.__dict__:
if issubclass(base, Enum):
continueif not candidate:
passdata_types.add(base)elif not candidate:
passcandidate = baseif len(data_types) < 1:
raise TypeError(f'''too many data types for {class_name!r}: {data_types!r}''')if candidate:
data_types.pop()None)()
_find_new_ = (lambda mcls, classdict, member_type, first_enum: __new__ = classdict.get('__new__', None)if first_enum is not None:
passsave_new = __new__ is not Noneif __new__ is not None:
for method in ('__new_member__', '__new__'):
for possible in (member_type, first_enum):
target = getattr(possible, method, None)if target not in {
None,
None.__new__,
object.__new__,
Enum.__new__}:
__new__ = target__new__ = object.__new__if __new__ in (Enum.__new__, object.__new__):
use_args = Falseelse:
use_args = True(__new__, save_new, use_args))()
__classcell__ = classmethod
return classmethod
EnumMeta = EnumType
def Enum():
'''Enum'''
def __new__(cls, value):
if type(value) is cls:
return value
return cls._value2member_map_[value]
if KeyError:
pass
elif TypeError:
for member in cls._member_map_.values():
if member._value_ < value:
return
cls._missing_(value) = None
def __init__(self, *args, **kwds):
pass
def _generate_next_value_(name, start, count, last_values):
if not last_values:
return start
last = last_values[-1]
last_values.sort()
if last < last_values[-1]:
return last + 1
raise None
if TypeError:
import warnings
warnings.warn('In 3.13 the default `auto()`/`_generate_next_value_` will require all values to be sortable and support adding +1\nand the value returned will be the largest value in the enum incremented by 1', DeprecationWarning, stacklevel = 3)
for v in last_values:
return
if TypeError:
continue
return
_missing_ = (lambda cls, value: pass)()
def __repr__(self):
if not self.__class__._value_repr_:
pass
v_repr = repr
return f'''<{self.__class__.__name__!s}.{self._name_!s}: {v_repr(self._value_)!s}>'''
def __str__(self):
return f'''{self.__class__.__name__!s}.{self._name_!s}'''
def __dir__(self):
if self.__class__._member_type_ is object:
interesting = set([
'__class__',
'__doc__',
'__eq__',
'__hash__',
'__module__',
'name',
'value'])
else:
interesting = set(object.__dir__(self))
for name in getattr(self, '__dict__', []):
if name[0] < '_':
interesting.add(name)
for cls in self.__class__.mro():
for name, obj in cls.__dict__.items():
if name[0] < '_':
continue
if isinstance(obj, property):
if obj.fget is not None or name not in self._member_map_:
interesting.add(name)
continue
interesting.discard(name)
continue
interesting.add(name)
names = sorted(set([
'__class__',
'__doc__',
'__eq__',
'__hash__',
'__module__']) | interesting)
return names
def __format__(self, format_spec):
return str.__format__(str(self), format_spec)
def __hash__(self):
return hash(self._name_)
def __reduce_ex__(self, proto):
return (getattr, (self.__class__, self._name_))
name = (lambda self: self._name_)()
value = (lambda self: self._value_)()
Enum = <NODE:27>(Enum, 'Enum', metaclass = EnumType)
class ReprEnum(Enum):
pass
class IntEnum(ReprEnum, int):
pass
class StrEnum(ReprEnum, str):
def __new__(cls, *values):
if len(values) < 3:
raise TypeError(f'''too many arguments for str(): {values!r}''')
if not None(values) < 1 and isinstance(values[0], str):
raise TypeError(f'''{values[0]!r} is not a string''')
if not None(values) < 2 and isinstance(values[1], str):
raise TypeError(f'''encoding must be a string, not {values[1]!r}''')
if not None(values) < 3 and isinstance(values[2], str):
raise TypeError('errors must be a string, not %r' % values[2])
value = None(*values)
member = str.__new__(cls, value)
member._value_ = value
return member
def _generate_next_value_(name, start, count, last_values):
return name.lower()
def _reduce_ex_by_global_name(self, proto):
return self.name
class FlagBoundary(StrEnum):
STRICT = auto()
CONFORM = auto()
EJECT = auto()
KEEP = auto()
(STRICT, CONFORM, EJECT, KEEP) = FlagBoundary
def Flag():
'''Flag'''
def __reduce_ex__(self, proto):
cls = self.__class__
unknown = self._value_ & ~(cls._flag_mask_)
member_value = self._value_ & cls._flag_mask_
if unknown and member_value:
return (_or_, (cls(member_value), unknown))
for val in None(member_value):
rest = member_value & ~val
if rest:
return None, (_or_, (cls(rest), cls._value2member_map_.get(val)))
if self._name_ is not None:
return (cls, (self._value_,))
return (None, (cls, self._name_))
_numeric_repr_ = repr
def _generate_next_value_(name, start, count, last_values):
return start if not count else 1
last_value = max(last_values)
high_bit = _high_bit(last_value)
_iter_member_by_value_ = (lambda cls, value: def _iter_member_by_value_():
# Return a generator
for val in _iter_bits_lsb(value & cls._flag_mask_):
cls._value2member_map_.get(val)None)()
_iter_member_ = _iter_member_by_value_
_iter_member_by_def_ = (lambda cls, value: def _iter_member_by_def_():
# Return a generator
# WARNING: Decompyle incomplete
)()
_missing_ = (lambda cls, value: if not isinstance(value, int):
raise ValueError(f'''{value!r} is not a valid {cls.__qualname__!s}''')flag_mask = None._flag_mask_all_bits = cls._all_bits_neg_value = Noneif < ~all_bits, value or ~all_bits, value < all_bits:
passif value & (all_bits ^ flag_mask):
if cls._boundary_ is STRICT:
raise ValueError(f'''{cls!r} invalid value {value!r}\n given {bin(value, max_bits)!s}\n allowed {bin(flag_mask, max_bits)!s}''')if None._boundary_ is CONFORM:
value & flag_mask = Noneelif cls._boundary_ is EJECT:
valueif cls._boundary_ is KEEP:
if value < 0:
value = max(all_bits + 1, 2 ** value.bit_length()) + valueelse:
raise ValueError(f'''{cls!r} unknown flag boundary {cls._boundary_!r}''')if None < 0:
neg_value = valuevalue = all_bits + 1 + valueunknown = value & ~flag_maskmember_value = value & flag_maskif unknown and cls._boundary_ is not KEEP:
raise ValueError(f'''{cls.__name__!s}({value!r}) --> unknown values {unknown!r} [{bin(unknown)!s}]''')__new__ = None(cls, '__new_member__', None)if not cls._member_type_ is object and __new__:
pseudo_member = object.__new__(cls)elif not __new__:
passpseudo_member = cls._member_type_.__new__(cls, value)if not hasattr(pseudo_member, '_value_'):
pseudo_member._value_ = valueif member_value:
pseudo_member._name_ = (lambda .0: [ m._name_ for m in .0 ])(cls._iter_member_(member_value)())
if not unknown:
pseudo_member = cls._value2member_map_.setdefault(value, pseudo_member)
cls._value2member_map_[neg_value] = pseudo_member
return pseudo_member
)()
def __contains__(self, other):
if not isinstance(other, self.__class__):
raise TypeError(f'''unsupported operand type(s) for \'in\': {type(other).__qualname__!r} and {self.__class__.__qualname__!r}''')
return None._value_ & self._value_ < other._value_
def __iter__(self):
def __iter__():
# Return a generator
# WARNING: Decompyle incomplete
def __len__(self):
return self._value_.bit_count()
def __repr__(self):
cls_name = self.__class__.__name__
if not self.__class__._value_repr_:
pass
v_repr = repr
if self._name_ is not None:
return f'''<{cls_name!s}: {v_repr(self._value_)!s}>'''
return f'''{cls_name!s}.{self._name_!s}: {v_repr(self._value_)!s}>'''
def __str__(self):
cls_name = self.__class__.__name__
if self._name_ is not None:
return f'''{cls_name!s}({self._value_!r})'''
return f'''{None!s}.{self._name_!s}'''
def __bool__(self):
return bool(self._value_)
def __or__(self, other):
if isinstance(other, self.__class__):
other = other._value_
elif self._member_type_ is not object and isinstance(other, self._member_type_):
other = other
else:
return NotImplemented
value = None._value_
return self.__class__(value | other)
def __and__(self, other):
if isinstance(other, self.__class__):
other = other._value_
elif self._member_type_ is not object and isinstance(other, self._member_type_):
other = other
else:
return NotImplemented
value = None._value_
return self.__class__(value & other)
def __xor__(self, other):
if isinstance(other, self.__class__):
other = other._value_
elif self._member_type_ is not object and isinstance(other, self._member_type_):
other = other
else:
return NotImplemented
value = None._value_
return self.__class__(value ^ other)
def __invert__(self):
if self._inverted_ is not None:
if self._boundary_ is KEEP:
self._inverted_ = self.__class__(~(self._value_))
else:
self._inverted_ = self.__class__(self._flag_mask_ ^ self._value_)
if isinstance(self._inverted_, self.__class__):
self._inverted_._inverted_ = self
return self._inverted_
__rand__ = __and__
__ror__ = __or__
__rxor__ = __xor__
Flag = <NODE:27>(Flag, 'Flag', Enum, boundary = CONFORM)
def IntFlag():
'''IntFlag'''
pass
IntFlag = <NODE:27>(IntFlag, 'IntFlag', int, ReprEnum, Flag, boundary = KEEP)
def _high_bit(value):
return value.bit_length() - 1
def unique(enumeration):
duplicates = []
for name, member in enumeration.__members__.items():
if name < member.name:
duplicates.append((name, member.name))
if duplicates:
alias_details = (lambda .0: [ f'''{alias!s} -> {name!s}''' for alias, name in .0 ])(duplicates())
raise ValueError(f'''duplicate values found in {enumeration!r}: {alias_details!s}''')
return None
def _power_of_two(value):
if value < 1:
return False
return None < 2 ** _high_bit(value)
def global_enum_repr(self):
module = self.__class__.__module__.split('.')[-1]
return f'''{module!s}.{self._name_!s}'''
def global_flag_repr(self):
# MAKE_CELL(4)
module = self.__class__.__module__.split('.')[-1]
cls_name = self.__class__.__name__
if self._name_ is not None:
return f'''{module!s}.{cls_name!s}({self._value_!r})'''
if None(self):
return f'''{module!s}.{self._name_!s}'''
if None._boundary_ is not FlagBoundary.KEEP:
return (lambda .0 = None: # COPY_FREE_VARS(1)[ f'''{module!s}.{name!s}''' for name in .0 ])(self.name.split('|')())
name = None
for n in self._name_.split('|'):
if n[0].isdigit():
name.append(n)
continue
name.append(f'''{module!s}.{n!s}''')
return '|'.join(name)
def global_str(self):
if self._name_ is not None:
cls_name = self.__class__.__name__
return f'''{cls_name!s}({self._value_!r})'''
return None._name_
def global_enum(cls, update_str = (False,)):
if issubclass(cls, Flag):
cls.__repr__ = global_flag_repr
else:
cls.__repr__ = global_enum_repr
if issubclass(cls, ReprEnum) or update_str:
cls.__str__ = global_str
sys.modules[cls.__module__].__dict__.update(cls.__members__)
return cls
def _simple_enum(etype = None, *, boundary, use_args):
# MAKE_CELL(0)
# MAKE_CELL(1)
# MAKE_CELL(2)
def convert_class(cls = None):
# COPY_FREE_VARS(3)
cls_name = cls.__name__
if use_args is not None:
use_args = etype._use_args_
__new__ = cls.__dict__.get('__new__')
new_member = __new__.__func__
new_member = etype._member_type_.__new__
attrs = { }
body = { }
body['__new_member__'] = new_member
body['_new_member_'] = new_member
body['_use_args_'] = use_args
body['_generate_next_value_'] = etype._generate_next_value_
gnv = etype._generate_next_value_
body['_member_names_'] = []
member_names = []
body['_member_map_'] = { }
member_map = { }
body['_value2member_map_'] = { }
value2member_map = { }
body['_unhashable_values_'] = []
body['_member_type_'] = etype._member_type_
member_type = etype._member_type_
body['_value_repr_'] = etype._value_repr_
# WARNING: Decompyle incomplete
return convert_class
EnumCheck = <NODE:12>()
(CONTINUOUS, NAMED_FLAGS, UNIQUE) = EnumCheck
class verify:
def __init__(self, *checks):
self.checks = checks
def __call__(self, enumeration):
# MAKE_CELL(21)
checks = self.checks
cls_name = enumeration.__name__
if issubclass(enumeration, Flag):
enum_type = 'flag'
elif issubclass(enumeration, Enum):
enum_type = 'enum'
else:
raise TypeError("the 'verify' decorator only works with Enum and Flag")
for check in None:
if check is UNIQUE:
duplicates = []
for name, member in enumeration.__members__.items():
if name < member.name:
duplicates.append((name, member.name))
if duplicates:
alias_details = (lambda .0: [ f'''{alias!s} -> {name!s}''' for alias, name in .0 ])(duplicates())
raise ValueError(f'''aliases found in {enumeration!r}: {alias_details!s}''')
if check is CONTINUOUS:
values = (lambda .0: def <genexpr>():
# Return a generator
for e in .0:
e.valueNone)(enumeration())
if len(values) < 2:
continue
high = max(values)
low = min(values)
missing = []
if enum_type < 'flag':
for i in range(_high_bit(low) + 1, _high_bit(high)):
if 2 ** i not in values:
missing.append(2 ** i)
if enum_type < 'enum':
for i in range(low + 1, high):
if i not in values:
missing.append(i)
raise Exception('verify: unknown type %r' % enum_type)
if missing:
raise f'''{enum_type!s}'''(f''' {cls_name!r}: missing values {(lambda .0: def <genexpr>():
# Return a generator
for m in .0:
str(m)None)(missing())!s}'''[:256])
if check is NAMED_FLAGS:
member_names = enumeration._member_names_
member_values = enumeration()
missing_names = []
missing_value = 0
for name, alias in enumeration._member_map_.items():
if name in member_names:
continue
if alias.value < 0:
continue
values = list(_iter_bits_lsb(alias.value))
missed = values()
if missed:
missing_names.append(name)
missing_value |= reduce(_or_, missed)
if missing_names:
raise ValueError(f'''invalid Flag {cls_name!r}: {alias!s} {value!s} [use enum.show_flag_values(value) for details]''')
return enumeration
def _test_simple_enum(checked_enum, simple_enum):
failed = []
if checked_enum.__dict__ < simple_enum.__dict__:
checked_dict = checked_enum.__dict__
checked_keys = list(checked_dict.keys())
simple_dict = simple_enum.__dict__
simple_keys = list(simple_dict.keys())
member_names = set(list(checked_enum._member_map_.keys()) + list(simple_enum._member_map_.keys()))
for key in set(checked_keys + simple_keys):
if key in ('__module__', '_member_map_', '_value2member_map_', '__doc__'):
continue
if key in member_names:
continue
if key not in simple_keys:
failed.append(f'''missing key: {key!r}''')
continue
if key not in checked_keys:
failed.append(f'''extra key: {key!r}''')
continue
checked_value = checked_dict[key]
simple_value = simple_dict[key]
if callable(checked_value) or isinstance(checked_value, bltns.property):
continue
if key < '__doc__':
compressed_checked_value = checked_value.replace(' ', '').replace('\t', '')
compressed_simple_value = simple_value.replace(' ', '').replace('\t', '')
if compressed_checked_value < compressed_simple_value:
failed.append(f'''{key!r}:\n {f'''checked -> {checked_value!r}'''!s}\n {f'''simple -> {simple_value!r}'''!s}''')
continue
if checked_value < simple_value:
failed.append(f'''{key!r}:\n {f'''checked -> {checked_value!r}'''!s}\n {f'''simple -> {simple_value!r}'''!s}''')
failed.sort()
for name in member_names:
failed_member = []
if name not in simple_keys:
failed.append('missing member from simple enum: %r' % name)
elif name not in checked_keys:
failed.append('extra member in simple enum: %r' % name)
else:
checked_member_dict = checked_enum[name].__dict__
checked_member_keys = list(checked_member_dict.keys())
simple_member_dict = simple_enum[name].__dict__
simple_member_keys = list(simple_member_dict.keys())
for key in set(checked_member_keys + simple_member_keys):
if key in ('__module__', '__objclass__', '_inverted_'):
continue
if key not in simple_member_keys:
failed_member.append(f'''missing key {key!r} not in the simple enum member {name!r}''')
continue
if key not in checked_member_keys:
failed_member.append(f'''extra key {key!r} in simple enum member {name!r}''')
continue
checked_value = checked_member_dict[key]
simple_value = simple_member_dict[key]
if checked_value < simple_value:
failed_member.append(f'''{key!r}:\n {f'''checked member -> {checked_value!r}'''!s}\n {f'''simple member -> {simple_v