o CRhC@sddlmZddlTddlmZddlmZddlmZddl Z gdZ e Z zddlZWney<dZe d YnwzeWn eyLeZYnwzeWn ey^d d ZYnwd Zz%ddlZeed roedddlmZmZmZdZZZ Z!eefZWneydZZZZZZ Z Z!Ynwerzddlm"Zm#Zeeef7ZWn eyYnwz ddlm$Z ee f7ZWn eyYnwz ddlm%Z!ee!f7ZWn eyYnwdZ&Z'Z(Z)Z*dddZ+ddZ,ddZ-ddZ.dddZ ddZ/z ddl0m1Z1e1Z2Wney&e3Z2dZ1YnwGd d!d!e2Z4e4Z5e1dur8e4Z1e4Z6Gd"d#d#e7Z8e8d$e3fiZ9d%d&Z:d'd(Z;d)dZ,d*d+Ze+e?Gd1d2d2eZ@dZZ%ZZ$Z#Z"ZAZBGd3d4d4e3Ze8d5e3fiZCGd6d7d7eZDdd8lEmZe4e_4eDe_D[Gd9d:d:eZFGd;d<d<ZGGd=d>d>eHZIe8d?e7fiZJGd@dAdAe7ZKerGdBdAdAeKeZKeKZeLeKMdCe3fdDe?dEZNeNeOdFdGZPeNdHdIZQeNdJdKZReNeOdLdMZSeNeTdNdOZUeNeOdPdQZVeNeOdRdSZWeNeOdTdUZXeNdVdWZYeNdXdYZZe[r8eNdZd[Z\eNd\d]Z]eNd^d_Z^eNd`daZ_eNdbdcZ`eNdddeZaeNdfdgZbeNdhdiZceNdjdkZdeNdldmZeeNe4dndoZfeNe4dpdqZgeNe4drdsZhepe3ZieKdCeifeNjZ[NdtduZkekZldvdwZmdxdyZne!ree!fZonefZoeKdzeod{d|iZ%Gd}d~d~epe%ZGdddeqe%Z$Gddde$ZrGddde$Zse[rGdddeZte udGdddeZvGdddeZwGdddeZxGdddeZyGdddeZzerGdd d eZ{GdddeZ|dddZ}ddZ~dddZddZzddlmZWneyOGddde$ZYnwe+ee?er^eefZnefZeLeKMdede?dEZeed<eed<eddOZUeeOddZeed<eeOddZeeOddQZVeeOddZeeOddZeddZeddZeddZeddWZYeddYZZereddZneddZeddZeddZeddZedd„Zeed<eed<eed<eKdeejZ#[GddDŽdepe%e#Z"ddɄZdd˄Zdd̈́ZddτZdddфZer2ddlmZddԄZddքZdd؄ZddڄZGdd܄de3ZdS))print_function)*) NamedConstant) NamedTuple) defaultdictN). bit_count is_single_bitbinpropertybitsAddValue MagicValue MultiValueNoAliasUniqueenumauto AddValueEnumMultiValueEnum NoAliasEnum UniqueEnumAutoNumberEnum OrderedEnumuniqueno_arg extend_enum enum_propertyEnumTypeEnumMetaEnumDictEnumIntEnumStrEnumFlagIntFlag LowerStrEnum UpperStrEnumReprEnum SqliteEnumsqlite3 FlagBoundarySTRICTCONFORMEJECTKEEPadd_stdlib_integrationremove_stdlib_integrationexport cls2module_reduce_ex_by_nameshow_flag_valuesr)cCs|D]}|r dSqdS)NTF)iterableelementr6r6M/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/aenum/_enum.pyany's r:r6versionz wrong version)rr!r")r%r$)r#)r(csdur|fdd}|St|tr(|jD] \}}t|tr%||<q|St|ts4trFt|trF|j}|D]\}}||<q;|Std|f)z export([collection,] namespace) -> Export members to target namespace. If collection is not given, act as a decorator. Ncs t|SN)r2) collection namespacer6r9export_decoratorV z export..export_decoratorz %r is not a supported collection) issubclassr__dict__items isinstancer! stdlib_enums __members__ TypeError)r=r?r@ncdatamr6r>r9r2Ns       r2cC$d}|r||dM}|d7}|s|S)aR return number of set bits Counting bits set, Brian Kernighan's way* unsigned int v; // count the number of bits set in v unsigned int c; // c accumulates the total bits set in v for (c = 0; v; c++) { v &= v - 1; } //clear the least significant bit set This method goes through as many iterations as there are set bits. So if we have a 32-bit word with only the high bit set, then it will only go once through the loop. * The C Programming Language 2nd Ed., Kernighan & Ritchie, 1988. This works because each subtraction "borrows" from the lowest 1-bit. For example: loop pass 1 loop pass 2 ----------- ----------- 101000 100000 - 1 - 1 = 100111 = 011111 & 101000 & 100000 = 100000 = 0 It is an excellent technique for Python, since the size of the integer need not be determined beforehand. (from https://wiki.python.org/moin/BitManipulation) rrr6numcountr6r6r9res ! rcCs |dkrdS||dM}|dkS)z> True if only one bit set in value (should be an int) rFrr6valuer6r6r9r s r ccs.|r||d@}|V||N}|sdSdS)zZ Return each bit value one at a time. >>> list(_iter_bits_lsb(6)) [2, 4] rNr6)rRbitr6r6r9_iter_bits_lsbs  rTcCsd|}|dkrt||ddd}n t||d|A}|dd}|dd}|s1d}|durHt||krH|d||| d}d ||fS) z Like built-in bin(), except negative values are represented in twos-compliment, and the leading bit always indicates sign (0=positive, 1=negative). >>> bin(10) '0b0 1010' >>> bin(~10) # ~10 is -11 '0b1 0101' r10rNz%s %s) bit_length _bltin_binreplacelen)rRmax_bitsceilingssigndigitsr6r6r9r s     r cCs tt|Sr<)listrTrQr6r6r9r5 r5)DynamicClassAttributec@s\eZdZdZdddZddZddZd d Zd d Zdd dZ ddZ ddZ ddZ dS)r a This is a descriptor, used to define attributes that act differently when accessed through an enum member and through an enum class. Instance access is the same as property(), but access to an attribute through the enum class will look in the class' _member_map_. NcCs>||_||_||_|p |j|_|du|_tt|dd|_dS)N__isabstractmethod__F)fgetfsetfdel__doc__ overwrite_docboolgetattrrf)selfrgrhridocr6r6r9__init__s   zproperty.__init__cCs<|jr|jnd}t|||j|j|p|j}|jdu|_|Sr<)rkrjtyperhri)rnrgfdocresultr6r6r9getters zproperty.gettercCs8|jrtjnd}t||j||j|j}|jdu|_|Sr<)rkrgrjrqri)rnrhrrrsr6r6r9setter zproperty.settercCs8|jrtjnd}t||j|j||j}|jdu|_|Sr<)rkrgrjrqrh)rnrirrrsr6r6r9deleterrvzproperty.deletercCsZ|jj|j}|jp|jp|j}g}|r|d||r&|d|jdd |S)N%rz function=%sz property(%s), ) ownerclass _member_map_getnamergrhriappend__name__join)rnmemberfuncstringsr6r6r9__repr__szproperty.__repr__cCs|durz|j|jWStytd||jfw|jdur&||S|jdur4td|j|fz|j|jWStyKtd||jfw)Nz%r has no attribute %rzcannot read attribute %r on %rz%r member has no attribute %r)r{r}KeyErrorAttributeErrorrgrhrC)rninstancerzr6r6r9__get__s*        zproperty.__get__cCsD|jdur|jdurtd|j|jf||j|j<dS|||S)Nz%cannot set attribute %r on )rhrgrr}clsnamerC)rnrrRr6r6r9__set__s   zproperty.__set__cCsb|jdur,|js |jrtd|j|jf|j|jvr"|j|j=dStd|j|jf||S)Nz(cannot delete attribute %r on z$no attribute %r on member)rirgrhrr}rrC)rnrr6r6r9 __delete__s    zproperty.__delete__cCs||_|j|_||_dSr<)r}rrrz)rnrzr}r6r6r9 __set_name__+s zproperty.__set_name__)NNNNr<) r __module__ __qualname__rjrprtrurwrrrrrr6r6r6r9r s    r c@eZdZddZdS) SentinelTypecCs d|jS)Nz<%s>rclsr6r6r9r9rAzSentinelType.__repr__N)rrrrr6r6r6r9r8 rSentinelcCs|dkrdS|dt|kS)NrFrU) _high_bitrQr6r6r9 _power_of_two=srcCs^|dvrt|Sd}|dkrd}|}t|d?t|d@}|r-dddd |D}|S) N)rrFrTrrVcSsg|]}d|dkqS)10rVr6).0dr6r6r9 Kzbits..)strr r)rOnegativersr6r6r9r Bsr cCrM)ae return number of set bits Counting bits set, Brian Kernighan's way* unsigned int v; // count the number of bits set in v unsigned int c; // c accumulates the total bits set in v for (c = 0; v; c++) { v &= v - 1; } //clear the least significant bit set This method goes through as many iterations as there are set bits. So if we have a 32-bit word with only the high bit set, then it will only go once through the loop. * The C Programming Language 2nd Ed., Kernighan & Ritchie, 1988. This works because each subtraction "borrows" from the lowest 1-bit. For example: loop pass 1 loop pass 2 ----------- ----------- 101000 100000 - 1 - 1 = 100111 = 011111 & 101000 & 100000 = 100000 = 0 It is an excellent technique for Python, since the size of the integer need not be determined beforehand. rrr6rNr6r6r9rOs  cCs d}|r|d7}|dL}|s|S)Nrrr6)rOlengthr6r6r9bit_lenss rcCs|dko ||d@dkS)z< True if only one bit set in num (should be an int) rrr6)rOr6r6r9r zscCs@t|tr |t}t|d|}t|\}}}}|duo|duS)z6check if new generate method supports *args and **kwdsim_funcN)rE staticmethodrrqrm getargspec)methodargsvarargskeywordsdefaultsr6r6r9_check_auto_argss   rcs|s|St|dtts&tfdd|ddDs"tdt|St|ddztfdd|ddDrGt|dd d WStd ty[t|d d d YSw) zC sorts things by value if all same type; otherwise by name rc3s|] }t|uVqdSr<rqrv sort_typer6r9 zenumsort..rNz$cannot sort items of different typesc3s |] }t|duVqdS)rNrrrr6r9rscS|dSNrr6ir6r6r9zenumsort..keyztry name sort insteadcSrNrr6rr6r6r9rr)rqrBtupleallrHsorted)thingsr6rr9enumsorts   rc@sFeZdZeddZeddZeddZeddZed d Zd d Z d S) EnumConstantsaddvaluez;prepends value(s) from _generate_next_value_ to each member magicvaluez7calls _generate_next_value_ when no arguments are given multivaluez#each member can have several valuesnoaliasz2duplicate valued members are distinct, not aliasedrz(duplicate valued members are not allowedcC|jSr<_name_rnr6r6r9rzEnumConstants.__repr__N) rrrconstantr rrrrrr6r6r6r9rs      rc@sPeZdZdZddZeddZeddZdd Zd d Z d d Z ddZ dS)rz+ Helper class to track args, kwds. cOs(||_t||_t||_d|_dSr<)_argsdictrD_kwdshash_hashr})rnrkwdsr6r6r9rps  z enum.__init__cCrr<)rrr6r6r9rz enum.argscC |jSr<)rcopyrr6r6r9r z enum.kwdscCrr<)rrr6r6r9__hash__rz enum.__hash__cCs(t||jstS|j|jko|j|jkSr<rE __class__NotImplementedrrrnotherr6r6r9__eq__ z enum.__eq__cCs(t||jstS|j|jkp|j|jkSr<rrr6r6r9__ne__rz enum.__ne__cCsng}ddd|jD}|r||dddtt|jD}|r,||d|jjd|fS)NrycSsg|]}d|fqS)rxr6rar6r6r9rsz!enum.__repr__..cSg|] \}}d||fqS)%s=%rr6rkrr6r6r9r%s(%s)) rrr~rrcrrDrr)rnfinalrrr6r6r9rs " z enum.__repr__N) rrrrjrpbltin_propertyrrrrrrr6r6r6r9rs   rno_valuec@s<eZdZdZeZeZgZddZddZ ddZ dd Z d d Z d d Z ddZddZddZddZddZddZerBddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Z d2d3Z!d4d5Z"d6d7Z#d8d9Z$d:d;Z%dd?Z'e(d@dAZ)e)j*dBdAZ)dFdDdEZ+dCS)GrzP Instances are replaced with an appropriate value in Enum class suites. cC0|}|jdd|_|jt||ff|Sr<r _operationsr~_and_rnrnew_autor6r6r9__and__z auto.__and__cC0|}|jdd|_|jt||ff|Sr<rrr6r6r9__rand__rz auto.__rand__cC.|}|jdd|_|jt|ff|Sr<)rrr~_inv_rnrr6r6r9 __invert__zauto.__invert__cCrr<rrr~_or_rr6r6r9__or__ rz auto.__or__cCrr<rrr6r6r9__ror__rz auto.__ror__cCrr<rrr~_xor_rr6r6r9__xor__rz auto.__xor__cCrr<rrr6r6r9__rxor__rz auto.__rxor__cCrr<)rrr~_abs_rr6r6r9__abs__$rz auto.__abs__cCrr<rrr~_add_rr6r6r9__add__*rz auto.__add__cCrr<rrr6r6r9__radd__0rz auto.__radd__cCrr<)rrr~_neg_rr6r6r9__neg__6rz auto.__neg__cCrr<)rrr~_pos_rr6r6r9__pos__<rz auto.__pos__cCrr<rrr~_div_rr6r6r9__div__Crz auto.__div__cCrr<r rr6r6r9__rdiv__Irz auto.__rdiv__cCrr<rrr~ _floordiv_rr6r6r9 __floordiv__Orzauto.__floordiv__cCrr<rrr6r6r9 __rfloordiv__Urzauto.__rfloordiv__cCrr<rrr~ _truediv_rr6r6r9 __truediv__[rzauto.__truediv__cCrr<rrr6r6r9 __rtruediv__arzauto.__rtruediv__cCrr<rrr~_lshift_rr6r6r9 __lshift__grzauto.__lshift__cCrr<rrr6r6r9 __rlshift__mrzauto.__rlshift__cCrr<rrr~_rshift_rr6r6r9 __rshift__srzauto.__rshift__cCrr<rrr6r6r9 __rrshift__yrzauto.__rrshift__cCrr<rrr~_mod_rr6r6r9__mod__rz auto.__mod__cCrr<rrr6r6r9__rmod__rz auto.__rmod__cCrr<rrr~_mul_rr6r6r9__mul__rz auto.__mul__cCrr<r"rr6r6r9__rmul__rz auto.__rmul__cCrr<rrr~_pow_rr6r6r9__pow__rz auto.__pow__cCrr<r&rr6r6r9__rpow__rz auto.__rpow__cCrr<rrr~_sub_rr6r6r9__sub__rz auto.__sub__cCrr<r*rr6r6r9__rsub__rz auto.__rsub__cCs|jrdSd|j|j|jfS)Nz auto(...)zauto(%r, *%r, **%r))r_valuerrrr6r6r9rsz auto.__repr__cCsF|jtur |jr td|jtur|js|jS|jtur|jS|S)Nzauto() object out of sync)r. _auto_nullrrH_resolverr6r6r9rRs z auto.valuecCs|jr||}||_dSr<)rr0r.rnrRr6r6r9rRs  NcCs|j}|jD]5\}}g}|D](}t||r1|jtur*|dur$tS||q||jq||q||}qg|jdd<||_|Sr<)rrrErRr/r~r.)rn base_valueropparamsvaluesparamrRr6r6r9r0s      z auto._resolver<),rrrrjr/ enum_memberr.rrrrrrrrrrrrr PY2r r rrrrrrrrr r!r$r%r(r)r,r-rrrRrur0r6r6r6r9rsT  r)_commonc@s(eZdZdZdZdZdZdZddZdS) _EnumArgSpec)rz all args except *args and **kwds)rzthe name of the *args variable)rUzthe name of the **kwds variable)rXzany default values)z0number of required values (no default available)cCsNt|}|\}}}}|r|dt| }n|dd}tt|||||fSr)rr]r__new__r:)r _new_funcargspecrrrrreqsr6r6r9r<s   z_EnumArgSpec.__new__N) rrrrrrrrequiredr<r6r6r6r9r:s r:c@ eZdZdZddZddZdS) _proto_memberzW intermediate step for enum members between class execution and final creation cCs ||_dSr<rQr1r6r6r9rprAz_proto_member.__init__c snt|||ji}d}d}d}d}ttr&r&tdtr&}dttr7jtur7j}j}n6ttrJj}jfj}jn#ttrVj}j}ntt rbjf}n ttskf}n}|durf|ddi}}~|j sd|j vr|j r|d}|dd}d|j vr|dd}n|}|dd}|dnE|j r|j r|t|j  dd}|js|dt|j j}|dn!|j r|dd}|dd}|dn |j r|dn|}n|}|jtur|f}|js||} n |j|g|Ri|} t| dsB|jtur | _n"z |j|i|| _WntyA} z td} | | _| d} ~ ww| j|| _|| _| j|i|t|j| _tdurt|tr|j O_ t!rw|j"O_"d|j #d|_$|j%r|j&|nt't(} zCz|j)} |j*r| | j+&|Wn-ty|j,D]\} }|j+}| | jkr|j*r| |&||} nqt-YnwWn2t-ytdust|ts|j&|ntdurt|trt!r|j&|Ynw| r3g}| .D]\}}d /|}|&d ||||jfqt0d |j1d /|ft|jtr>| |j_2d}d}d}|j3ddD]5}|j45|}|durt|t6t7frh|}|}d }nt8|r{|}|psd}|px|}qKd}|}qK|rt6}| |_9|:|||dvrt;|dd|_t;|dd|_?t;|dd|_@t;|dd|_A||_B||_CtD|||ntD||| | |jE|<f|}|j r||vr||f7}|| _F|D]E|j r|j)vstGfdd|j,Drt0dfz|j%rtd| |j)<Wqty4|j,| ff7_,YqwdS)zR convert each quasi-member into an instance of the new enum class r6NrrrR_value_z/_value_ not set in __new__, unable to create itrU,z%s --> %s [%r]z%s: duplicate names found: %sz; rdescattr)rrErgrrhrrirc3s|] \}}|kVqdSr<r6rrrLrQr6r9rrz-_proto_member.__set_name__..z%r has already been usedzcannot use dict to store value)HdelattrrRrErrr/rrrMember _multivalue__creating_init_ _auto_init_ _new_args_r] _auto_args_ _member_type_ _use_args_ _new_member_hasattrobjectrC ExceptionrH __cause__r __objclass__rp_member_names_ _sort_order_r$rB _flag_mask_r _singles_mask_rZ _all_bits_ _noalias_r~rrc_value2member_map__unique_r}_value2member_seq_rrDr ValueErrorrr7__mro__rCr|r re is_descriptorrrrmrg_getrh_setri_del _attr_type _cls_typesetattrr{_values_r:)rn enum_class member_namerr init_args extra_mv_argsrmv_argr7excte nonuniqueunhashable_valuecanonical_memberr}messagealiases bad_aliasesfound_descriptordescriptor_type class_typebaserFredirectr5r6rQr9rsf                                        z_proto_member.__set_name__N)rrrrjrprr6r6r6r9rBs rBcsHeZdZdZfddZfddZfddZdd Zd d ZZ S) r zTrack enum member order and ensure member names are not reused. EnumType will use the names found in self._member_names as the enumeration member names. cstt|||_||_||_||_d|_g|_t |_ ||_ t |v|_ }t|v|_t|v|_|j r=|jr=td||jrI|jrItd|||_||_d|_d|_t|v|_g|_g|_|jrhgd|_d|_d|_g|_d|_dS)Nz2%r: AddValue and MagicValue are mutually exclusivez4%r: MultiValue and MagicValue are mutually exclusiver6F)r r classmethodT)superr rp _cls_name_constructor_init_constructor_start_constructor_boundary_generate_next_value _member_namesset_member_names_set _settingsr _addvaluer _magicvaluer _multivaluerH_start_addvalue_value _new_args _auto_args_locked_init_ignore_ignore_init_done _allow_init _last_values _auto_called)rncls_namesettingsstartconstructor_initconstructor_startconstructor_boundaryrrr6r9rps:         zEnumDict.__init__cs||jkr |j|vr tS|js ||vs ||jvs t|s t|r(tt||S|j rD| ||j t |j |jdd}||||Std)Nz"Magic is not set -- why am I here?)r~rrr is_sunder is_dunderr}r __getitem__rrrr]rr __setitem__rTrnrrRrr6r9rs  " zEnumDict.__getitem__cs>d}t|j|r n5t|j|rn-t|r|dvr$td|j|f|js4|dvr4td|j|f|dkrr|jrBtd|jt|t rL| }nt |}||_ t ||j@}|rmtd|jd d d |Dfd|_n|d kr|jrtd |jn|dkr|jrtd|j||_n|dkr.t|t tfs|f}t|t st |}|j|O_t|vrt|vrtd|jt|vrt|vrtd|jtgd}|jD]}||vrtd|j||fd||<q|d|_|d|_|d|_|j |_|jr|jsgd|_ |jr'|jr'd|jvr'|jddt|j}n|dkrq|j r>td|j|}t|t rN|!dd }|jr_d|jvr_|jdd|jrjtd|j||_|}n|d kr|j"r~td!|}|d"urt|t#r|j$}nt|t%rtd#|j|}t#|}t&||_'t(|d$|nt)|r|d%krd&}|jstd|j|fn#|d'krt|t#r|j$}t*||_+n|d(krt|t%st%|}t,|rd|_nI||jvrtd)|j|f||j vr n2t,|s9d*|_||vr&td+|j|||ft-|t.ur<||_/|jr;td,|jn|jrK|jsK|0||}n|jr{t-|turY|f}t|dt1rp|2||df|d-d"}|jrz|0||}nt|t1r|2||}ntt-|turt3d.d |Drg} |D]} t| t1rd*}|2|| } | j4} |j56| | 6| qt| }n:t|t1s|j+o|j+j7} t8|jp| } t|trt8|} nd-} t8|jd-kp| }| | kr|0||}n |jr,t|t1r |j9}n t|ts|f}n|}t8|jt8|kr,td0|j||j|f|j:6||j;|nd|_d*|_t|st)|st|j|st,|s|s[d}n9t|t1ri|j56|j4n+t-|tur|rt|dt1r|j56|dj4n|j56|dn|j56|t||d"S)1zChanges anything not sundured, dundered, nor a descriptor. If an enum member name is used twice, an error is raised; duplicate values are not checked for. Single underscore (sunder) names are reserved. T)_init_ _settings__order__ignore__start__create_pseudo_member__create_pseudo_member_values__generate_next_value_ _boundary__numeric_repr_ _missing__missing_value__missing_name_ _iter_member__iter_member_by_value__iter_member_by_def_z@%r: _sunder_ names, such as %r, are reserved for future Enum use)create_pseudo_member_rrrz"%r: cannot set %r after init phaserz%%r: ignore can only be specified oncez0%r: _ignore_ cannot specify already set names %srycs|]}t|VqdSr<reprrr6r6r9rCz'EnumDict.__setitem__..rz4%r: boundary specified in constructor and class bodyrz1%r: start specified in constructor and class bodyr-%r: NoAlias and Unique are mutually exclusivez*cannot specify both MultiValue and NoAliasrrrrrz"%r: unknown qualifier %r (from %r)rrr)r r|rrRrrz3%r: init specified in constructor and in class bodyrD z0%r: _init_ and MagicValue are mutually exclusiverz4_generate_next_value_ must be defined before membersNzB%r: _generate_next_value must be a staticmethod, not a classmethodr __order__rr<__init_subclass__z%r: attempt to reuse name: %rFz%r: %s already defined as %rz(%r: enum() and AddValue are incompatiblercs|]}t|tVqdSr<)rErrr6r6r9rr6z=%s.%s: number of fields provided do not match init [%r != %r])?is_internal_classr~is_private_namerr`rrrHrE basestringsplitrcrrrrrrrrrrrrrfromkeysrrrrrinsertrr\rr__func__r|rrrhrr:rrbrqrr}_gnvr _convert_autor:rRrr~r@r]rraddr}r r)rnrrR auto_storealreadyallowed_settingsargrgnv auto_valuedrnew_args target_len source_len multi_args test_valuerr6r9rs^                                      "            ,  zEnumDict.__setitem__cCs|js |js |jturU|js|jr|j}nd}|jo|jj}t|jp#|p&d}t|t ur2t|}nd}t|jdkp<|}||krU| ||}d|_ |jrR||_ |S||_|S)Nr6rT) rrrRr/rr@r]rrqrrrr)rnrrRr5rrrrr6r6r9rs$    zEnumDict._convert_autocCs|jr!t|ts |f}|j||jt|j|jddg|R}n|||jt|j|jdd}t|trAt|dkrA|d}|SNrr)rrErrrr]rrrr6r6r9rs ,"z EnumDict._gnv) rrrrjrprrrr __classcell__r6r6rr9r s  # Rr rcseZdZdZed6ddZddZd6fdd Zd d Ze ddddd dfd dZ ddZ ddZ ddZ eddZddZddZddZddZeZdd Zd!d"Zd#d$Zd7d&d'Zd8d(d)Zed*d+Zed,d-Zed.d/Zed0d1Zed2d3Zed4d5Z Z!S)9rzMetaclass for EnumNr6c s|||tdur|dkrd}nd}|du} |du} |du} t|ts'|f}t|}d} d} |||\}|durbt|dd} t| d| } |||O}|pV|jdd}|j } |dura|j }nd}t |vr~|r~d|vr~t|t rz| ddnd |}t|vrt|vrtd |t|vrt|vrtd |tgd }|D]}||vrtd ||fqt|||| | | d}|_dtdur|dkptduotdd|D|_tdurtdd|Drttfvrt|vrdd}t||d<fdd}||d<nOzt|j|_WnFtyYn=w|sKt|dr*t|j|_| r4| |d<d|_|durJt|t rG|!dd"}||_#n t|drWt|j|_| durbt| |d<|S)Nr$TFrrrrRrzvalue rz1%r: MultiValue and NoAlias are mutually exclusiverz%r: unknown qualifier %r)rrrrrr)rflagcsrr<)rBr$rbr6r6r9rArz'EnumType.__prepare__..css|]}|tuVqdSr<)r$rr6r6r9rCrc_sd|f|S)NrUr6)r}rrPr5rrr6r6r9rLsz3EnumType.__prepare__.._generate_next_value_cs||}||_|Sr<)r<rC)r flag_value type_valueobj member_typer6r9r<Os z%EnumType.__prepare__..__new__r<__new_member__rDrr)$_check_for_existing_members_r$rErr _get_mixins_rm_get_settings_rL_order_function_rr rcrrrrHrrrr _member_typer: _base_type baseintegerrSrr:rrrR_inherited_gnvrr\rr)metaclsrbasesinitrrboundaryr initial_flagrrrgenerateorder first_enumrr enum_dictrr<r6rr9 __prepare__s       .            zEnumType.__prepare__cOsdSr<r6)rrrr6r6r9rpiszEnumType.__init__c9 sF t|tur|dd}|dd}|dd}|d|dd} |dd} |dd} |d d} |d d} |d d}|d d}|d d}|dd}|dd}|dd}|dd}|dd}t|d|}t|d|}tfdd|D}|}|j|||d}|r||d<|p|j}| dur|d} | dur| } t |t r|}n| durddt t |D}nt | tr| dd}} nwt| rK|rt |tsd|}td|rd|pddg}g}|D]D\}}|rt |ts |f}|f|}nt||f}|jt|kr7td|jd |jt|d d!d|Df|||qd"dt|| d#D}n| }d$D]}t|}|dur_|||<qO|D]}z ||||<WqctyyYqcw|D]\}}||vr|||<q~~ ~ ~ ~ ~ ~~~d%|_|j} t| td&d'g@}!|!rt d(d |!f|dd} t | tr| dd} |j}|j!}|j"}g}"|j#}#|j$}$d)}%|durd%}%|dd}"d|"vr|"d*dkrtd+t%|v}&t&|v}'t'|v}(t(|v})|)dgd|d}*|*D] }+||+dq|p'|dd}|d },|,dur=t|,t*ur=t*|,},t|}|,durL|,|d <|+|\}-|,||-\}}.}/t*||d,<|/|d-<| D] }||}t-|||<qj|"|d.<|'|d/<|&|d0<|(|d1<|)|d2<g|d3<t |d4<|d5<i|d6<d|d7<||d<||d<||d8<|#|d9<|$|d:<d|d;<|.||d<<|pt|-dd|d<d*|d=<d*|d><d*|d?<d|d@<|D]\}}0t |0t/r|0j0||<qd)}1dA|vrt1urdB}2t2fdCdD|2Dst3|d%}1dE|vrdF|dE<z d}3t4|||Wnt5y?}4z |4j6p4|4}3WYd}4~4nd}4~4ww|3durG|3t7t8kr| D] }j9|:|qNj9D]\}}0|| vrkq`t;|0dGrw|0:|q`tt?durt?|vrňt1urtdIdJ|vrj@_@j@|dJ<dK|vrňjA}5|5t1jAurjB}5|5_AjA|dK<dLD]9}||vrАqt|}6t|d}7t|-|d}8|7dur|7|6kr|dAkr|1rqtC||8|8||<qtDdur$tEtDr$dMD]}||vr"tC|ttD||8||<qt7tFkr9tEtGr8tCdNttGdNntHrQtEtGrQdOD] }5tC|5ttG|5qDttKd?tKd@n,tDdurtEtDrdSdDtdSdDkrۈjL_M| rfdTd| D} j9D]\}}t |tNrt |j0tOr|j0j0|_0q| r!fdUd| D} | jPkr!tdVjP| fS)WNrrrr6rrrrrrrrrrrrrr<rrcs:g|]\}}t|st|st|st|s||fqSr6)rrrrbrrr6r9rsz$EnumType.__new__..)rrcSg|]\}}|qSr6r6rr}rRr6r6r9rrDrrzname r}rRz)%d values expected (%s), %d received (%s)rycSsg|]}t|qSr6rrr6r6r9rrcSg|]}|jqSr6r}rrLr6r6r9rr)rrrrrrrrr<rrrrrrrTmrorzinvalid enum member name(s): %sFrz7'value', if specified, must be the first item in 'init'rQrPrKrJ _magicvalue_r\r^rWr{rOr]r_rLrMrNr _value_repr_rYrZr[ _inverted_ __reduce_ex__)__getnewargs_ex____getnewargs__r __reduce__c3s|]}|jvVqdSr<rCrrr6r9r7rz#EnumType.__new__..rjzAn enumeration.rrzOReprEnum subclasses must be mixed with a data type (i.e. int, str, float, etc.) __format____str__)rrrr)rrrrrrr__cmp__)__le____lt____gt____ge__rrrrcSrr6rrr6r6r9rrr$cSrr6rCrr6r6r9rrcs(g|]}|jvst|jr|qSr6)r{r rCrorjr6r9rs cs.g|]}|jvs|jvr|jvr|qSr6)r{rWrr r6r9rs  z*member order does not match _order_: %r %r)Qrqr poprmrrDrrr|rrE OrderedDictrrcrr\rcallablerrr _defined_len_r]rH_fields_r~rlocalsrrrrr`rrrrrrrr setdefaultrr _find_new_rB_find_data_repr_ nonmemberrRrSr:make_class_unpicklabler< RuntimeErrorrUpyverPY3_6rCrrRr!r}rr(rrrrhr$rBPY2_6intr8rrrHrrrrrW)9rrrclsdictrrrrrrrrrrrrrrrrrr< enum_members original_dict calced_orderrr}rR name_valuerFrr member_names invalid_names creating_initr auto_args auto_initrrrrignorerrrsave_new new_uses_argsr unpicklablemethodsroer class_method obj_method enum_methodr)rrjrr9r<ls                                                                             "   zEnumType.__new__cCdS)z6 classes/types should always be True. Tr6rr6r6r9__bool__zEnumType.__bool__rc Cs,|dur |||S|j|||||||dS)aEither returns an existing member, or creates a new enum class. This method is used both when an enum class is given a value to match to an enumeration member (i.e. Color(3)) and for the functional API (i.e. Color = Enum('Color', names='red green blue')). When used for the functional API: `module`, if set, will be stored in the new class' __module__ attribute; `type`, if set, will be mixed in as the first base class. Note: if `module` is not set this routine will attempt to discover the calling module by walking the frame stack; if this is unsuccessful the resulting class will not be pickleable. N)modulequalnamerqrr)r<_create_)rrRnamesr0r1rqrrr6r6r9__call__s zEnumType.__call__cCsBt||rdSz||jvWSty |dd|jDvYSw)zReturn True if `value` is in `cls`. `value` is in `cls` if: 1) `value` is a member of `cls`, or 2) `value` is the value of one of the `cls`'s members. TcSrr6r6rGr6r6r9rrz)EnumType.__contains__..)rEr]rHr_rrRr6r6r9 __contains__s   zEnumType.__contains__cCsn||jvrtd|j|ft||}t|tr!td|j|ft|tr/td|j|ft||dS)Nz!%s: cannot delete Enum member %r.z%s: cannot delete constant %rz%s: cannot delete property %r) r{rrget_attr_from_chainrErr rq __delattr__)rrF found_attrr6r6r9r8 s       zEnumType.__delattr__cCst|jgd}|jtjur|d|jtjur|dttdr)|ddD]}t ||t t|t t |fvrA||q+|j turKt |St tt |j |BS)N) rr6rjr__iter____len__rGrrr<rr)rprrr)rrWrQrSr<rrr!rRrmr$rOrdir)r interestingrr6r6r9__dir__s        zEnumType.__dir__cCr)zReturns a mapping of member name->value. This mapping lists all enum members, including aliases. Note that this is a copy of the internal mapping. )r{rrr6r6r9rG1s zEnumType.__members__cCsz|j|WStytd}YnwtdurBt|trBd|vrBz|d}|dD]}|||O}q-|WStyA|w||}t||rN|S|)Nr|r) r{r_sysexc_infor$rBrrrE)rr}rorsrIr6r6r9r:s$     zEnumType.__getitem__csfddjDS)Nc3|]}j|VqdSr<r{rr}rr6r9rOrz$EnumType.__iter__..rWrr6rr9r:NszEnumType.__iter__csfddtjDS)Nc3rBr<rCrDrr6r9rRrz(EnumType.__reversed__..)reversedrWrr6rr9 __reversed__QszEnumType.__reversed__cC t|jSr<)r]rWrr6r6r9r;TrAzEnumType.__len__cCs d|jfS)Nz rrr6r6r9rYrdzEnumType.__repr__cCs|jdi}||vrtd|j|ft||}t|tr'td|j|ft|ttfr.cSs|d|dfSrr6tr6r6r9rsz$EnumType._convert_..rcSrrr6rTr6r6r9rr)r0r) varsr@moduleskeyssortrHr/r4r global_enumupdaterG) rr}r0rRrSr as_globalmodule_globalsmembersr6rQr9rOys"     zEnumType._convert_c Cstrt|trz|d}Wntytd|fw|j}|dur(|f} n||f} ||| \} } t| dd} t| d| } t|t rM| dd }t|t t fr|rt|dt r|g} }g}t| D]\}}| ||||dd}|||||fqhd}d}|D])}|durt|t ri}n||| }t|t r|||}}n|\}}|||<q|dur||| }|j||| ||d }|durz td jd }Wn ttfyYnw|durt|n||_|dur||_|S) a|Convenience method to create a new Enum class. `names` can be: * A string containing member names, separated either with spaces or commas. Values are auto-numbered from 1. * An iterable of member names. Values are auto-numbered from 1. * An iterable of (member name, value) pairs. * A mapping of member name -> value. asciiz %r is not representable in ASCIINrrrDrr)rrUr)r8rEunicodeencodeUnicodeEncodeErrorrHrrrmrr\rrrc enumerater~rr<r@ _getframe f_globalsrrrrr)r class_namer3r0r1rqrrrr_rroriginal_names last_valuesrPr}rRitemrrk member_valuerjr6r6r9r2sb              zEnumType._create_cCsFtdurdS|D]}|jD]}t|tr|jrtd||fq qdS)Nz cannot extend %r)r!rarBrWrHmclsrfrchainrzr6r6r9rs z%EnumType._check_for_existing_members_cCsp|rtdur ttfS||||d}|tvr|d}t|ts%td|||p,t}|jr4td||fS)zReturns the type for creating enum members, and the first inherited enum class. bases: the tuple of bases that was given to __new__ NrYzZnew enumerations should be created as `EnumName([mixin_type, ...] [data_type,] enum_type)`z*cannot extend enumerations via subclassing)r!rSrrFrBrH_find_data_type_rW)rmrfrrrr6r6r9rs   zEnumType._get_mixins_cCs|D]@}|jD]:}|tftvrqt|tr|jSd|jvrAd|jvr8d|jvr8|jdjr8tS|jdSqqdS)Nr__dataclass_fields____dataclass_params__) rarSrFrErrrCr_dataclass_reprrlr6r6r9rs        zEnumType._find_data_repr_cCst}|D]L}d}|jD]D}|tftvrq t|tr)|jtur(||jn)q d|jvs3d|jvrLt|tr9q t durCt |t rCq ||pH|n|pO|}q qt |dkr`t d||f|rf| SdS)Nr<rqrz%r: too many data types: %r)rrarSrFrErrOrrC StdlibFlagrBr]rHr )rmrfr data_typesrn candidaterzr6r6r9rps2       zEnumType._find_data_type_cCs@t}|D]}|jD]}t|tr|jD]}||qq q|S)zuReturns the combined _settings_ of all Enum base classes bases: the tuple of bases given to __new__ )rrarBr!rr)rrrnrzr`r6r6r9r5s    zEnumType._get_settings_c Cs|dd}|duo |du}|dur>dD]&}||fD]}t||d}|ddjtjtjtjfvr3|}nq|dur:nqtj}|dusJ|tjtjfvrMd} nd} ||| fS)a Returns the __new__ to be used for creating the enum members. clsdict: the class dictionary given to __new__ member_type: the data type whose __new__ will be used by default first_enum: enumeration to check for an overriding __new__ r<N)rr<FT)r|rmr<rSr! StdlibEnum) rmrrrr<r%rpossibletargetr&r6r6r9rCs0     zEnumType._find_new_)NNr6N)NNF)NNNrN)"rrrrjr|rrpr<r.rr4r6r8r>rrGrr:rGr; __nonzero__rrIrPrOr2rrrrprrrrr6r6rr9rsJ Wx   G      rc@s eZdZdS)rN)rrrr6r6r6r9rwsr!zNGeneric enumeration. Derive from this class to define new enumerations. )rronscCs|jrdSdS)Nz (*values)z\(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)rErr6r6r9 __signature__sr|cOs|j}|dur dSd|vr|dd}|rtt|t|kr+tdt||t||ft||D] \}}t|||q0t|t|krv|t|d}|D]}||t}|tur`td|ft|||qM|rxtdd|dSdSdS)NrRrz,%d arguments expected (%s), %d received (%s)zmissing value for: %rzinvalid keyword(s): %sry) rLr]rHziprhr  undefinedrrX)rnrrrLr}rremaining_argsrRr6r6r9rps0  rpcCst|jvr tdt||ur|Sz|j|WSty Ynty:|jD]\}}||kr7|YSq)Ynw||}t||rG|S|durUt |ddt urU|S|durn|t uret d|j ft d||j ftd|j |f)Nz1NoAlias enumerations cannot be looked up by valuerz"%s() should be called with a value%r is not a valid %szDerror in %s._missing_: returned %r instead of None or a valid member)rrrHrqr]rr_rrErmr.rr`r)rrRrkrrsr6r6r9r<s:        r<cKs8ttkr|r td|fdStt|jdi|dS)Nz unconsumed keyword arguments: %rr6)rrrHr}r!r)rrr6r6r9rs rc OsDt|D]}z|d}Wn tyYqw|}|r |f|S|Sr)rFrH)r}rrPrirr last_value new_valuer6r6r9rs   rcCr-)z'deprecated, use _missing_value_ insteadNr6r5r6r6r9rr/rcC ||S)zused for failed value access)rr5r6r6r9rs rcCr-)zused for failed item accessNr6)rr}r6r6r9rr/rcCs,|jjp|jjj}d|jj|j||jfS)Nz <%s.%s: %s>)rrrCrrr)rnv_reprr6r6r9rsrcCsd|jj|jfSN%s.%s)rrrrr6r6r9rsrcsjjtur tgd}ntfddtD}tdgD] }|ddkr.||q!jD]9}|j D]1\}}|ddkrFq;t |t ra|j dusU|j vr[||q;||q;t |jsl||q;q4t|S)z< Returns all members and all public methods )rrjrrrc3s|] }|jvr|VqdSr<rC)rrIrr6r9r sz__dir__..rCrrgN)rrOrSrr>rmrrrCrDrEr rgr{discardr)rnr=r}rrr6rr9r> s(          r>cCstt||Sr<)rr)rn format_specr6r6r9r rcCrHr<)rrrr6r6r9r! rrcCs|j|jffSr<)rrCrnprotor6r6r9r% srcCtd|jj|jjf)Nzunorderable types: %s() <= %s()rHrrrr6r6r9r) rcCr)Nzunorderable types: %s() < %s()rrr6r6r9r- rrcCr)Nzunorderable types: %s() >= %s()rrr6r6r9r1 rrcCr)Nzunorderable types: %s() > %s()rrr6r6r9r5 rrcCst||jr ||uStSr<rErrrr6r6r9r:  rcCst||jr ||uStSr<rrr6r6r9r@ rrcCrr<rrr6r6r9r}N r}cCrr<rrr6r6r9rRS rrRcCrr<)rirr6r6r9r5X rr5cCrr<rrr6r6r9pickle_by_global_namec rrcCst|j|jffSr<)rmrrrr6r6r9pickle_by_enum_nameh rrcs$jdfddDS)Nryc3s,|]}|jrd|t|fVqdS)rN)rrm)rrdcfrnr6r9rn s z"_dataclass_repr..)rqrrXrr6rr9rsl srsr(rjzIOnly changes the repr(), leaving str() and format() to the mixed-in type.c@seZdZdZdS)r"z8 Enum where members are also (and must be) ints N)rrrrjr6r6r6r9r" r"c@s&eZdZdZddZejZddZdS)r#zr Enum where members are also (and must already be) strings default value is member name, lower-cased cOsb|r td|j|r"t|dts"td|j|dt|dft|}t||}||_|S)Nz#%r: keyword arguments not supportedrz#%s: values must be str [%r is a %r])rHrrErrqr<rC)rr5rrRrr6r6r9r< s  zStrEnum.__new__cC|S)zD Return the lower-cased version of the member name. )lower)r}rrPrir6r6r9r szStrEnum._generate_next_value_N)rrrrjr<rrrr6r6r6r9r# s  r#c@eZdZdZddZdS)r&z} Enum where members are also (and must already be) lower-case strings default value is member name, lower-cased cO6tj||g|Ri|}||krtd||S)Nz%r is not lower-case)r#rrr`rrRrrrr6r6r9r<   zLowerStrEnum.__new__Nrrrrjr<r6r6r6r9r& s r&c@rA)r'z} Enum where members are also (and must already be) upper-case strings default value is member name, upper-cased cOr)Nz%r is not upper-case)r#rupperr`rr6r6r9r< rzUpperStrEnum.__new__cOrr<)r)r}rrPrirrr6r6r9r sz"UpperStrEnum._generate_next_value_N)rrrrjr<rr6r6r6r9r' s r'c@eZdZdZeZdS)AutoEnumza automatically use _generate_next_value_ when values are missing (Python 3 only) N)rrrrjrrr6r6r6r9r rc@r)rz Automatically assign increasing values to members. Py3: numbers match creation order Py2: numbers are assigned alphabetically by member name (unless `_order_` is specified) cOsRt|jd}|jturt||}n|jturt||}nt|}||_|Sr)r]rGrOrr<longrSrC)rrrrRrr6r6r9r< s   zAutoNumberEnum.__new__Nrr6r6r6r9r s rc@seZdZeZdS)rN)rrrr rr6r6r6r9r rrc@r)rz1 Multiple values can map to each member. N)rrrrjrrr6r6r6r9r rrc@r)rzQ Duplicate value members are distinct, but cannot be looked up by value. N)rrrrjrrr6r6r6r9r rrc@s0eZdZdZddZddZddZdd Zd S) rz7 Add ordering based on values of Enum members. cCs|j|jur |j|jkStSr<rrCrrr6r6r9r   zOrderedEnum.__ge__cCs|j|jur |j|jkStSr<rrr6r6r9r rzOrderedEnum.__gt__cCs|j|jur |j|jkStSr<rrr6r6r9r rzOrderedEnum.__le__cCs|j|jur |j|jkStSr<rrr6r6r9r rzOrderedEnum.__lt__N)rrrrjrrrrr6r6r6r9r s  rc@r)r)cCs|tjur|jSdSr<)r*PrepareProtocolr})rnprotocolr6r6r9 __conform__ s zSqliteEnum.__conform__N)rrrrr6r6r6r9r) rc@r)rz+ Ensure no duplicate values exist. N)rrrrjrrr6r6r6r9r rrcsfttj|}|rt|}n|}tfdd|D}||||d}t|_||j|||<dS)aL Create a new Enum subclass that replaces a collection of global constants enum: Enum, IntEnum, ... name: name of new Enum module: name of module (__name__ in global context) filter: function that returns True if name should be converted to Enum member source: namespace to check (defaults to 'module') c3s$|] \}}|r||fVqdSr<r6rrRr6r9r. s"zconvert..r0N) rVr@rWrrDr4rr[rG)rr}r0rRrSr]r^r6rr9convert s   rc$ Os||jvs||jvs|ddt|ddDvr&td||j|||fd}|jddD]}|j|}|durMt|ttfrDn td||j fq/z|j}|j }|j }|j } t d d|D} Wntyutd |fwz|j} t|jv} t|jv} t|jv}|jpg}Wntyg} d } d } d }g}Ynw| r|std |j |j}t|d dpt|ddp|}|sdd|D}t|}t|dd}|dur|r|ddpd}t|dd}|dur|||||f}n|f}|tjurd }nd}t|dkr |\}n|}d}i}t|tr|j}|j}t|ts'|f}n|}d|vrEd|vr9|d}n#|d|dd}}n| r\|d|ddd}}}|r\|f}|turd|f}|su||}t|dst||_ n||g|Ri|}t|ds|||_ |j }| rd|vr|}n|f|}||_!|j"|_#|j$||f||_%t|j |_&d}}t|dr|j'|B}|j(|B}|j)dkrt*t+||@}|rtdt,d-dd|Df| rt.||||dS|j%}|/D]:}t|d|j g}|D],} |D]&}!| |!kr3|s| r#td||ft.|||||dd Sqq qt0t1krBt2f}"nt2t3f}"t4||"rt|drt5|r_t.||||dS||j(@|kr~| |dur~| |}#t.||#|||dd St.||||dd!St.||S)"z/ Add a new member to an existing Enum. cSsg|]}|dqS)rr6)rrUr6r6r9rB rzextend_enum..r_r6z%r already in use as %rNr"%r already in use in superclass %rcSsg|] }|jD]}|qqSr6r)rrrr6r6r9rS rz%r is not a supported EnumFz*no values specified for MultiValue enum %rrQrcSrr6rQrr6r6r9ri rrrYrTrRrrCr[keepz%invalid Flag %r -- missing values: %srycsrr<)r)rrr6r6r9r rzextend_enum..)r maskriz%r is a duplicate of %r)r}r ris_alias)r rr)6rCr{rmrHr|rarEr rerrWrOr]rrrr_rrrrrLr`r<r]rSrrrrr rRrCrrrVrprirXr[rYrrcrTrr_finalize_extend_enumr5rrr$rtrBr )$ enumerationr}rr descriptorrzr{rWrOr]base_attributesr_ _multi_value_ _no_alias_r^rLmt_new_newrirPrrr&rR more_values new_memberr[rYmissed new_valuesrscanonical_values_canonical_valuer flag_bases canonicalr6r6r9r4 s                                     rFc Cs|p|j}d}|jddD]}|j|}|dur,t|ttfr#n td||jfq|s>t}| ||t ||||sF|j |||j |<t|d|jgD]} z||j| <WqStyo|j| |ff7_YqSw|r||_||_t|jr|j|jO_|S)Nrrri)r}rarCr|rEr rerHrrrhrWr~r{rmrCr]r_r[rYr rZ) rrr}r rrrrzr{rr6r6r9r s8        rcCs^g}|jD]\}}||jkr|||jfq|r-ddd|D}td||f|S)zS Class decorator that ensures only unique members exist in an enumeration. rycSr)z%s -> %sr6)raliasr}r6r6r9r rzunique..zduplicate names found in %r: %s)rGrDr}r~rr`)r duplicatesr}rduplicate_namesr6r6r9r s  r)r+c@s(eZdZdZeZeZeZeZdS)r+z control how out of range values are handled "strict" -> error is raised [default] "conform" -> extra bits are discarded "eject" -> lose flag status (becomes a normal integer) N) rrrrjrr,r-r.r/r6r6r6r9r+ s  r+r$zRGeneric flag enumeration. Derive from this class to define new flag enumerations.rrc Os|s|rd|f|duf|Sd|f|duSt|}zt|}d|d}|r.|f|WS|WSty9Ynwtd|)z Generate the next value when not given. name: the name of the member start: the initital start value or None count: the number of existing members last_value: the last value assigned or None rNrUzinvalid Flag value: %r)maxrrTrH) r}rrPrirrrhigh_bitrsr6r6r9r/ s     ccs(t||j@D] }|j|VqdS)zY Extract all members from the value in definition (i.e. increasing value) order. N)rTrZr]r|)rrRvalr6r6r9rK srrccs4t||}|jddd|D]}|VqdS)zA Extract all members from the value in definition order. cSrr<rXrLr6r6r9r] z&_iter_member_by_def_..rN)rcrrY)rrRr^rr6r6r9rV s rcCr)z; return a member matching the given value, or None )rr5r6r6r9ra s cGs|d}}t|tstd||jf|j}|j}|j}||A}||@}|j} d|f|dk} | ri| |krc| tur>|S| t urKd| | }n| t urZd| | |@}ntd||jf|d| }||@} ||@|@} ||@} | tur| r|Sn| t urd} n| t ur| rtd||jft || }| }d}| rd}|jD]'\}}||vr|jr|j|@|jkr|j| @r||||jO}||jO}q|| @| A}|r| t urn| t urd}n| tur|Std||jf| |O} || O}|f|dd}|jddd|j|g|R}t|d d}|jtur/|s/t|}n |p5|jj|g|R}t|d sE||_|rcd d d |D|_| rb|jd|| 7_nd|_|j||}| durw||j| <|S)z$ Create a composite member. rrNrUrcSrr<rrr6r6r9r rz(_create_pseudo_member_..rrrCr?cSrr6rrr6r6r9r rz*_create_pseudo_member_..z|%s)rErr`rrYrZr[rr.r/rZr-r,rcrr{rDrCr~rYrrmrOrSr<rRrrrr]r)rr5rR error_value flag_mask singles_maskall_bits unknown_bits unnamed_bitsr neg_valuerk unnamed_value unknown_valuer^ final_value still_unknownfoundrIpmr< pseudo_memberr6r6r9ri s                  rcGs2|jttfvr |St|dkr||fS|S)zB Return values to be fed to __new__ to create new member. rU)rOrrSr])rr^r5r6r6r9r s  rcCsPt||jstdt|j|jjf|jdks|jdkrdS|j|j@|jkS)zH Returns True if self has at least the same flags set as other. 3unsupported operand type(s) for 'in': '%s' and '%s'rF)rErrHrqrrCrr6r6r9r6 s r6ccs||jD]}|VqdS)z, Returns flags in definition order. N)rrC)rnrr6r6r9r: sr:cCrHr<)rrCrr6r6r9r; rr;cCs4|j}|jdurd|j|jfSd|j|j|jfS)Nz<%s: %r>z <%s.%s: %r>rrrrCrnrr6r6r9r s cCs0|j}|jdurd|j|jfSd|j|jfS)Nrrrrr6r6r9r s cCrHr<rlrCrr6r6r9rz rrzcCrHr<rrr6r6r9r. rr.cCsDt||jr |j}n|jturt||jr|}ntS||j|BSr<rErrCrOrSrrnr other_valuer6r6r9r rcCsDt||jr |j}n|jturt||jr|}ntS||j|@Sr<rrr6r6r9r" rrcCsDt||jr |j}n|jturt||jr|}ntS||j|ASr<rrr6r6r9r, rrcCs<|jdur||j|j@|_t|j|jr||j_|jSr<)rrrZrCrErr6r6r9r6 s rrrrc@seZdZdZeZddZdS)r%zSupport for integer-based FlagscCsft|tr ||}nt||jstdt|j|jjf|jdks(|jdkr*dS|j|j@|jkS)zP Returns True if self has at least the same flags set as other. rrF)rErrrHrqrrCrr6r6r9r6L s   zIntFlag.__contains__N)rrrrjr/rr6r6r6r6r9r%G s r%cCs |dS)z@returns index of highest bit, or -1 if value is zero or negativer)rZrQr6r6r9r] s rcCs |jjdd}d||jfS)z{ use module.enum_name instead of class.enum_name the module is the last module in case of a multi-module name .rYr)rrrr)rnr0r6r6r9global_enum_repra srcs|jjdd|jj}|jdurd||jfSt|r%d|jfS|jtj ur;d fdd|j dDSg}|jdD]}|d  rQ| |qC| d|fqCd |S) z{ use module.flag_name instead of class.flag_name the module is the last module in case of a multi-module name rrYNz %s.%s(%r)rr?csg|]}d|fqS)rr6rDrr6r9rw rz$global_flag_repr..r)rrrrrrCr rr+r/rr}isdigitr~)rnrr}rIr6rr9global_flag_reprj s      rcCs&|jdur|jj}d||jfS|jS)z2 use enum_name instead of class.enum_name Nz%s(%r))rrrrC)rnrr6r6r9 global_str s rcCsFt|tr t|_nt|_t|tr|rt|_tj |j j |j |S)z decorator that makes the repr() of an enum member reference its module instead of its class; also exports all members to the enum's module's global namespace )rBr$rrrr(rrr@rWrrCr[rG)r update_strr6r6r9rZ s rZ)WeakSetcCslt|ts td|fz|jdWn,ty$t|_t|_Ynty?ddl }| \}}}td}t |Ynw||jvrGdS||jvrNdS||urZ|j |dS|t |dd vrj|j |dS|tur{t|tr{|j |dS|turt|tr|j |dS|turt|tr|j |dS|turt|tr|j |dS|j |dS) z9 Override for issubclass(subclass, cls). z+issubclass() arg 1 must be a class (got %r)_subclass_cache_rNpossible causes for endless recursion: - __getattribute__ is not ignoring __dunder__ attibutes - __instancecheck__ and/or __subclasscheck_ are (mutually) recursive see `aenum.remove_stdlib_integration` for temporary work-aroundTFrar6)rErqrHrCrrr_subclass_negative_cache_RecursionErrorsysrAraise_from_nonerrm StdlibIntFlagrBr%rtr$ StdlibIntEnumr"rwr!)rsubclassrrotbr6r6r9__subclasscheck__ sJ              rcCsN|j}z||WSty&ddl}|\}}}td}t|YdSw)Nrr)rrrrrAr)rrrrrorr6r6r9__instancecheck__ s  rcCstr tt_tt_dSdSr<)rwrStdlibEnumMetarr6r6r6r9r0 s r0cCstrt`t`dSdS)a Remove the __instancecheck__ and __subclasscheck__ overrides from the stdlib Enum. Those overrides are in place so that code detecting stdlib enums will also detect aenum enums. If a buggy __getattribute__, __instancecheck__, or __subclasscheck__ is defined on a custom EnumMeta then RecursionErrors can result; using this function after importing aenum will solve that problem, but the better solution is to fix the buggy method. N)rwrrrr6r6r6r9r1 s r1c@seZdZddZddZdS)r3cGsZ|j|_|j|_g|_|j}|sdd|D}|D]}|||j|<|j|qdS)NcSs"g|] \}}t|ttfr|qSr6)rErr!rr6r6r9r s"z'cls2module.__init__..)rr_parent_module__all__rCrDr~)rnrr all_objectsr}r6r6r9rp szcls2module.__init__cCs|tjd|j|jf<dSr)r@rWrrrr6r6r9register szcls2module.registerN)rrrrprr6r6r6r9r3 s r3r<)NNNF)F) __future__rr9 _constantr_tupler collectionsrrr@rr r[r* ImportErrorremover NameErrorrr:rFrrRrrr!rwr"rrtr StdlibStrEnumStdlibReprEnumr%r$r#r(rr rrrr2rr rTr5typesrerzrSr _RouteClassAttributeToGetattrrrqrrrr rrrglobalsrr.r/r/rrr:rBrr rr _Addendumrrr|r|rpr<rrrrrrrrPY3r>rrrrrrrrrr}rRr5 _enum_baseresolverr4rrs _repr_basesrrr&r'rr~rrrrrr)rrrrrr+ _flag_bases flag_dictr,rrrrrr6r:r;r8rzr.rrrrrrrrrZ _weakrefsetrrrr0r1r3r6r6r6r9s.             $      '  i  $- ) il3n    (                          -         m               .