o ٷi@sddlmZddlTddlmZddlmZddlmZddl Z ddl Z gdZ e ZzddlZWney@dZe d YnwzeWn eyPeZYnwzeWn eybd d ZYnwd Zz%ddlZeed rsedddlmZmZmZdZZ Z!Z"eefZWneydZZZZ ZZ!Z!Z"Ynwerzddlm#Z m$Zeee f7ZWn eyYnwz ddlm%Z!ee!f7ZWn eyYnwz ddlm&Z"ee"f7ZWn eyYnwdZ'Z(Z)Z*Z+dddZ,ddZ-ddZ.dddZ ddZ/z ddl0m1Z1e1Z2Wney&e3Z2dZ1Ynwdd Z4Gd!d"d"e2Z5e5Z6e1durd/d0Z?d1d2Z@e,eAGd3d4d4eZBdZZ&ZZ%Z$Z#ZCZDGd5d6d6e3Ze9d7e3fiZEGd8d9d9eZFdd:lGmZe5e_5eFe_F[Gd;d<dd>ZIGd?d@d@eJZKe9dAe8fiZLGdBdCdCe8ZMerGdDdCdCeMeZMeMZeNeMOdEe3fdFeAdGZPePeQdHdIZRePdJdKZSePdLdMZTePeQdNdOZUePeVdPdQZWePeQdRdSZXePeQdTdUZYePeQdVdWZZePdXdYZ[ePdZd[Z\e]r Export members to target namespace. If collection is not given, act as a decorator. Ncs t|SN)r2) collection namespacer6r9export_decoratorW z export..export_decoratorz %r is not a supported collection) issubclassr__dict__items isinstancer! stdlib_enums __members__ TypeError)r=r?r@ncdatamr6r>r9r2Os       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) rrr6numcountr6r6r9rfs ! rccs.|r||d@}|V||N}|sdSdS)zZ Return each bit value one at a time. >>> list(_iter_bits_lsb(6)) [2, 4] rNr6)valuebitr6r6r9_iter_bits_lsbs  rSFcCsd|}|dkrt||ddd}n|s$t||d|A}n t||ddd}|dd}|dd}|s@d}|durWt||krW|d||| d}|dkre|re|ddd }d ||fS) a^ Like built-in bin(), except negative values are either represented in twos-compliment with the leading bit indicating sign (0=positive, 1=negative), or shown as positive with a sign bit of '~'. >>> bin(10) '0b0 1010' >>> bin(~10) # ~10 is -11 '0b1 0101' >>> bin(~10, invert=True) # ~10 is -11 '0b~ 1010' r10rN~z%s %s) bit_length _bltin_binreplacelen)rQmax_bitsinvertceilingssigndigitsr6r6r9r s      r cCs tt|Sr<)listrSrQr6r6r9r5s r5)DynamicClassAttributec Cstd|j}||t|f;}t|tr>|j}|td|jt |j|d|jt |j |d|j t |j |d|j d7}t |dS)z, show details about given enum/flag a %%r member type: %(_member_type_)r members: %%r __new__: %(_new_member_)r use args: %(_use_args_)r settings: %(_settings_)r member names: %(_member_names_)r start value: %(_start_)r auto init: %(_auto_init_)r new args: %(_new_args_)r auto args: %(_auto_args_)r ordering: %(_order_function_)r value repr: %(_value_repr_)r z boundary: %(boundary)r all bits: %(all_bits)r (%(iall_bits)r) flag mask: %(flag_mask)r (%(iflag_mask)r) singles mask: %(singles_mask)r (%(isingles_mask)r) )r^)boundaryall_bits iall_bits flag_mask iflag_mask singles_mask isingles_maskN) textwrapdedentrCr]rBr$ _all_bits_rZ _boundary_r _flag_mask__singles_mask_print)rtextr^r6r6r9infos"       rvc@s`eZdZdZdZdddZddZddZd d Zd d Z dd 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_docboolgetattrrw)selfrxryrzdocr6r6r9__init__s   zproperty.__init__cCs<|jr|jnd}t|||j|j|p|j}|jdu|_|Sr<)r|r{typeryrz)rrxfdocresultr6r6r9getter zproperty.gettercCs<|jr|jnd}t||j||j|p|j}|jdu|_|Sr<)r|r{rrxrz)rryrrr6r6r9setter rzproperty.settercCs<|jr|jnd}t||j|j||p|j}|jdu|_|Sr<)r|r{rrxry)rrzrrr6r6r9deleterrzproperty.deletercCsR|jp|jp|j}g}|jdur|d|j|r"|d|jdd|S)N%rz function=%sz property(%s), )rxryrzmemberappend__name__join)rfuncstringsr6r6r9__repr__s zproperty.__repr__cCs|dur|jdur |jStd||jf|jdur||S|jdur-td|j|fz|j|jWStyDtd||jfw)Nz%r has no attribute %rzcannot read attribute %r on %rz%r member has no attribute %r)rAttributeErrornamerxryrCKeyError)rinstance ownerclassr6r6r9__get__s&        zproperty.__get__cCsD|jdur|jdurtd|j|jf||j|j<dS|||S)Nz%cannot set attribute %r on )ryrxrrclsnamerC)rrrQr6r6r9__set__6s   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)rzrxryrrrrC)rrr6r6r9 __delete__As    zproperty.__delete__cCs||_|j|_dSr<)rrr)rrrr6r6r9 __set_name__Ps zproperty.__set_name__)NNNNr<)r __module__ __qualname__r{rrrrrrrrrrr6r6r6r9r s    r c@eZdZddZdS) SentinelTypecCs d|jS)Nz<%s>)rclsr6r6r9r]rAzSentinelType.__repr__N)rrrrr6r6r6r9r\ rSentinelcCs|dkrdS|dt|kS)NrFrT) _high_bitrer6r6r9 _power_of_twoasrcCs^|dvrt|Sd}|dkrd}|}t|d?t|d@}|r-dddd |D}|S) N)rrFrTrrUcSsg|]}d|dkqS)10rUr6).0dr6r6r9 ozbits..)strr r)rOnegativerr6r6r9r fsr 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. rrr6rNr6r6r9rss  cCs d}|r|d7}|dL}|s|S)Nrrr6)rOlengthr6r6r9bit_lens rcCs|dko ||d@dkS)z< True if only one bit set in num (should be an int) rrr6)rOr6r6r9r sr cCs@t|tr |t}t|d|}t|\}}}}|duo|duS)z6check if new generate method supports *args and **kwdsim_funcN)rE staticmethodrrr~ 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<rrv sort_typer6r9 zenumsort..rNz$cannot sort items of different typesc3s |] }t|duVqdS)rNrrrr6r9rscS|dSNrr6ir6r6r9zenumsort..keyztry name sort insteadcSrNrr6rr6r6r9rr)rrBtupleallrHsorted)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 allowedcCs|jdur td|j|jS)NzEnumConstant for %r has no name)_name_ ValueError_value_rr6r6r9rs zEnumConstants.__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)rrkwdsr6r6r9rs  z enum.__init__cC|jSr<)rrr6r6r9rz enum.argscC |jSr<)rcopyrr6r6r9r z enum.kwdscCrr<)rrr6r6r9__hash__sz enum.__hash__cCs(t||jstS|j|jko|j|jkSr<rE __class__NotImplementedrrrotherr6r6r9__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)NrcSsg|]}d|fqS)rr6rar6r6r9rsz!enum.__repr__..cSg|] \}}d||fqS)%s=%rr6rkrr6r6r9r%s(%s)) rrrrrdrrDrr)rfinalrrr6r6r9r s " z enum.__repr__N) rrrr{rbltin_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_rrnew_autor6r6r9__and__ z auto.__and__cC0|}|jdd|_|jt||ff|Sr<rrr6r6r9__rand__&rz auto.__rand__cC.|}|jdd|_|jt|ff|Sr<)rrr_inv_rrr6r6r9 __invert__,zauto.__invert__cCrr<rrr_or_rr6r6r9__or__2rz auto.__or__cCrr<rrr6r6r9__ror__8rz auto.__ror__cCrr<rrr_xor_rr6r6r9__xor__>rz auto.__xor__cCrr<r rr6r6r9__rxor__Drz auto.__rxor__cCrr<)rrr_abs_rr6r6r9__abs__Jrz auto.__abs__cCrr<rrr_add_rr6r6r9__add__Prz auto.__add__cCrr<rrr6r6r9__radd__Vrz auto.__radd__cCrr<)rrr_neg_rr6r6r9__neg__\rz auto.__neg__cCrr<)rrr_pos_rr6r6r9__pos__brz auto.__pos__cCrr<rrr_div_rr6r6r9__div__irz auto.__div__cCrr<rrr6r6r9__rdiv__orz auto.__rdiv__cCrr<rrr _floordiv_rr6r6r9 __floordiv__urzauto.__floordiv__cCrr<rrr6r6r9 __rfloordiv__{rzauto.__rfloordiv__cCrr<rrr _truediv_rr6r6r9 __truediv__rzauto.__truediv__cCrr<r rr6r6r9 __rtruediv__rzauto.__rtruediv__cCrr<rrr_lshift_rr6r6r9 __lshift__rzauto.__lshift__cCrr<r$rr6r6r9 __rlshift__rzauto.__rlshift__cCrr<rrr_rshift_rr6r6r9 __rshift__rzauto.__rshift__cCrr<r(rr6r6r9 __rrshift__rzauto.__rrshift__cCrr<rrr_mod_rr6r6r9__mod__rz auto.__mod__cCrr<r,rr6r6r9__rmod__rz auto.__rmod__cCrr<rrr_mul_rr6r6r9__mul__rz auto.__mul__cCrr<r0rr6r6r9__rmul__rz auto.__rmul__cCrr<rrr_pow_rr6r6r9__pow__rz auto.__pow__cCrr<r4rr6r6r9__rpow__rz auto.__rpow__cCrr<rrr_sub_rr6r6r9__sub__rz auto.__sub__cCrr<r8rr6r6r9__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_resolverr6r6r9rQs z auto.valuecCs|jr||}||_dSr<)rr>r<rrQr6r6r9rQs  NcCs|j}|jD]5\}}g}|D](}t||r1|jtur*|dur$tS||q||jq||q||}qg|jdd<||_|Sr<)rrrErQr=rr<)r base_valueropparamsvaluesparamrQr6r6r9r>s      z auto._resolver<),rrrr{r= enum_memberr<rrrrrr r r rrrrrPY2rrrrr"r#r&r'r*r+r.r/r2r3r6r7r:r;rrrQrr>r6r6r6r9rsT  r)_commonc@s(eZdZdZdZdZdZdZddZdS) _EnumArgSpec)rz all args except *args and **kwds)rzthe name of the *args variable)rTzthe name of the **kwds variable)rWzany default values)z0number of required values (no default available)cCsNt|}|\}}}}|r|dt| }n|dd}tt|||||fSr)rr]r__new__rH)r _new_funcargspecrrrrreqsr6r6r9rJ s   z_EnumArgSpec.__new__N) rrrrrrrrequiredrJr6r6r6r9rHs rHc@ eZdZdZddZddZdS) _proto_memberzW intermediate step for enum members between class execution and final creation cCs ||_dSr<rer?r6r6r9rrAz_proto_member.__init__c szt|||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|trdur|j krv|j!O_!t"r|j#O_#|j$r|j%|nt&t'} zCz|j(} |j)r| | j*%|Wn-ty|j+D]\} }|j*}| | jkr|j)r| |%||} nqt,YnwWn7t,y tdust|ts|j%|ntdur t|tr dust"r |j%|Ynw| r9g}| -D]\}}d.|}|%d ||||jfqt/d |j0d .|ft|jtrD| |j_1d}d}d}|j2ddD]5}|j34|}|durt|t5t6frn|}|}d }nt7|r|}|pyd }|p~|}qQd}|}qQ|rt5}| |_8|9|||dvrt:|dd|_;t:|dd|_t:|dd|_?t:|dd|_@||_A||_BtC|||ntC||| | |jD|<f|}|j r||vr||f7}|| _E|D]E|j r|j(vstFfdd|j+Drt/dfz|j$rtd| |j(<Wqty:|j+| ff7_+YqwdS)zR convert each quasi-member into an instance of the new enum class r6NrrrQrz/_value_ not set in __new__, unable to create it,z%s --> %s [%r]z%s: duplicate names found: %sz; rdescattr)rrRrxrryrrzrc3s|] \}}|kVqdSr<r6rrrLrer6r9rrz-_proto_member.__set_name__..z%r has already been usedzcannot use dict to store value)GdelattrrQrErrr=rrrMember _multivalue__creating_init_ _auto_init_ _new_args_r] _auto_args_ _member_type_ _use_args_ _new_member_hasattrobjectr ExceptionrH __cause__r __objclass__r_member_names_ _sort_order_r$rBrprrr rs _noalias_rrrd_value2member_map__unique_r_value2member_seq_rrDrrrrE__mro__rCgetr rf is_descriptorrrr~rx_getry_setrz_del _attr_type _cls_typesetattr _member_map__values_r:)r enum_class member_namerr init_args extra_mv_argsrmv_argrEexcte nonuniqueunhashable_valuecanonical_memberrmessagealiases bad_aliasesfound_descriptordescriptor_type class_typebaserSredirectrCr6rer9rsd                                          z_proto_member.__set_name__N)rrrr{rrr6r6r6r9rPs rPcsHeZdZdZfddZfddZfddZdd 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||jrG|jrGtd|||_||_d|_d|_t|v|_g|_g|_|jrfgd|_d|_d|_g|_d|_dS)Nz2%r: AddValue and MagicValue are mutually exclusivez4%r: MultiValue and MagicValue are mutually exclusiver6F)r r classmethodT)superr r _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)rcls_namesettingsstartconstructor_initconstructor_startconstructor_boundaryrr6r9r s:          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?)rrrr is_sunder is_dunderrr __getitem__rrrr]rr __setitem__rarrrQrr6r9r,s  " zEnumDict.__getitem__cs*d}t|j|r n+t|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|_n?||jvrtd)|j|f||j vr n(t,|s/d*|_||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||}nwt|t1r|2||}njt-|turt3d.d |Drg} |D]} t| t1rd*}|2|| } | j4} |j56| | 6| qt| }n0t|t1s|j+o|j+j7} t8|jp| } t|trt8|} nd-} | | 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|sQd}n9t|t1r_|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_rq_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 %srcs|]}t|VqdSr<reprrr6r6r9rjz'EnumDict.__setitem__..rqz4%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 rrrQrrz3%r: init specified in constructor and in class bodyrQ 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__rrJ__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_classris_private_namerrrrrHrE basestringsplitrdrrrrrrrrrrrrrfromkeysrrrrrinsertrr\rr__func__rrrrrrrHrrlrrr_gnvr _convert_autor:rQrrrNr]rraddrr r)rrrQ auto_storealreadyallowed_settingsargrgnv auto_valuedrnew_args target_len source_len test_valuerr6r9r>s\                                      "            ,  zEnumDict.__setitem__cCs|js |js |jturL|js|jr|j}nd}|jo|jj}t|jp#|p&d}t|t ur2t|}nd}||krL| ||}d|_ |jrI||_ |S||_|S)Nr6rT) rrrQr=rrNr]rrrrrr)rrrQrCrrrr6r6r9rs"    zEnumDict._convert_autocCs|jr!t|ts |f}|j||jt|j|jddg|R}n|||jt|j|jdd}t|trAt|dkrA|d}|SNrr)rrErrrr]rrrr6r6r9r%s ,"z EnumDict._gnv) rrrr{rrrrr __classcell__r6r6rr9r s  # Qr 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$TFrrrrQrzvalue rz1%r: MultiValue and NoAlias are mutually exclusiverz%r: unknown qualifier %r)rrrrrr)rflagcsrr<)rBr$rbr6r6r9rfrz'EnumType.__prepare__..css|]}|tuVqdSr<)r$rr6r6r9rhrc_sd|f|S)NrTr6)rrrPrCrrr6r6r9rqsz3EnumType.__prepare__.._generate_next_value_cs||}||_|Sr<)rJr)r flag_value type_valueobj member_typer6r9rJts z%EnumType.__prepare__..__new__rJ__new_member__rQrr)$_check_for_existing_members_r$rErr _get_mixins_r~_get_settings_rY_order_function_rr rdrrrrHrrrr _member_typer: _base_type baseintegerr`rrHrrr__inherited_gnvrr\rr)metaclsrbasesinitrrrgr initial_flagrrrgenerateorder first_enumrr enum_dictrrJr6rr9 __prepare__6s       .            zEnumType.__prepare__cOsdSr<r6)rrrr6r6r9rszEnumType.__init__c? s~ 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*}0| D]K}||}}1t |t-r|j.t/ur|j.}1t |1t0r|1d*kr|0|1O}0t |1tr|1rt |1d*t0r|1d*d*kr|0|1d*O}0t1|||<qld.|02d/}2|"|d0<|'|d1<|&|d2<|(|d3<|)|d4<g|d5<t |d6<|d7<i|d8<d|d9<||d<||d<||d:<|#|d;<|$|d<<d|d=<|3||d><|pt|-dd|d<d*|d?<d*|d@<|2|dA<d|dB<t4durq|rqt5|dCt4rq| D]:}3||3}4t |4j.t6rQ|4j.d*krO|0|4j.@|4_.q6|4j.durYq6t |4j.t-ro|4j.j.d*kro|0|4j.j.@|4j._.q6|D]\}}5t |5t7r|5j.||<qud)}6dD|vrt8urdE}7t9fdFdG|7Dst:|d%}6dH|vrdI|dH<z d}8t;|||Wn*t<y}9z|9j=p|9}8|8d}9~9wt>y}9z t?|9dJr|9`@d}9~9wwtAtBkr*| D] }jC|D|qjCD]\}}5|| vr qt?|5dKr|5D|qtEdur*t?dLr*tFGtHdurdtH|vrdt8ur=tdMdN|vrKjI_IjI|dN<dO|vrdjJ}:|:t8jJur\jK}:|:_JjJ|dO<dPD]9}||vroqft|};t|d}|>t|>krwjR_S| rfdXd| D} jCD]\}}t |tTrt |j.t-r|j.j.|_.q| rfdYd| D} | jUkrtdZjU| fS)[Nrrrr6rrrrrrrrrrqrrrrJrrcs:g|]\}}t|st|st|st|s||fqSr6)rrrrlrrr6r9rsz$EnumType.__new__..)rrcSg|]\}}|qSr6r6rrrQr6r6r9rrQrrzname rrQz)%d values expected (%s), %d received (%s)rcSsg|]}t|qSr6rrr6r6r9rrcSg|]}|jqSr6rrrLr6r6r9rr)rrrrrrrrrJrrrrqrrrTmrorzinvalid enum member name(s): %sFrz7'value', if specified, must be the first item in 'init'r^r]rTrrXrW _magicvalue_rfrhrdrsr\rgrirYrZr[r _value_repr_rrrsrp _inverted_rX __reduce_ex__)__getnewargs_ex____getnewargs__r __reduce__c3s|]}|jvVqdSr<rCrrr6r9rqrz#EnumType.__new__..r{zAn enumeration. __notes__rrzOReprEnum subclasses must be mixed with a data type (i.e. int, str, float, etc.) __format____str__)rr rr)rrr r rr r__cmp__)__le____lt____gt____ge__rrrrcSrr6rrr6r6r9rrr$cSsg|] }|jdur|jqSr<rrr6r6r9rrcs(g|]}|jvst|jr|qSr6)rsr rrorur6r9rs cs.g|]}|jvs|jvr|jvr|qSr6)rsrdrrr6r9rs  z*member order does not match _order_: %r %r)Vrr popr~rrDrrrkrrE OrderedDictrrdrr\rcallablerrr _defined_len_r]rH_fields_rrlocalsrrrrrrrrrrrrr setdefaultrr _find_new_rrQr=rrPrZ_find_data_repr_r$rBint nonmemberr`r:make_class_unpicklablerJ RuntimeErrorrbrar_rpyverPY3_6rCrr!rrr(rr rrrPY2_6rFrrrUrrrrd)?rrrclsdictrrrrgrrrrrrrrrrqrrrrJ enum_members original_dict calced_orderrrrQ name_valuerSrr member_names invalid_names creating_initr auto_args auto_initrrrrignorerrrsave_new new_uses_argsrjrrhrIpr unpicklablemethodsrzer class_method obj_method enum_method member_valuesr)rrurr9rJs<                                          0                                             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)modulequalnamerrrg)rJ_create_)rrQnamesr;r<rrrgr6r6r9__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. TcSrr6r6rTr6r6r9rHrz)EnumType.__contains__..)rErgrHrirrQr6r6r9 __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) rsrrget_attr_from_chainrErr r __delattr__)rrS found_attrr6r6r9rCJs       zEnumType.__delattr__cCst|jgd}|jtjur|d|jtjur|dttdr)|ddD]}t ||t t|t t |fvrA||q+|j turKt |St tt |j |BS)N) rrAr{r__iter____len__rGrrrJrr)rrrr )rrdr^r`rJrrr!r_r~r$r\rdir)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. )rsrrr6r6r9rGqs zEnumType.__members__cCsz|j|WStytd}YnwtdurBt|trBd|vrBz|d}|dD]}|||O}q-|WStyA|w||}t||rN|S|)Nr|r) rsr_sysexc_infor$rBrrrE)rrrzrrIr6r6r9rzs$     zEnumType.__getitem__csfddjDS)Nc3|]}j|VqdSr<rsrrrr6r9rrz$EnumType.__iter__..rdrr6rr9rEszEnumType.__iter__csfddtjDS)Nc3rMr<rNrOrr6r9rrz(EnumType.__reversed__..)reversedrdrr6rr9 __reversed__szEnumType.__reversed__cC t|jSr<)r]rdrr6r6r9rFrAzEnumType.__len__cCsHtdurt|trd|jfStdurt|trd|jfSd|jfS)Nz z z)r!rBrr$rr6r6r9rs    zEnumType.__repr__cCs|jdi}||vrtd|j|ft||}t|tr'td|j|ft|ttfr.cSs|d|dfSrr6tr6r6r9rsz$EnumType._convert_..rcSrrr6r_r6r6r9rr)r;rg) varsrKmoduleskeyssortrHr/r4r global_enumupdaterG) rrr;r]r^rg as_globalmodule_globalsmembersr6r\r9rZs"     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 ASCIINrrrQrr)rgrTr)rFrEunicodeencodeUnicodeEncodeErrorrHrrr~rr\rrrd enumeraterrrJrK _getframe f_globalsrrrrr)r class_namer>r;r<rrrgrr_rroriginal_names last_valuesrPrrQitemr#rv member_valuerur6r6r9r=sb              zEnumType._create_cCsFtdurdS|D]}|jD]}t|tr|jrtd||fq qdS)Nz cannot extend %r)r!rjrBrdrHmclsrqrchainrr6r6r9r#s 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__ NrXzZnew enumerations should be created as `EnumName([mixin_type, ...] [data_type,] enum_type)`z*cannot extend enumerations via subclassing)r!r`rrFrBrH_find_data_type_rd)rxrqrrrr6r6r9r.s   zEnumType._get_mixins_cCs|D]@}|jD]:}|tftvrqt|tr|jSd|jvrAd|jvr8d|jvr8|jdjr8tS|jdSqqdS)Nr__dataclass_fields____dataclass_params__) rjr`rFrErrrCr_dataclass_reprrwr6r6r9rHs        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)NrJr|rz%r: too many data types: %r)rrjr`rFrErr\rrC StdlibFlagrBr]rHr)rxrqr data_typesry candidaterr6r6r9r{^s2       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__ )rrjrBr!rr)rrryrrar6r6r9rzs    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__ rJN)rrJFT)rkr~rJr`r! StdlibEnum) rxr#rrrJr.rpossibletargetr/r6r6r9rs0     zEnumType._find_new_)NNr6N)NNF)NNNrN)"rrrr{rrrrJr9rr?rArCrIrrGrrErRrF __nonzero__rrTr[rZr=rrrr{rrrrr6r6rr9r3sL W   G      rc@s eZdZdS)rN)rrrr6r6r6r9rsr!zNGeneric enumeration. Derive from this class to define new enumerations. )rrnscCs|jrdSdS)Nz (*values)z\(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)rPrr6r6r9 __signature__srcOs|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)NrQrz,%d arguments expected (%s), %d received (%s)zmissing value for: %rzinvalid keyword(s): %sr) rYr]rHziprrr undefinedrrc)rrrrYrrremaining_argsrQr6r6r9rs0  rcCst|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 valuerqz"%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)rrrHrrgrrirrEr~r.rrr)rrQrvrrr6r6r9rJs:        rJcKs8ttkr|r td|fdStt|jdi|dS)Nz unconsumed keyword arguments: %rr6)r r!rHrr!r)rrr6r6r9r s rc OsDt|D]}z|d}Wn tyYqw|}|r |f|S|Sr)rQrH)rrrPrtrr last_value new_valuer6r6r9r s   rcCr8)z'deprecated, use _missing_value_ insteadNr6r@r6r6r9r+ r:rcC ||S)zused for failed value access)rr@r6r6r9r1 s rcCr8)zused for failed item accessNr6)rrr6r6r9r7 r:rcCs,|jjp|jjj}d|jj|j||jfS)Nz <%s.%s: %s>)rrrrrr)rv_reprr6r6r9r= srcCsd|jj|jfSN%s.%s)rrrrr6r6r9r B sr csjjtur tgd}ntfddtD}tdgD]}|ddkr3|jvr3||q!jD]9}|j D]1\}}|ddkrKq@t |t rf|j dusZ|jvr`||q@||q@t |jsq||q@q9t|S)z, Returns all public methods )rr{rrrc3s|] }|jvr|VqdSr<rN)rrIrr6r9rO sz__dir__..rCrrrN)rr\r`rrIr~rsrrrCrDrEr rxdiscardr)rrHrrrr6rr9rIG s(         rIcCstt||Sr<)rr)r format_specr6r6r9rb rcCrSr<)rrrr6r6r9rf rrcCs|j|jffSr<)rrrprotor6r6r9rj srcCtd|jj|jjf)Nzunorderable types: %s() <= %s()rHrrrr6r6r9r n r cCr)Nzunorderable types: %s() < %s()rrr6r6r9r r rr cCr)Nzunorderable types: %s() >= %s()rrr6r6r9rv rrcCr)Nzunorderable types: %s() > %s()rrr6r6r9r z rr cCst||jr ||uStSr<rErrrr6r6r9r  rcCst||jr ||uStSr<rrr6r6r9r rrcCrr<rrr6r6r9r rcCrr<rrr6r6r9rQ rrQcCrr<)rtrr6r6r9rC rrCcCrr<rrr6r6r9pickle_by_global_name rrcCst|j|jffSr<)r~rrrr6r6r9pickle_by_enum_name rrcs$jdfddDS)Nrc3s,|]}|jrd|t|fVqdS)rN)rr~)rrdcfrr6r9r s z"_dataclass_repr..)r|rrcrr6rr9r~ sr~r(r{zIOnly 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)rrrr{r6r6r6r9r" 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])rHrrErrrJr)rrCrrQrr6r6r9rJ s  zStrEnum.__new__cC|S)zD Return the lower-cased version of the member name. )lower)rrrPrtr6r6r9r szStrEnum._generate_next_value_N)rrrr{rJrr rr6r6r6r9r# 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#rrrrrQrrrr6r6r9rJ   zLowerStrEnum.__new__Nrrrr{rJr6r6r6r9r& s r&c@rO)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#rupperrrr6r6r9rJ rzUpperStrEnum.__new__cOrr<)r)rrrPrtrrr6r6r9r sz"UpperStrEnum._generate_next_value_N)rrrr{rJrr6r6r6r9r' s r'c@eZdZdZeZdS)AutoEnumza automatically use _generate_next_value_ when values are missing (Python 3 only) N)rrrr{rrr6r6r6r9r 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]rGr\rrJlongr`r)rrrrQrr6r6r9rJ s   zAutoNumberEnum.__new__Nrr6r6r6r9r s rc@seZdZeZdS)rN)rrrr rr6r6r6r9r% rrc@r)rz1 Multiple values can map to each member. N)rrrr{rrr6r6r6r9r) rrc@r)rzQ Duplicate value members are distinct, but cannot be looked up by value. N)rrrr{rrr6r6r6r9r0 rrc@s0eZdZdZddZddZddZdd Zd S) rz7 Add ordering based on values of Enum members. cCs|j|jur |j|jkStSr<rrrrr6r6r9r<   zOrderedEnum.__ge__cCs|j|jur |j|jkStSr<rrr6r6r9r A rzOrderedEnum.__gt__cCs|j|jur |j|jkStSr<rrr6r6r9r F rzOrderedEnum.__le__cCs|j|jur |j|jkStSr<rrr6r6r9r K rzOrderedEnum.__lt__N)rrrr{rr r r r6r6r6r9r7 s  rc@r)r)cCs|tjur|jSdSr<)r*PrepareProtocolr)rprotocolr6r6r9 __conform__S s zSqliteEnum.__conform__N)rrrrr6r6r6r9r)R rc@r)rz+ Ensure no duplicate values exist. N)rrrr{rrr6r6r6r9rX 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<r6rr]r6r9rs s"zconvert..r;N) rarKrbrrDr4rrfrG)rrr;r]r^rhrir6rr9convert_ 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+||@}|rtd|j d,dd|Df| rt-||||dS|j%}|.D]:}t|d|j g}|D],} |D]&}!| |!kr4|s| r$td||ft-|||||dd Sqq qt/t0krCt1f}"nt1t2f}"t3||"rt|drt4|r`t-||||dS||j(@|kr| |dur| |}#t-||#|||dd St-||||dd!St-||S)"z/ Add a new member to an existing Enum. cSsg|]}|dqS)rr6)rr`r6r6r9r rzextend_enum..rir6z%r already in use as %rNr"%r already in use in superclass %rcSsg|] }|jD]}|qqSr6r)rrrr6r6r9r rz%r is not a supported EnumFz*no values specified for MultiValue enum %rr^rcSrr6rerr6r6r9r rrrXrTrQrrrpkeepz%invalid Flag %r -- missing values: %srcsrr<)r)rrr6r6r9r rzextend_enum..)r maskrtz%r is a duplicate of %r)rr ris_alias)r rr)5rCrsr~rHrkrjrEr rfrrdr\rgrrrrirrrrrYrrJr]r`rrrrrr_rrrrcrrtrerprrrqrdrSr_finalize_extend_enumrCr r!r$rrBr )$ enumerationrrr descriptorrrsrdr\rgbase_attributesri _multi_value_ _no_alias_rhrYmt_new_newrtrPrrr/rQ more_values new_memberrprrmissed new_valuesr~canonical_values_canonical_valuer flag_bases canonicalr6r6r9ry s                                     rc Cs2|p|j}d}|jddD]}|j|}|dur,t|ttfr#n td||jfq|sBt}| ||||_ t |||n||jvrP||_ t ||||sX|j |||j|<t|d|jgD]} z||j| <Wqety|j| |ff7_Yqew|r||_||_t|jr|j|jO_|S)Nrrrt)rrjrCrkrEr rfrHrrrrrrdrrsr~rrgrirprrr rs) rrrr rrrrrrr6r6r9r% s@         rcCs^g}|jD]\}}||jkr|||jfq|r-ddd|D}td||f|S)zS Class decorator that ensures only unique members exist in an enumeration. rcSr)z%s -> %sr6)raliasrr6r6r9rQ rzunique..zduplicate names found in %r: %s)rGrDrrrr)r duplicatesrrduplicate_namesr6r6r9rG s  r)r+c@s(eZdZdZeZeZeZeZdS)r+a1 control how out of range / unnamed / absent flags are handled "strict" -> error is raised [Flag default] "conform" -> extra bits are discarded [`_flag_mask_` bits retained] "eject" -> lose flag status (becomes a normal integer) "keep" -> retain flag status, retain extra bits [IntFlag default] when there are missing flags, negative numbers are handled as "strict" -> missing flag bits are discarded "eject" -> original integer is returned "keep" -> missing flag bits are kept N) rrrr{rr,r-r.r/r6r6r6r9r+] s   r+r$zRGeneric flag enumeration. Derive from this class to define new flag enumerations.rqrc 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 rNrTzinvalid Flag value: %r)maxrrarH) rrrPrtrrrhigh_bitrr6r6r9r s     ccs4t||j@D]}|j|}|dur|VqdS)zY Extract all members from the value in definition (i.e. increasing value) order. N)rSrsrgrk)rrQvalrr6r6r9r s rrccs4t||}|jddd|D]}|VqdS)zA Extract all members from the value in definition order. cSrr<)re)rLr6r6r9r sz&_iter_member_by_def_..rN)rdrrd)rrQrirr6r6r9r s rcCr)z; return a member matching the given value, or None )rr@r6r6r9r s cGs|d}}t|tstd||jf|j}|j}|j}|j}d}|tur1|dkr,|}||M}n|t urW||krA|ksD|S|S|dkrN|}||M}|||A@rV|Snq|t urv|dkru|}||krk||M}n]|d| dM}nR|t urt | | } ||kr|ksntd||t|| t|| f|dkr|}||M}|||A@rtd||t|| t|| fntd||f|f|dd}||jvr|j|} n||@} ||@} ||@} t||}|j|g|R}t|dd}|jtur|st|} n |p|jj|g|R} t| d s%|| _| s+| rd}|D]}||jO}q/| rh|jD]'\}}||vrf|jrf|j| @|jkrf||||jO}| |j@} q@| ||AB} d d d |D| _|s|r|t urtd ||f|t ur|S|tt fvrntd||fd| _n*| r|t ur| |@| krtd || f| r| jd|| 7_nd| _|j|| } |dur| |j|<| S)z$ Create a composite member. rrNrTrz-%r invalid value %r given %s allowed %sz%r unknown flag boundary %rrrrJcSrr6rrr6r6r9r rz*_create_pseudo_member_..z%r: no members with value %rz|%s) rErrrrrrsrprqr-r.r/rZr,rr rgrdrrr~r\r`rJr_rrsrDrrrrr)rrCrQ error_valuerjrlrhrg neg_valuer^ pseudo_memberunknownrrvrirJcombined_valuerLrIpmr6r6r9r s                 $         rcGs2|jttfvr |St|dkr||fS|S)zB Return values to be fed to __new__ to create new member. rT)r\rr`r])rrirCr6r6r9r1 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)rErrHrrrrr6r6r9rA> s rAccs||jD]}|VqdS)z, Returns flags in definition order. N)rr)rrr6r6r9rEK srEcCrSr<)rrrr6r6r9rFS rrFcCs4|j}|jdurd|j|jfSd|j|j|jfS)Nz<%s: %r>z <%s.%s: %r>rrrrrrr6r6r9rW s cCs0|j}|jdurd|j|jfSd|j|jfS)Nrrrrr6r6r9r ` s cCrSr<r}rrr6r6r9ri rrcCrSr<rrr6r6r9r9m rr9cCs0t||jr |jS|jturt||jr|StSr<)rErrr\r`r)rrr6r6r9 _get_valueq s rcCsT||}|tur tS||fD]}||durtd|fq|j}|||BS)Nz/'%s' cannot be combined with other flags with |rrrHrrrr other_valuerrQr6r6r9ry   rcCsT||}|tur tS||fD]}||durtd|fq|j}|||@S)Nz/'%s' cannot be combined with other flags with &rrr6r6r9r rrcCsT||}|tur tS||fD]}||durtd|fq|j}|||AS)Nz/'%s' cannot be combined with other flags with ^rrr6r6r9r  rr cCs<||durtd|f|jdur||j|_|jS)Nz'%s' cannot be inverted)rrHrrrrr6r6r9r s  rr rr c@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)rErrrHrrrrr6r6r9rA s   zIntFlag.__contains__N)rrrr{r/rqrAr6r6r6r9r% s r%cCs |dS)z@returns index of highest bit, or -1 if value is zero or negativer)rZrer6r6r9r 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 .rXr)rrrr)rr;r6r6r9global_enum_repr 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 rrXNz %s.%s(%r)rrJcsg|]}d|fqS)rr6rOrr6r9r rz$global_flag_repr..r)rrrrrrr rqr+r/rrisdigitr)rrrrIr6rr9global_flag_repr s      rcCs&|jdur|jj}d||jfS|jS)z2 use enum_name instead of class.enum_name Nz%s(%r))rrrr)rrr6r6r9 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(rr rKrbrrCrfrG)r update_strr6r6r9re s re)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-aroundTFrjr6)rErrHrCrrr_subclass_negative_cache_RecursionErrorsysrLraise_from_nonerr~ StdlibIntFlagrBr%rr$ StdlibIntEnumr"rr!)rsubclassrrztbr6r6r9__subclasscheck__ sJ              rcCsN|j}z||WSty&ddl}|\}}}td}t|YdSw)Nrr)rrrrrLr)rrrrrzrr6r6r9__instancecheck__0 s  rcCstr tt_tt_dSdSr<)rrStdlibEnumMetarr6r6r6r9r0; 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)rrrrr6r6r6r9r1@ s r1c@seZdZddZddZdS)r3cGsZ|j|_|j|_g|_|j}|sdd|D}|D]}|||j|<|j|qdS)NcSs"g|] \}}t|ttfr|qSr6)rErr!rr6r6r9rU s"z'cls2module.__init__..)rr_parent_module__all__rCrDr)rrr all_objectsrr6r6r9rO szcls2module.__init__cCs|tjd|j|jf<dSr)rKrbrrrr6r6r9registerY szcls2module.registerN)rrrrrr6r6r6r9r3N s r3r<)NF)NNNF)F) __future__rrG _constantr_tupler collectionsrrnrrKrr r[r* ImportErrorremover NameErrorrr:rFrr_rrr!rr"rrr StdlibStrEnumStdlibReprEnumr%r$r#r(rr rrrr2rrSr5typesrfrr`rvr _RouteClassAttributeToGetattrrrrrrr rr rrglobalsrr.r/r=rrrHrPrr rr _AddendumrrrrrrJrrrrrrrr PY3rIrrrr r rr rrrrQrC _enum_baseresolverr4rr~ _repr_basesrrr&r'rrrrrrrr)rrrrrr+ _flag_bases flag_dictr,rrrrrrArErFrFrr9rrrr rrrrrre _weakrefsetrrrr0r1r3r6r6r6r9s6             $      (   %i  $- ) im1    (                          -"          t                .