a
    dC                    @   s  d dl mZ ddlT ddlmZ ddlmZ d dlmZ d dl	Z
g dZeZzd dlZW n  eyx   dZed	 Y n0 ze W n ey   eZY n0 ze W n ey   d
d ZY n0 dZzLd dlZeedredn,d dlmZmZmZ d Z Z Z Z!eefZW n4 eyB   d Z Z Z Z Z Z  Z Z!Y n0 erz d dlm"Zm#Z eeef7 ZW n ey~   Y n0 zd dlm$Z  ee f7 ZW n ey   Y n0 zd dlm%Z! ee!f7 ZW n ey   Y n0 d Z& Z' Z( Z)Z*dddZ+dd Z,dd Z-dd Z.dddZdd Z/zd dl0m1Z1 e1Z2W n eyX   e3Z2dZ1Y n0 G d d! d!e2Z4e4Z5e1du r|e4Z1e4Z6G d"d# d#e7Z8e8d$e3fi Z9d%d& Z:d'd( Z;d)d Z,d*d+ Z<d,d Z-d-d. Z=d/d0 Z>e+e? G d1d2 d2eZ@d Z Z% Z Z$ Z# Z" ZAZBG d3d4 d4e3Ze8d5e3fi ZCG d6d7 d7eZDdd8lEmZ e4e_4eDe_D[G d9d: d:eZFG d;d< d<ZGG d=d> d>eHZIe8d?e7fi ZJG d@dA dAe7ZKerG dBdA dAeKeZKeKZeLeKMdCe3fdDe? dEZNeNeOdFdG ZPeNdHdI ZQeNdJdK ZReNeOdLdM ZSeNeTdNdO ZUeNeOdPdQ ZVeNeOdRdS ZWeNeOdTdU ZXeNdVdW ZYeNdXdY ZZe[r|eNdZd[ Z\eNd\d] Z]eNd^d_ Z^eNd`da Z_eNdbdc Z`eNddde ZaeNdfdg ZbeNdhdi ZceNdjdk ZdeNdldm ZeeNe4dndo ZfeNe4dpdq ZgeNe4drds Zhep e3ZieKdCeifeNj Z[Ndtdu ZkekZldvdw Zmdxdy Zne!rbee!fZonefZoeKdzeod{d|iZ%G d}d~ d~epe%ZG dd deqe%Z$G dd de$ZrG dd de$Zse[rG dd deZteud G dd deZvG dd deZwG dd deZxG dd deZyG dd deZzerBG dd	 d	eZ{G dd deZ|dddZ}dd Z~dddZdd Zzd dlmZ W n$ ey   G dd de$ZY n0 e+ee?  ereefZnefZeLeKMdede? dEZeed< eed< eddO ZUeeOdd Zeed< eeOdd ZeeOddQ ZVeeOdd ZeeOdd Zedd Zedd Zedd ZeddW ZYeddY ZZeredd Znedd Zedd Zedd Zedd Zedd Zeed< eed< eed< eKdeej Z#[G ddǄ depe%e#Z"ddɄ Zdd˄ Zdd̈́ Zddτ ZdddфZerpd dlmZ ddԄ Zddք Zdd؄ Zddڄ ZG dd܄ de3ZdS )    )print_function   )*)NamedConstant)
NamedTuple)defaultdictN).	bit_countis_single_bitbinpropertybitsAddValue
MagicValue
MultiValueNoAliasUniqueenumautoAddValueEnumMultiValueEnumNoAliasEnum
UniqueEnumAutoNumberEnumOrderedEnumuniqueno_argextend_enumenum_propertyEnumTypeEnumMetaEnumDictEnumIntEnumStrEnumFlagIntFlagLowerStrEnumUpperStrEnumReprEnum
SqliteEnumsqlite3FlagBoundarySTRICTCONFORMEJECTKEEPadd_stdlib_integrationremove_stdlib_integrationexport
cls2module_reduce_ex_by_nameshow_flag_valuesr)   c                 C   s   | D ]}|r dS qdS )NTF )iterableelementr6   r6   T/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/aenum/_enum.pyany'   s    r:   r6   versionzwrong version)r   r!   r"   )r%   r$   )r#   )r(   c                    s    du r|   fdd}|S t | trN| j D ]\}}t|tr0| |< q0nHt | tsftrt | tr| j }|D ]\}}| |< qtntd| f | S )z
    export([collection,] namespace) -> Export members to target namespace.

    If collection is not given, act as a decorator.
    Nc                    s
   t |  S N)r2   )
collection	namespacer6   r9   export_decoratorV   s    z export.<locals>.export_decoratorz %r is not a supported collection)	
issubclassr   __dict__items
isinstancer!   stdlib_enums__members__	TypeError)r=   r?   r@   ncdatamr6   r>   r9   r2   N   s    


r2   c                 C   s"   d}| r| | d M } |d7 }q|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)
    r   r   r6   numcountr6   r6   r9   r   e   s
    !
r   c                 C   s    | dkrdS | | d M } | dkS )z>
    True if only one bit set in value (should be an int)
    r   Fr   r6   valuer6   r6   r9   r	      s    r	   c                 c   s&   | r"| |  d @ }|V  | |N } q dS )zZ
    Return each bit value one at a time.

    >>> list(_iter_bits_lsb(6))
    [2, 4]
    r   Nr6   )rP   bitr6   r6   r9   _iter_bits_lsb   s    rR   c                 C   s   d|    }| dkr,t| | ddd}nt|  |d | A }|dd }|dd }|sbd}|durt||k r|d | | | d }d	||f S )
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'
       r   10r   N   z%s %s)
bit_length
_bltin_binreplacelen)rP   Zmax_bitsZceilingssigndigitsr6   r6   r9   r
      s    r
   c                 C   s   t t| S r<   )listrR   rO   r6   r6   r9   r5      s    r5   )DynamicClassAttributec                   @   s\   e Zd ZdZdddZdd Zdd Zd	d
 Zdd ZdddZ	dd Z
dd Zdd ZdS )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_.
    Nc                 C   s>   || _ || _|| _|p|j| _|d u | _tt|dd| _d S )N__isabstractmethod__F)fgetfsetfdel__doc__overwrite_docboolgetattrra   )selfrb   rc   rd   docr6   r6   r9   __init__   s    
zproperty.__init__c                 C   s<   | j r|jnd }t| || j| j|p(| j}| jd u |_ |S r<   )rf   re   typerc   rd   )ri   rb   fdocresultr6   r6   r9   getter   s    zproperty.getterc                 C   s8   | j rtjnd }t| | j|| j| j}| jd u |_ |S r<   )rf   rb   re   rl   rd   )ri   rc   rm   rn   r6   r6   r9   setter   s    zproperty.setterc                 C   s8   | j rtjnd }t| | j| j|| j}| jd u |_ |S r<   )rf   rb   re   rl   rc   )ri   rd   rm   rn   r6   r6   r9   deleter   s    zproperty.deleterc                 C   sZ   | j j| j}| jp | jp | j}g }|r8|d|  |rL|d|j  dd	| S )N%rzfunction=%szproperty(%s), )

ownerclass_member_map_getnamerb   rc   rd   append__name__join)ri   memberfuncstringsr6   r6   r9   __repr__   s    zproperty.__repr__c                 C   s   |d u r>z|j | j W S  ty:   td|| jf Y q0 nf| jd urR| |S | jd urptd| j|f n4z|j| j W S  ty   td|| jf Y n0 d S )Nz%r has no attribute %rzcannot read attribute %r on %rz%r member has no attribute %r)ru   rw   KeyErrorAttributeErrorrb   rc   rB   )ri   instancert   r6   r6   r9   __get__   s&    


zproperty.__get__c                 C   sH   | j d u r8| jd ur*td| j| jf qD||j| j< n|  ||S d S )Nz%cannot set attribute %r on <aenum %r>)rc   rb   r   rw   clsnamerB   )ri   r   rP   r6   r6   r9   __set__  s    

zproperty.__set__c                 C   sh   | j d u rZ| js| jr,td| j| jf qd| j|jv rD|j| j= qdtd| j| jf n
|  |S d S )Nz(cannot delete attribute %r on <aenum %r>z$no attribute %r on <aenum %r> member)rd   rb   rc   r   rw   r   rB   )ri   r   r6   r6   r9   
__delete__  s    
zproperty.__delete__c                 C   s   || _ |j| _|| _d S r<   )rw   ry   r   rt   )ri   rt   rw   r6   r6   r9   __set_name__+  s    zproperty.__set_name__)NNNN)N)ry   
__module____qualname__re   rk   ro   rp   rq   r~   r   r   r   r   r6   r6   r6   r9   r      s   



r   c                   @   s   e Zd Zdd ZdS )SentinelTypec                 C   s
   d| j  S )Nz<%s>ry   clsr6   r6   r9   r~   9  s    zSentinelType.__repr__N)ry   r   r   r~   r6   r6   r6   r9   r   8  s   r   Sentinelc                 C   s   | dk rdS | dt |  kS )Nr   FrS   )	_high_bitrO   r6   r6   r9   _power_of_two=  s    r   c                 C   s^   | dv rt | S d}| dk r&d}|  } t| d? t | d@  }|rZdddd	 |D  }|S )
N)r   r   Fr   Tr   rT    c                 S   s   g | ]}d |dk qS )10rT   r6   ).0dr6   r6   r9   
<listcomp>K      zbits.<locals>.<listcomp>)strr   rz   )rM   negativern   r6   r6   r9   r   B  s    r   c                 C   s"   d}| r| | d M } |d7 }q|S )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.
    r   r   r6   rL   r6   r6   r9   r   O  s
    
c                 C   s   d}| r|d7 }| dL } q|S )Nr   r   r6   )rM   lengthr6   r6   r9   bit_lens  s
    
r   c                 C   s   | dko| | d @ dkS )z<
    True if only one bit set in num (should be an int)
    r   r   r6   )rM   r6   r6   r9   r	   z  s    c                 C   s@   t | tr| t} t| d| } t| \}}}}|duo>|duS )z6check if new generate method supports *args and **kwdsim_funcN)rD   staticmethodr   rl   rh   
getargspec)methodargsvarargskeywordsdefaultsr6   r6   r9   _check_auto_args  s
    

r   c                    s   | s| S t | d  t tsLt fdd| dd D sDtdt| S t | d d  z<t fdd| dd D rt| dd	 d
W S tdW n" ty   t| dd	 d
 Y S 0 dS )zC
    sorts things by value if all same type; otherwise by name
    r   c                 3   s   | ]}t | u V  qd S r<   rl   r   vZ	sort_typer6   r9   	<genexpr>  r   zenumsort.<locals>.<genexpr>r   Nz$cannot sort items of different typesc                 3   s   | ]}t |d   u V  qdS )r   Nr   r   r   r6   r9   r     r   c                 S   s   | d S Nr   r6   ir6   r6   r9   <lambda>  r   zenumsort.<locals>.<lambda>keyztry name sort insteadc                 S   s   | d S Nr   r6   r   r6   r6   r9   r     r   )rl   rA   tupleallrG   sorted)Zthingsr6   r   r9   enumsort  s    
r   c                   @   sF   e Zd ZeddZeddZeddZeddZed	d
Zdd Z	dS )EnumConstantsaddvaluez;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 valuesnoaliasz2duplicate valued members are distinct, not aliasedr   z(duplicate valued members are not allowedc                 C   s   | j S r<   _name_ri   r6   r6   r9   r~     s    zEnumConstants.__repr__N)
ry   r   r   constantr   r   r   r   r   r~   r6   r6   r6   r9   r     s   




r   c                   @   sP   e Zd ZdZdd Zedd Zedd Zdd	 Zd
d Z	dd Z
dd ZdS )r   z+
    Helper class to track args, kwds.
    c                 O   s(   || _ t| | _t|| _d | _d S r<   )_argsdictrC   _kwdshash_hashrw   )ri   r   kwdsr6   r6   r9   rk     s    
zenum.__init__c                 C   s   | j S r<   )r   r   r6   r6   r9   r     s    z	enum.argsc                 C   s
   | j  S r<   )r   copyr   r6   r6   r9   r     s    z	enum.kwdsc                 C   s   | j S r<   )r   r   r6   r6   r9   __hash__  s    zenum.__hash__c                 C   s(   t || jstS | j|jko&| j|jkS r<   rD   	__class__NotImplementedr   r   ri   otherr6   r6   r9   __eq__  s    zenum.__eq__c                 C   s(   t || jstS | j|jkp&| j|jkS r<   r   r   r6   r6   r9   __ne__  s    zenum.__ne__c                 C   sn   g }d dd | jD }|r(|| d dd tt| j D }|rX|| d| jjd |f S )Nrs   c                 S   s   g | ]}d |f qS )rr   r6   r   ar6   r6   r9   r     r   z!enum.__repr__.<locals>.<listcomp>c                 S   s   g | ]\}}d ||f qS )%s=%rr6   r   kr   r6   r6   r9   r     r   %s(%s))	rz   r   rx   r   r_   r   rC   r   ry   )ri   finalr   r   r6   r6   r9   r~     s    
"
zenum.__repr__N)ry   r   r   re   rk   bltin_propertyr   r   r   r   r   r~   r6   r6   r6   r9   r     s   

r   Zno_valuec                   @   s<  e Zd ZdZeZeZg Zdd Zdd Z	dd Z
dd	 Zd
d Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zerdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Zd0d1 Z d2d3 Z!d4d5 Z"d6d7 Z#d8d9 Z$d:d; Z%d<d= Z&d>d? Z'e(d@dA Z)e)j*dBdA Z)dFdDdEZ+dCS )Gr   zP
    Instances are replaced with an appropriate value in Enum class suites.
    c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   _operationsrx   Z_and_ri   r   new_autor6   r6   r9   __and__  s    zauto.__and__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rand__   s    zauto.__rand__c                 C   s.   |   }| jd d  |_|jt| ff |S r<   )r   r   rx   Z_inv_ri   r   r6   r6   r9   
__invert__  s    zauto.__invert__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_or_r   r6   r6   r9   __or__  s    zauto.__or__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __ror__  s    zauto.__ror__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_xor_r   r6   r6   r9   __xor__  s    zauto.__xor__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rxor__  s    zauto.__rxor__c                 C   s.   |   }| jd d  |_|jt| ff |S r<   )r   r   rx   Z_abs_r   r6   r6   r9   __abs__$  s    zauto.__abs__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_add_r   r6   r6   r9   __add__*  s    zauto.__add__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __radd__0  s    zauto.__radd__c                 C   s.   |   }| jd d  |_|jt| ff |S r<   )r   r   rx   Z_neg_r   r6   r6   r9   __neg__6  s    zauto.__neg__c                 C   s.   |   }| jd d  |_|jt| ff |S r<   )r   r   rx   Z_pos_r   r6   r6   r9   __pos__<  s    zauto.__pos__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_div_r   r6   r6   r9   __div__C  s    zauto.__div__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rdiv__I  s    zauto.__rdiv__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z
_floordiv_r   r6   r6   r9   __floordiv__O  s    zauto.__floordiv__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rfloordiv__U  s    zauto.__rfloordiv__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z	_truediv_r   r6   r6   r9   __truediv__[  s    zauto.__truediv__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rtruediv__a  s    zauto.__rtruediv__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_lshift_r   r6   r6   r9   
__lshift__g  s    zauto.__lshift__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rlshift__m  s    zauto.__rlshift__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_rshift_r   r6   r6   r9   
__rshift__s  s    zauto.__rshift__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rrshift__y  s    zauto.__rrshift__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_mod_r   r6   r6   r9   __mod__  s    zauto.__mod__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rmod__  s    zauto.__rmod__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_mul_r   r6   r6   r9   __mul__  s    zauto.__mul__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rmul__  s    zauto.__rmul__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_pow_r   r6   r6   r9   __pow__  s    zauto.__pow__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rpow__  s    zauto.__rpow__c                 C   s0   |   }| jd d  |_|jt| |ff |S r<   r   r   rx   Z_sub_r   r6   r6   r9   __sub__  s    zauto.__sub__c                 C   s0   |   }| jd d  |_|jt|| ff |S r<   r   r   r6   r6   r9   __rsub__  s    zauto.__rsub__c                 C   s"   | j r
dS d| j| j| jf S d S )Nz	auto(...)zauto(%r, *%r, **%r))r   _valuer   r   r   r6   r6   r9   r~     s    zauto.__repr__c                 C   sL   | j tur| jrtdn.| j tu r0| js0| j S | j tur@| j S |  S d S )Nzauto() object out of sync)r  
_auto_nullr   rG   _resolver   r6   r6   r9   rP     s    

z
auto.valuec                 C   s   | j r| |}|| _d S r<   )r   r  r  ri   rP   r6   r6   r9   rP     s    
Nc                 C   s   | j }| jD ]j\}}g }|D ]P}t||rb|jtu rT|d u rHt    S || ql||j q|| q|| }qg | jd d < || _|S r<   )r   r   rD   rP   r  rx   r  )ri   Z
base_valuer   opparamsvaluesparamrP   r6   r6   r9   r    s    


zauto._resolve)N),ry   r   r   re   r  enum_memberr  r   r   r   r   r   r   r   r   r   r   r   r   r   PY2r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r~   r   rP   rp   r  r6   r6   r6   r9   r     sR   


r   )_commonc                   @   s(   e Zd ZdZdZdZdZdZdd ZdS )	_EnumArgSpec)r   z all args except *args and **kwds)r   zthe name of the *args variable)rS   zthe name of the **kwds variable)rV   zany default values)   z0number of required values (no default available)c                 C   sN   t |}|\}}}}|r,|dt|  }n|dd  }tt|||||fS r   )r   r[   r   __new__r  )r   Z	_new_funcZargspecr   r   r   r   reqsr6   r6   r9   r    s    z_EnumArgSpec.__new__N)	ry   r   r   r   r   r   r   requiredr  r6   r6   r6   r9   r    s   r  c                   @   s    e Zd ZdZdd Zdd ZdS )_proto_memberzW
    intermediate step for enum members between class execution and final creation
    c                 C   s
   || _ d S r<   rO   r  r6   r6   r9   rk     s    z_proto_member.__init__c              
      s  t || | j i }d}d}d}d}t trL rLt d trL } d  t trn jtu rn j} j}nlt tr j} jf j } j nFt tr j} j}n.t t	rĈ j  f}nt tsֈ f}n }|dur f|dd   i } }~|j
sd|jv r|j
rb|d }|dd }d|jv rH|dd }n|}|dd }|d  n|jr|jr|t|j d d }|js|dt|jj }|d  n@|jr|dd }|dd }|d  n|jr|d  n|}n|}|jtu r|f}|js||}	n|j|g|R i |}	t|	ds|jtu rT |	_nPz|j|i ||	_W n8 ty }
 ztd}|
|_|W Y d}
~
n
d}
~
0 0 |	j ||	_||	_|	j|i | t|j|	_tdur"t|tr"| j  O  _ t! r| j" O  _"d|j #  d |_$|j%r:|j&| nPt't(}zz&|j)  }	|j*rh||	j+ &| W n\ ty   |j,D ]<\}}|j+}||	jkr|j*r|| &| |}	 qqt-Y n0 W nd t-y.   tdu st|ts|j&| n,tdur*t|tr*t! r*|j&| Y n0 |rg }|. D ].\}}d	/|}|&d
|||| jf  qBt0d|j1d/|f t| jtr|	| j_2d}d}d}|j3dd D ]p}|j45|}|durt|t6t7fr|}|}d} q,n0t8|r |}|pd}|p|}qnd}|}q|rt6 }|	|_9|:|| |dv rt;|dd|_<t;|dd|_=t;|dd|_>t;|dd|_?t;|dd|_@t;|dd|_A||_B||_CtD||| ntD|||	 |	|jE|<  f| }|j
r||vr||f7 }||	_F|D ] |j
rH |j)v s:tG fdd|j,D rHt0d f z|j%rZtd|	|j) < W n( ty   | j, |	ff7  _,Y n0 qdS )zR
        convert each quasi-member into an instance of the new enum class
        r6   Nr   r   rP   _value_z/_value_ not set in __new__, unable to create itrS   ,z%s --> %s [%r]z%s: duplicate names found: %sz;  r   descattr)r   r  rb   r   rc   r   rd   r   c                 3   s   | ]\}}| kV  qd S r<   r6   r   r   rK   rO   r6   r9   r     r   z-_proto_member.__set_name__.<locals>.<genexpr>z%r has already been usedzcannot use dict to store value)HdelattrrP   rD   r   r   r  r   r   r   ZMember_multivalue__creating_init__auto_init_
_new_args_r[   _auto_args__member_type_
_use_args__new_member_hasattrobjectr  	ExceptionrG   	__cause__r   __objclass__rk   _member_names__sort_order_r$   rA   _flag_mask_r	   _singles_mask_rX   
_all_bits_	_noalias_rx   r   r_   _value2member_map__unique_rw   _value2member_seq_r   rC   rz   
ValueErrorry   r
  __mro__rB   rv   r   r`   is_descriptorr{   r   rh   rb   _getrc   Z_setrd   Z_delZ
_attr_typeZ	_cls_typesetattrru   _values_r:   )ri   
enum_classmember_namer   r   Z	init_argsZextra_mv_argsr   Zmv_argr
  excteZ	nonuniqueZunhashable_valuecanonical_memberrw   messagealiasesZbad_aliasesZfound_descriptorZdescriptor_typeZ
class_typebaser  redirectr  r6   rO   r9   r     sT   




















z_proto_member.__set_name__N)ry   r   r   re   rk   r   r6   r6   r6   r9   r    s   r  c                       sH   e Zd ZdZ fddZ fddZ fddZdd	 Zd
d Z  Z	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.
    c                    s   t t|   || _|| _|| _|| _d | _g | _t	 | _
|| _t|v  | _}t|v | _t|v | _| jrz| jrztd| | jr| jrtd| || _|| _d| _d| _t|v| _g | _g | _| jrg d| _d| _d| _g | _d| _d S )Nz2%r: AddValue and MagicValue are mutually exclusivez4%r: MultiValue and MagicValue are mutually exclusiver6   F)r   r   classmethodT)superr    rk   	_cls_name_constructor_init_constructor_start_constructor_boundary_generate_next_value_member_namesset_member_names_set	_settingsr   	_addvaluer   _magicvaluer   _multivaluerG   _startZ_addvalue_value	_new_args
_auto_args_locked_init_ignore_ignore_init_done_allow_init_last_values_auto_called)ri   cls_namesettingsstartconstructor_initconstructor_startconstructor_boundaryr   r   r6   r9   rk     s:    



zEnumDict.__init__c                    s   || j kr| j | vrtS | js@|| v s@|| jv s@t|s@t|rPtt| |S | j	r| 
|| jt| j| jd d  }| || |S tdd S )Nz"Magic is not set -- why am I here?)r@  r   rO  rQ  	is_sunder	is_dunderr?  r    __getitem__rJ  rD  rL  r[   rE  rT  __setitem__r#  ri   r   rP   r\  r6   r9   r_    s$    "zEnumDict.__getitem__c                    sl  d}t | j|rnt| j|r$nt|r~|dvrLtd| j|f q| jsp|dvrptd| j|f q|dkr| jrtd| j t|t	r|
 }nt|}|| _t|| j@ }|rtd| jd	d
d |D f d| _q|dkr| jrztd| j q|dkr:| jr0td| j || _q|dkr|t|ttfsZ|f}t|tsnt|}|  j|O  _t|v rt|v rtd| j n"t|v rt|v rtd| j tg d}| jD ],}||vrtd| j||f d||< q|d | _|d | _|d | _| j | _| jrF| jsFg d| _| jrp| jrpd| jvrp| jdd t| j}n|dkr | j rtd| j |}t|t	r|!dd
 }| jrd| jvr| jdd | jrtd| j || _|}nz|d kr| j"rtd!|}|d"urnt|t#r<|j$}n(t|t%rXtd#| j n|}t#|}t&|| _'t(| d$| n.t)|r|d%krd&}| jstd| j|f nF|d'krt|t#r|j$}t*|| _+n|d(krt|t%st%|}t,|rd| _n|| jv r.td)| j|f n~|| jv r>nnt,|sd*| _|| v rptd+| j|| | f t-|t.u r||_/| jr&td,| j n| jr| js| 0||}nh| jr t-|tur|f}t|d t1r| 2||d f|d-d"  }| jr&| 0||}nt|t1r:| 2||}nt-|tu rt3d.d |D rg }	|D ]>}
t|
t1rd*}| 2||
}
|
j4}
| j56|
 |	6|
 qdt|	}nxt|t1s&d/p| j+o| j+j7}t8| jp|}t|trt8|}nd-}t8| jd-kp|}||k r&| 0||}n | jrt|t1rB|j9}nt|tsV|f}n|}t8| jt8|krtd0| j|| j|f | j:6| | j;| nd| _d*| _t|sVt)|sVt| j|sVt,|sV|sd}nrt|t1r | j56|j4 nVt-|tu rJ|rVt|d t1r8| j56|d j4 n| j56|d  n| j56| t<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)Zcreate_pseudo_member_rl  rm  rn  z"%r: cannot set %r after init phasere  z%%r: ignore can only be specified oncez0%r: _ignore_ cannot specify already set names %srs   c                 s   s   | ]}t |V  qd S r<   reprr   r6   r6   r9   r   C  r   z'EnumDict.__setitem__.<locals>.<genexpr>rj  z4%r: boundary specified in constructor and class bodyrf  z1%r: start specified in constructor and class bodyrc  -%r: NoAlias and Unique are mutually exclusivez*cannot specify both MultiValue and NoAliasr   r   r   r   r   z"%r: unknown qualifier %r (from %r)r   r   r   )r   r>  r   rP   r   rb  z3%r: init specified in constructor and in class bodyr   z0%r: _init_ and MagicValue are mutually exclusiveri  z4_generate_next_value_ must be defined before membersNzB%r: _generate_next_value must be a staticmethod, not a classmethodrD  	__order__rd  r  __init_subclass__z%r: attempt to reuse name: %rFz%r: %s already defined as %rz(%r: enum() and AddValue are incompatibler   c                 s   s   | ]}t |tV  qd S r<   )rD   r   r   r6   r6   r9   r     r   r6   z=%s.%s: number of fields provided do not match init [%r != %r])?Zis_internal_classr@  is_private_namer]  r/  rS  rR  rG   rD   
basestringsplitr_   rQ  rF  rG  rz   rC  rB  rL  r   rH  r   r   r   r   fromkeysrK  rI  rJ  rO  rP  insertrA  rZ   rU  r   __func__r>  r   rN  r3  r^  r  rM  r1  rl   r   rw   _gnvr   _convert_autor:   rP   rT  rx   r  r[   r   rE  addr?  r    r`  )ri   r   rP   Z
auto_storealreadyallowed_settingsargrb  ZgnvZauto_valuedr   new_args
target_len
source_len
multi_argsZ
test_valuer\  r6   r9   r`    sL   



























"


,zEnumDict.__setitem__c                 C   s   |j s|js|jtu r|j s"|jr*|j }nd}dp>| jo>| jj}t| jpJ|pPd}t|t	u rht|}nd}t| jdkp||}||k r| 
||}d| _|j r||_n||_|S )Nr6   r   T)r   r   rP   r  rM  r  r[   rP  rl   r   r  rU  r   )ri   r   rP   r  r  r  r  r  r6   r6   r9   r    s"    
zEnumDict._convert_autoc                 C   s   | j rBt|ts|f}| j|| jt| j| jd d  g|R  }n"| || jt| j| jd d  }t|trt|dkr|d }|S Nr   r   )rN  rD   r   rD  rL  r[   rE  rT  ra  r6   r6   r9   r     s    
,"zEnumDict._gnv)
ry   r   r   re   rk   r_  r`  r  r  __classcell__r6   r6   r\  r9   r      s   # Rr    r   c                       s  e Zd ZdZed6ddZdd Zd7 fdd		Zd
d Ze	ddddddfddZ
dd Zdd Zdd Zedd Zdd Zdd Zdd Zdd ZeZdd  Zd!d" Zd#d$ Zd8d&d'Zd9d(d)Zed*d+ Zed,d- Zed.d/ Zed0d1 Zed2d3 Zed4d5 Z   Z!S ):r   zMetaclass for EnumNr6   c                    s  |  || td u r"|dkr"d}nd}|d u}	|d u}
|d u}t|tsN|f}t|}d }d }| ||\ }|d urt|dd }t|d|}|| |O }|p|jd d  }|j	}|d u r|j
}nd}t|v r|rd|vrt|tr|dd nd	| }t|v rt|v rtd
| t|v r<t|v r<td| tg d}|D ] }||vrNtd||f qNt||||	|
|d} |_dtd u r|dkptd uotdd |D  |_td urJtdd |D rJ ttf vrJt|v r"dd }t||d<  fdd}||d< n&zt|j|_W n tyF   Y n0 nx|st|drht|j|_|r|||d< d|_|d urt|t r|!dd" }||_#nt|drt|j|_|d urt||d< |S )Nr$   TFri  r   r   rP   r   zvalue rt  z1%r: MultiValue and NoAlias are mutually exclusiveru  z%r: unknown qualifier %r)rV  rW  rX  rY  rZ  r[  )r   flagc                 s   s   | ]}t |tV  qd S r<   )rA   r$   r   br6   r6   r9   r   A  r   z'EnumType.__prepare__.<locals>.<genexpr>c                 s   s   | ]}|t u V  qd S r<   )r$   r  r6   r6   r9   r   C  r   c                 _   s   d| f| S )NrS   r6   )rw   rX  rN   r  r   r   r6   r6   r9   ri  L  s    z3EnumType.__prepare__.<locals>._generate_next_value_c                    s     | |}||_|S r<   )r  r  )r   
flag_valueZ
type_valueobjmember_typer6   r9   r  O  s    z%EnumType.__prepare__.<locals>.__new__r  __new_member__r  rv  rd  )$_check_for_existing_members_r$   rD   r   rF  _get_mixins_rh   _get_settings_r  _order_function_rf  r   r_   r}  r   r   rG   r   r   r|  r    Z_member_typer:   Z
_base_typebaseintegerr"  r   r  r  rM  r!  Z_inherited_gnvrz  rZ   r{  rP  )metaclsr   basesinitrX  rW  boundaryr   Zinitial_flagrY  rZ  r[  generateorder
first_enumr  r  	enum_dictri  r  r6   r  r9   __prepare__  s    


.



zEnumType.__prepare__c                 O   s   d S r<   r6   )r   r   r   r6   r6   r9   rk   i  s    zEnumType.__init__c           9   
      sb
  t |turF|dd }|dd }|dd}|d|dd }	|dd }
|dd }|d	d }|d
d }|dd }|dd }|dd }|dd }|dd }|dd }|dd }|dd }t|d|}t|d|}t fdd| D }|}| j |||d}|r,||d< |p6|j}|	d u r`|d}	|	d ur`|		 }	t
|trt|}nB|	d u rdd tt| D }nt
|	tr|	dd  }}	nt|	r|rt
|tsd|}td|rd| pddg}g }| D ]\}}|r:t
|ts.|f}|f| }nt||f}|jt|krtd|jd |jt|d d!d |D f |||  qd"d t||	d#D }n|	}d$D ]"}t | }|d ur|||< q|D ],}z|| ||< W n ty
   Y n0 q| D ]\}}||vr|||< q~	~
~~~~~~d%|_|j} t| td&d'g@ }!|!rt d(d |!f |dd }	t
|	tr|	dd }	|j}|j!}|j"}g }"|j#}#|j$}$d)}%|d urd%}%|d d  }"d|"v r|"d* dkrtd+t%|v }&t&|v }'t'|v }(t(|v })|)dg d |d }*|*D ]}+||+d  qF|pj|dd }|d
},|,d urt |,t*urt*|,},t| }|,d ur|,|d
< | + |\}-| ,||-\}}.}/t*||d,< |/|d-< | D ]}|| }t-|||< q|"|d.< |'|d/< |&|d0< |(|d1< |)|d2< g |d3< t |d4< |d5< i |d6< d|d7< ||d< ||d< ||d8< |#|d9< |$|d:< d |d;< | . ||d<< |pt|-dd |d< d*|d=< d*|d>< d*|d?< d |d@< | D ] \}}0t
|0t/r|0j0||< qd)}1dA|vr>t1ur>dB}2t2fdCdD|2D s>t3| d%}1dE|vrPdF|dE< zd }3t 4|  ||W n2 t5y }4 z|4j6p|4}3W Y d }4~4n
d }4~40 0 |3d ur|3t7t8k r2| D ]}j9| :| qj9 D ]0\}}0|| v rqt;|0dGr|0:| qt<d ur2t;dHr2t=>  t?d urt?|v rt1u rXtdIdJ|vrtj@_@j@|dJ< dK|vrjA}5|5t1jAu rjB}5|5_AjA|dK< dLD ]r}||v rqt|}6t|d }7t|-|d }8|7d ur|7|6kr|dAkr|1rqtC||8 |8||< qtDd urdtEtDrddMD ]*}||vr8tC|ttD| |8||< q8t7tFk rtEtGrtCdNttGdN n0tHrtEtGrdOD ]}5tC|5ttG|5 qt<d ur|.rtCdPj9d  tCdt<j9d  |		r4t
|	t*	r
|	jI}	t|		r4t*|	_JdQd t|	d#D }	tDd u 	rH dRk	s^tDd u	rtEtD	stKd tKd= tKd> tKd? tKd@ nXtDd u	rtEtD	rdSd D tdSd D k	r҈jL_M|		rfdTd|	D }	j9 D ]2\}}t
|tN	rt
|j0tO	r|j0j0|_0	q|	
r^fdUd|	D }	|	jPk
r^tdVjP|	f S )WNrb  rf  rc  r6   rd  rw  re  rg  rh  ri  rl  rm  rn  rj  ro  rp  rq  r  r   r~  c                    s:   g | ]2\}}t |st|st |st|s||fqS r6   )r]  r^  ry  r1  r   r   r6   r9   r     s   "z$EnumType.__new__.<locals>.<listcomp>)r  rX  c                 S   s   g | ]\}}|qS r6   r6   r   rw   rP   r6   r6   r9   r     r   r  rv  r{   zname rw   rP   z)%d values expected (%s), %d received (%s)rs   c                 S   s   g | ]}t |qS r6   rr  r   r6   r6   r9   r     r   c                 S   s   g | ]
}|j qS r6   rw   r   rK   r6   r6   r9   r     r   r   )rl  rm  rn  re  rg  rh  ri  rd  r  rl  rm  rn  rj  ro  rp  rq  Tmror   zinvalid enum member name(s): %sFr   z7'value', if specified, must be the first item in 'init'r   r  r  r  Z_magicvalue_r+  r-  r&  ru   r  r,  r.  r  r  r  r  _value_repr_r(  r)  r*  
_inverted___reduce_ex__)__getnewargs_ex____getnewargs__r  
__reduce__c                 3   s   | ]}| j v V  qd S r<   rB   r  r  r6   r9   r   7  r   z#EnumType.__new__.<locals>.<genexpr>re   zAn enumeration.r   rx  zOReprEnum subclasses must be mixed with a data type (i.e. int, str, float, etc.)
__format____str__)r~   r  r  r  )r   r   r   r   r   r   r   Z__cmp__)__le____lt____gt____ge__r   r   r   r  c                 S   s   g | ]
}|j qS r6   r  r  r6   r6   r9   r     r   r$   c                 S   s   g | ]
}|j qS r6   r  r  r6   r6   r9   r     r   c                    s(   g | ] }| j vs t | jr|qS r6   )ru   r	   r  r   or5  r6   r9   r     s   c                    s.   g | ]&}| j vs&| j v r| jv r|qS r6   )ru   r&  r  r  r6   r9   r     s   
z*member order does not match _order_:
%r
%r)Qrl   r    poprh   r   rC   r  rP  rv   r   rD   OrderedDictr   r_   rz  rZ   r{  callablerz   r   r   Z_defined_len_r[   rG   _fields_rx   r   localsr   rO  rE  rF  r/  rL  rH  rM  rN  r   r   r   r   
setdefaultr   r  
_find_new_r  _find_data_repr_Z	nonmemberrP   r"  r:   make_class_unpicklabler  RuntimeErrorr$  pyverPY3_6rB   r   r!  r!   r?  rx  r(   r  r  r~   r3  r$   rA   ZPY2_6intr  r~  r  r  rq  ro  r   r   r&  )9r  r   r  clsdictr  rX  rW  r  r   rd  re  rg  rh  ri  rl  rm  rn  rj  ro  rp  rq  r  enum_membersZoriginal_dictZcalced_orderr{   rw   rP   
name_valuer  r   r   Zmember_namesinvalid_namesZcreating_initr  Z	auto_argsZ	auto_initr   r   r   r   ignorer   r  r  save_newnew_uses_argsr  Zunpicklablemethodsr7  er   class_method
obj_methodenum_methodr\  )r   r5  r  r9   r  l  s   




















"











	







"

	zEnumType.__new__c                 C   s   dS )z6
        classes/types should always be True.
        Tr6   r   r6   r6   r9   __bool__  s    zEnumType.__bool__r   c              	   C   s,   |du r|  | |S | j|||||||dS )a  Either 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)modulequalnamerl   rX  r  )r  _create_)r   rP   namesr  r  rl   rX  r  r6   r6   r9   __call__  s    zEnumType.__call__c                 C   sF   t || rdS z|| jv W S  ty@   |dd | jD v  Y S 0 dS )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.
        Tc                 S   s   g | ]\}}|qS r6   r6   r  r6   r6   r9   r     r   z)EnumType.__contains__.<locals>.<listcomp>N)rD   r,  rG   r.  r   rP   r6   r6   r9   __contains__  s    
zEnumType.__contains__c                 C   sp   || j v rtd| j|f t| |}t|trDtd| j|f nt|tr`td| j|f t| | d S )Nz!%s: cannot delete Enum member %r.z%s: cannot delete constant %rz%s: cannot delete property %r)	ru   r   ry   get_attr_from_chainrD   r   r   rl   __delattr__)r   r  
found_attrr6   r6   r9   r  
  s    



zEnumType.__delattr__c                 C   s   t | jg d }| jtjur(|d | jtjur>|d ttdrR|d dD ],}t	| |t	t|t	t
|fvrV|| qV| jtu rt|S tt t| j|B S d S )N)	r   r  re   r_  __iter____len__rF   r   ry   r  rx  r   )rk   r  r~   r  )rF  r&  r   r"  r  r  rx  r!   r!  rh   r$   r  r   dir)r   interestingr   r6   r6   r9   __dir__  s    




zEnumType.__dir__c                 C   s
   | j  S )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.
        )ru   r   r   r6   r6   r9   rF   1  s    zEnumType.__members__c                 C   s   z| j | W S  ty*   t d }Y n0 td urt| trd|v rz*| d}|dD ]}|| | O }qZ|W S  ty   |Y n0 | |}t|| r|S |d S )Nr   |r   )	ru   r   _sysexc_infor$   rA   r{  rn  rD   )r   rw   r7  rn   rH   r6   r6   r9   r_  :  s     


zEnumType.__getitem__c                    s    fdd j D S )Nc                 3   s   | ]} j | V  qd S r<   ru   r   rw   r   r6   r9   r   O  r   z$EnumType.__iter__.<locals>.<genexpr>r&  r   r6   r   r9   r  N  s    zEnumType.__iter__c                    s    fddt  jD S )Nc                 3   s   | ]} j | V  qd S r<   r  r  r   r6   r9   r   R  r   z(EnumType.__reversed__.<locals>.<genexpr>)reversedr&  r   r6   r   r9   __reversed__Q  s    zEnumType.__reversed__c                 C   s
   t | jS r<   )r[   r&  r   r6   r6   r9   r  T  s    zEnumType.__len__c                 C   s   d| j f S )Nz
<aenum %r>r   r   r6   r6   r9   r~   Y  s    zEnumType.__repr__c                 C   s   | j di }||v r(td| j|f t| |}t|trPtd| j|f n*t|ttfrzt|tsztd| j|f t	
| || dS )a  Block attempts to reassign Enum members/constants.

        A simple assignment to the class namespace only changes one of the
        several possible ways to get an Enum member from the Enum class,
        resulting in an inconsistent Enumeration.
        ru   z%s: cannot rebind member %r.z%s: cannot rebind constant %rz%s: cannot rebind property %rN)rB   rv   r   ry   r  rD   r   r   r   rl   __setattr__)r   rw   rP   
member_mapr  r6   r6   r9   r  \  s    

zEnumType.__setattr__c                 O   s(   dd l }|jdtdd | j|i |S )Nr   zB_convert is deprecated and will be removed, use _convert_ instead.rS   )
stacklevel)warningswarnDeprecationWarning	_convert_)r   r   r   r  r6   r6   r9   _converts  s
    zEnumType._convertFc           	         s   t tj| }rt n| fdd D }z|jdd d W n" tyn   |jdd d Y n0 | ||||p~td} t| _|rt	|  n|
| j | ||< | S )z[
        Create a new Enum subclass that replaces a collection of global constants
        c                    s    g | ]} |r|| fqS r6   r6   )r   r   filtersourcer6   r9   r     r   z&EnumType._convert_.<locals>.<listcomp>c                 S   s   | d | d fS r  r6   tr6   r6   r9   r     r   z$EnumType._convert_.<locals>.<lambda>r   c                 S   s   | d S r   r6   r  r6   r6   r9   r     r   )r  r  )varsr  moduleskeyssortrG   r/   r4   r  global_enumupdaterF   )	r   rw   r  r  r  r  Z	as_globalmodule_globalsmembersr6   r  r9   r  y  s     	

zEnumType._convert_c              	   C   s
  t r>t|tr>z|d}W n  ty<   td|f Y n0 | j}|du rT| f}	n|| f}	| ||	\}
}t|dd}t|d|}t|t	r|
dd }t|ttfr|rt|d t	r|g  }}g }t|D ]6\}}|||||dd }|| |||f qd}d}|D ]Z}|du rJt|t	r>i }n|||	}t|t	rf|||  }}n|\}}|||< q|du r|||	}|j|||	||d	}|du rztd
jd }W n ttfy   Y n0 |du rt| n||_|dur||_|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 ASCIINri  r   r  rv  r   )r  rS   ry   )r  rD   unicodeencodeUnicodeEncodeErrorrG   r   r  rh   rz  rZ   r{  r   r_   	enumeraterx   r  r  r  	_getframe	f_globalsr   r   r  r   r   )r   
class_namer  r  r  rl   rX  r  r  r  _r  r  original_nameslast_valuesrN   rw   rP   itemr  r6  member_valuer5  r6   r6   r9   r    s^    

&







zEnumType._create_c                 C   sF   t d u rd S |D ]0}|jD ]$}t|t r|jrtd||f qqd S )Nz<aenum %r> cannot extend %r)r!   r0  rA   r&  rG   mclsr  r  chainr<  r6   r6   r9   r    s    
z%EnumType._check_for_existing_members_c                 C   sp   |rt du rtt fS | || |d }|tv r8|d }t|t sJtd| ||pXt}|jrhtd||fS )zReturns the type for creating enum members, and the first inherited
        enum class.

        bases: the tuple of bases that was given to __new__
        NrW   zZnew enumerations should be created as `EnumName([mixin_type, ...] [data_type,] enum_type)`z*cannot extend enumerations via subclassing)r!   r"  r  rE   rA   rG   _find_data_type_r&  )r
  r  r  r  r  r6   r6   r9   r    s    
zEnumType._get_mixins_c                 C   s   |D ]}|j D ]v}|tft v r$qqt|tr<|j    S d|jv rd|jv rrd|jv rr|jd jrrt    S |jd     S qqd S )Nr~   __dataclass_fields__Z__dataclass_params__)	r0  r"  rE   rD   r   r  rB   rs  _dataclass_reprr	  r6   r6   r9   r    s     



zEnumType._find_data_repr_c                 C   s   t  }|D ]}d }|jD ]}|tft v r.qqt|trT|jtur||j  q
qd|jv shd|jv rt|trvqnt	d urt
|t	rq||p|  q
q|p|}qq
t|dkrtd||f n|r| S d S d S )Nr  r  r   z%r: too many data types: %r)rF  r0  r"  rE   rD   r   r  r  rB   
StdlibFlagrA   r[   rG   r  )r
  r  r  
data_typesr  	candidater<  r6   r6   r9   r    s.    



zEnumType._find_data_type_c                 C   s@   t  }| D ]0}|jD ]$}t|tr|jD ]}|| q(qq
|S )zuReturns the combined _settings_ of all Enum base classes

        bases: the tuple of bases given to __new__
        )rF  r0  rA   r!   rc  r  )r  rW  r  r<  r\   r6   r6   r9   r  5  s    


zEnumType._get_settings_c           
      C   s   | dd}|duo|du}|du r|dD ]L}||fD ]2}t||d}|ddjtjtjtjfvr4|} qhq4|dur( q|q(tj}|du s|tjtjfv rd}	nd}	|||	fS )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)r  r  FT)rv   rh   r  r"  r!   
StdlibEnum)
r
  r  r  r  r  r  r   possibletargetr  r6   r6   r9   r  C  s,    zEnumType._find_new_)NNr6   N)NNr6   N)NNF)NNNr   N)"ry   r   r   re   r>  r  rk   r  r  r   r  r  r  r  r   rF   r_  r  r  r  __nonzero__r~   r  r  r  r  r  r  r  r  r   r  r  r  r6   r6   r\  r9   r     sH   W  x


G





r   c                   @   s   e Zd ZdS )r   N)ry   r   r   r6   r6   r6   r9   r   w  s   r!   zNGeneric enumeration.

    Derive from this class to define new enumerations.

)r   rj   nsc                 C   s   | j r
dS dS d S )Nz	(*values)z\(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)r  r   r6   r6   r9   __signature__  s    r  c                 O   s   | j }|d u rd S d|v r&|dd  }|rt|t|k rVtdt||t||f t||D ]\}}t| || q`t|t|k r|t|d  }|D ]2}||t}|tu rtd|f t| || q|rtdd|  d S )NrP   r   z,%d arguments expected (%s), %d received (%s)zmissing value for: %rzinvalid keyword(s): %srs   )	r  r[   rG   zipr3  r  Z	undefinedrz   r  )ri   r   r   r  rw   r  remaining_argsrP   r6   r6   r9   rk     s*    rk   c                 C   s   t | jv rtdt|| u r"|S z| j| W S  ty@   Y n6 tyt   | jD ]\}}||krR|   Y S qRY n0 | |}t|| r|S |d urt	| dd t
u r|S |d u r|tu rtd| jf qtd|| jf ntd| j|f d S )Nz1NoAlias enumerations cannot be looked up by valuerj  z"%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)r   rc  rG   rl   r,  r   r.  rm  rD   rh   r.   r   r/  ry   )r   rP   r  r{   rn   r6   r6   r9   r    s4    


r  c                 K   s6   t tk r|r2td|f ntt| jf i | d S )Nz unconsumed keyword arguments: %r)r  r  rG   r?  r!   rx  )r   r   r6   r6   r9   rx    s    rx  c              	   O   sN   t |D ]*}z|d }W  q8W q ty0   Y q0 q|}|rF|f| S |S d S r   )r  rG   )rw   rX  rN   r  r   r   
last_value	new_valuer6   r6   r9   ri    s    

ri  c                 C   s   dS )z'deprecated, use _missing_value_ insteadNr6   r  r6   r6   r9   rl    s    rl  c                 C   s
   |  |S )zused for failed value access)rl  r  r6   r6   r9   rm    s    rm  c                 C   s   dS )zused for failed item accessNr6   )r   rw   r6   r6   r9   rn    s    rn  c                 C   s,   | j jp| jj j}d| j j| j|| jf S )Nz<%s.%s: %s>)r   r  r  r~   ry   r   )ri   Zv_reprr6   r6   r9   r~     s    r~   c                 C   s   d| j j| jf S N%s.%s)r   ry   r   r   r6   r6   r9   r    s    r  c                    s    j jtu rtg d}nt fddt D }t dg D ]}|d dkrB|| qB j  D ]r}|j	 D ]b\}}|d dkrqvt
|tr|jdus| jvr|| q|| qvt
| j sv|| qvqht|S )z<
        Returns all members and all public methods
        )r   re   r   r   r   c                 3   s   | ]}| j vr|V  qd S r<   r  )r   rH   r   r6   r9   r   
	  r   z__dir__.<locals>.<genexpr>rB   r   r  N)r   r  r"  rF  r  rh   r  r  rB   rC   rD   r   rb   ru   discardr   )ri   r  rw   r   r  r6   r   r9   r  	  s"    
r  c                 C   s   t t | |S r<   )r   r  )ri   format_specr6   r6   r9   r  	  s    r  c                 C   s
   t | jS r<   )r   r   r   r6   r6   r9   r   !	  s    r   c                 C   s   | j | jffS r<   )r   r  ri   protor6   r6   r9   r  %	  s    r  c                 C   s   t d| jj|jjf d S )Nzunorderable types: %s() <= %s()rG   r   ry   r   r6   r6   r9   r  )	  s    r  c                 C   s   t d| jj|jjf d S )Nzunorderable types: %s() < %s()r$  r   r6   r6   r9   r  -	  s    r  c                 C   s   t d| jj|jjf d S )Nzunorderable types: %s() >= %s()r$  r   r6   r6   r9   r  1	  s    r  c                 C   s   t d| jj|jjf d S )Nzunorderable types: %s() > %s()r$  r   r6   r6   r9   r  5	  s    r  c                 C   s   t || jr| |u S tS r<   rD   r   r   r   r6   r6   r9   r   :	  s    r   c                 C   s   t || jr| |uS tS r<   r%  r   r6   r6   r9   r   @	  s    r   c                 C   s   | j S r<   r   r   r6   r6   r9   rw   N	  s    rw   c                 C   s   | j S r<   r  r   r6   r6   r9   rP   S	  s    rP   c                 C   s   | j S r<   )r4  r   r6   r6   r9   r  X	  s    r  c                 C   s   | j S r<   r  r"  r6   r6   r9   pickle_by_global_namec	  s    r&  c                 C   s   t | j| jffS r<   )rh   r   r   r"  r6   r6   r9   pickle_by_enum_nameh	  s    r'  c                    s$   j  d fdd  D S )Nrs   c                 3   s*   | ]"} | j rd |t|f V  qdS )r   N)rs  rh   )r   r   Zdcfri   r6   r9   r   n	  s   
z"_dataclass_repr.<locals>.<genexpr>)r  rz   r  r   r6   r(  r9   r  l	  s    r  r(   re   zIOnly changes the repr(), leaving str() and format() to the mixed-in type.c                   @   s   e Zd ZdZdS )r"   z8
    Enum where members are also (and must be) ints
    N)ry   r   r   re   r6   r6   r6   r9   r"   	  s   r"   c                   @   s&   e Zd ZdZdd ZejZdd ZdS )r#   zr
    Enum where members are also (and must already be) strings

    default value is member name, lower-cased
    c                 O   sb   |rt d| j |rDt|d tsDt d| j|d t|d f t| }t| |}||_|S )Nz#%r: keyword arguments not supportedr   z#%s: values must be str [%r is a %r])rG   ry   rD   r   rl   r  r  )r   r  r   rP   r{   r6   r6   r9   r  	  s     zStrEnum.__new__c                 C   s   |   S )zD
        Return the lower-cased version of the member name.
        )lower)rw   rX  rN   r  r6   r6   r9   ri  	  s    zStrEnum._generate_next_value_N)ry   r   r   re   r  r   r  ri  r6   r6   r6   r9   r#   	  s   r#   c                   @   s   e Zd ZdZdd ZdS )r&   z}
    Enum where members are also (and must already be) lower-case strings

    default value is member name, lower-cased
    c                 O   s6   t j| |g|R i |}|| kr2td| |S )Nz%r is not lower-case)r#   r  r)  r/  r   rP   r   r   r  r6   r6   r9   r  	  s    zLowerStrEnum.__new__Nry   r   r   re   r  r6   r6   r6   r9   r&   	  s   r&   c                   @   s    e Zd ZdZdd Zdd ZdS )r'   z}
    Enum where members are also (and must already be) upper-case strings

    default value is member name, upper-cased
    c                 O   s6   t j| |g|R i |}|| kr2td| |S )Nz%r is not upper-case)r#   r  upperr/  r*  r6   r6   r9   r  	  s    zUpperStrEnum.__new__c                 O   s   |   S r<   )r,  )rw   rX  rN   r  r   r   r6   r6   r9   ri  	  s    z"UpperStrEnum._generate_next_value_N)ry   r   r   re   r  ri  r6   r6   r6   r9   r'   	  s   r'   c                   @   s   e Zd ZdZeZdS )AutoEnumza
        automatically use _generate_next_value_ when values are missing (Python 3 only)
        N)ry   r   r   re   r   rc  r6   r6   r6   r9   r-  	  s   r-  c                   @   s   e Zd ZdZdd ZdS )r   z
    Automatically assign increasing values to members.

    Py3: numbers match creation order
    Py2: numbers are assigned alphabetically by member name
         (unless `_order_` is specified)
    c                 O   sR   t | jd }| jtu r&t| |}n"| jtu r>t| |}n
t| }||_|S r   )r[   rF   r  r  r  longr"  r  )r   r   r   rP   r  r6   r6   r9   r  	  s    


zAutoNumberEnum.__new__Nr+  r6   r6   r6   r9   r   	  s   r   c                   @   s   e Zd ZeZdS )r   N)ry   r   r   r   rc  r6   r6   r6   r9   r   	  s   r   c                   @   s   e Zd ZdZeZdS )r   z1
    Multiple values can map to each member.
    N)ry   r   r   re   r   rc  r6   r6   r6   r9   r   	  s   r   c                   @   s   e Zd ZdZeZdS )r   zQ
    Duplicate value members are distinct, but cannot be looked up by value.
    N)ry   r   r   re   r   rc  r6   r6   r6   r9   r   	  s   r   c                   @   s0   e Zd ZdZdd Zdd Zdd Zdd	 Zd
S )r   z7
    Add ordering based on values of Enum members.
    c                 C   s   | j |j u r| j|jkS tS r<   r   r  r   r   r6   r6   r9   r  	  s    zOrderedEnum.__ge__c                 C   s   | j |j u r| j|jkS tS r<   r/  r   r6   r6   r9   r  	  s    zOrderedEnum.__gt__c                 C   s   | j |j u r| j|jkS tS r<   r/  r   r6   r6   r9   r  
  s    zOrderedEnum.__le__c                 C   s   | j |j u r| j|jk S tS r<   r/  r   r6   r6   r9   r  
  s    zOrderedEnum.__lt__N)ry   r   r   re   r  r  r  r  r6   r6   r6   r9   r   	  s
   r   c                   @   s   e Zd Zdd ZdS )r)   c                 C   s   |t ju r| jS d S r<   )r*   ZPrepareProtocolrw   )ri   protocolr6   r6   r9   __conform__
  s    
zSqliteEnum.__conform__N)ry   r   r   r1  r6   r6   r6   r9   r)   
  s   c                   @   s   e Zd ZdZeZdS )r   z+
    Ensure no duplicate values exist.
    N)ry   r   r   re   r   rc  r6   r6   r6   r9   r   
  s   r   c                    sf   t tj| }|rt |}n|}t fdd| D }| |||d} t| _|| j | ||< dS )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')
    c                 3   s"   | ]\}} |r||fV  qd S r<   r6   r  r  r6   r9   r   .
  r   zconvert.<locals>.<genexpr>r  N)	r  r  r  r   rC   r4   r  r  rF   )r   rw   r  r  r  r  r  r6   r2  r9   convert
  s    
r4  c           $      O   s>  || j v s.|| jv s.|dd t| ddD v rLtd|| j || | f d}| jdd D ]>}|j |}|dur^t|ttfr qq^td||j	f q^z2| j}| j
}| j}| j}	td	d |  D }
W n  ty   td
| f Y n0 z4| j}t| jv }t| jv }t| jv }| jp"g }W n( tyN   g }d}d}d}g }Y n0 |rj|sjtd| j	 |j}t| ddpt| ddp|}|sdd | D }t| }t| dd}|du r|r|d d pd}t| dd}|dur|||||f}n|f}|tju rd}nd}t|dkr4|\}n|}d}i }t|trX|j}|j}t|tsl|f}n|}d|v rd|v r|d}n|d |dd  }}n.|r|d |dd d  }}}|r|f}|tu r|f}|s|| }t|ds4||_ n,|| g|R i |}t|ds4|| |_ |j }|rZd|v rP|}n
|f| }||_!| j"|_#|j$|  |f| |_%t| j
|_&d }}t| dr| j'|B }| j(|B }| j)dkrt*t+|| @ }|rtdt,d-dd |D f |rt.| |||dS |j%}|/ D ]v}t|d|j g}|D ]Z} |D ]N}!| |!kr:|sT|rftd||f n t.| ||||dd       S q:q2qt0t1k rt2f}"nt2t3f}"t4| |"r0t| dr0t5|rt.| |||dS || j(@ |kr|	|dur|	|}#t.| |#|||dd S t.| |||dd!S n
t.| |S dS )"z/
    Add a new member to an existing Enum.
    c                 S   s   g | ]}|d  qS )r   r6   )r   r  r6   r6   r9   r   B
  r   zextend_enum.<locals>.<listcomp>r.  r6   z%r already in use as %rNr   "%r already in use in superclass %rc                 S   s   g | ]}|j D ]}|qqS r6   r  )r   r  r   r6   r6   r9   r   S
  r   z%r is not a supported EnumFz*no values specified for MultiValue enum %rr   r  c                 S   s   g | ]
}|j qS r6   rO   r  r6   r6   r9   r   i
  r   rf  rW   ri  TrP   r   r  r*  Zkeepz%invalid Flag %r -- missing values: %srs   c                 s   s   | ]}t |V  qd S r<   )r   )r   r   r6   r6   r9   r   
  r   zextend_enum.<locals>.<genexpr>)r   maskr4  z%r is a duplicate of %r)rw   r   r6  is_alias)r   r6  r7  )6rB   ru   rh   rG   rv   r0  rD   r   r`   ry   r&  r  r,  rF  r  r   r.  r   rc  r   r   r  r/  r  r[   r"  r   r   r   r   r  r!  r  r   r   r%  rk   r4  r'  r*  r(  rj  r_   rR   r   rz   _finalize_extend_enumr  r  r  r$   r  rA   r	   )$enumerationrw   r   r   
descriptorr<  ru   r&  r  r,  Zbase_attributesr.  Z_multi_value_Z
_no_alias_r-  r  Zmt_new_newr  rN   rX  r  r  rP   Zmore_values
new_memberr*  r(  missed
new_valuesr9  Zcanonical_values_Zcanonical_valuer  Z
flag_bases	canonicalr6   r6   r9   r   4
  s    



 











,

 
r   Fc           
   	   C   s  |p|j }d }| jdd  D ]>}|j|}|d urt|ttfrH q\qtd||jf q|s~t }|	| | t
| || |s| j| || j|< t|d|jgD ]:}	z|| j|	< W q ty   |  j|	|ff7  _Y q0 q|r|| _|| _t|jr|  j|jO  _|S )Nr   r5  r4  )rw   r0  rB   rv   rD   r   r`   rG   ry   r   r3  r&  rx   ru   rh   r  r,  r.  r*  r(  r	   r)  )
r9  r<  rw   r   r6  r7  r:  r<  r=  r   r6   r6   r9   r8  
  s4    

r8  c                 C   s^   g }| j  D ]"\}}||jkr|||jf q|rZddd |D }td| |f | S )zS
    Class decorator that ensures only unique members exist in an enumeration.
    rs   c                 S   s   g | ]\}}d ||f qS )z%s -> %sr6   )r   aliasrw   r6   r6   r9   r     r   zunique.<locals>.<listcomp>zduplicate names found in %r: %s)rF   rC   rw   rx   rz   r/  )r9  
duplicatesrw   r{   Zduplicate_namesr6   r6   r9   r   
  s    
r   )r+   c                   @   s(   e Zd ZdZe Ze Ze Ze ZdS )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)	ry   r   r   re   r   r,   r-   r.   r/   r6   r6   r6   r9   r+     s
   r+   r$   zRGeneric flag enumeration.

Derive from this class to define new flag enumerations.rj  rk  c           	      O   s   |s0|rd|f|du f| S d|f|du S nVt |}z.t|}d|d  }|r^|f| W S |W S W n tyx   Y n0 td| dS )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
    r   NrS   zinvalid Flag value: %r)maxr   r#  rG   )	rw   rX  rN   r  r   r   r  high_bitrn   r6   r6   r9   ri  /  s    

c                 c   s&   t || j@ D ]}| j|V  qdS )zY
    Extract all members from the value in definition (i.e. increasing value) order.
    N)rR   r)  r,  rv   )r   rP   valr6   r6   r9   rp  K  s    rp  ro  c                 c   s2   t | |}|jdd d |D ]
}|V  q"dS )zA
    Extract all members from the value in definition order.
    c                 S   s   | j S r<   r'  rK   r6   r6   r9   r   ]  r   z&_iter_member_by_def_.<locals>.<lambda>r   N)r_   rp  r  )r   rP   r  r{   r6   r6   r9   rq  V  s    rq  c                 C   s
   |  |S )z;
    return a member matching the given value, or None
    )rg  r  r6   r6   r9   rl  a  s    c                 G   s  |d  }}t |ts(td|| jf | j}| j}| j}||A }|| @ }| j}	d|f|dk  }
|
r|
| kr|	tu r||S |	t	u rd|

  |
 }q|	tu rd|

  |
 |@ }qtd|| jf n|d |
 }||@ }||@ | @ }|| @ }|	tu r
|r<|S n2|	tu rd}n"|	tu r<|r<td|| jf t| |}|}d}|rd}| j D ]X\}}||vrf|jrf|j|@ |jkrf|j|@ rf|| ||jO }||jO }qf|| @ |A }|r|	t	u rn0|	tu rd}n |	tu r|S td|| jf ||O }||O }|f|dd  }|jdd d | j|g|R  }t| d	d}| jtu r~|s~t| }n|p| jj| g|R  }t|d
s||_|rddd |D |_|r| jd| | 7  _nd|_| j||}|
dur|| j|
< |S )z$
    Create a composite member.
    r   r  NrS   r   c                 S   s   | j S r<   rE  rF  r6   r6   r9   r     r   z(_create_pseudo_member_.<locals>.<lambda>r   r  r  r  c                 S   s   g | ]
}|j qS r6   r   r  r6   r6   r9   r     r   z*_create_pseudo_member_.<locals>.<listcomp>z|%s)rD   r  r/  ry   r(  r)  r*  rj  r.   r/   rX   r-   r,   r_   ro  ru   rC   r  rx   r  rh  rh   r  r"  r  r!  rz   r   rk  r,  r  )r   r  rP   Zerror_valueZ	flag_maskZsingles_maskZall_bitsZunknown_bitsZunnamed_bitsr  Z	neg_valuer  Zunnamed_valueZunknown_valuer  Zfinal_valueZstill_unknownfoundrH   Zpmr  pseudo_memberr6   r6   r9   rg  i  s    













rg  c                 G   s6   | j ttf v r|S t|dk r.||   f S |S dS )zB
    Return values to be fed to __new__ to create new member.
    rS   N)r  r  r"  r[   )r   r  r  r6   r6   r9   rh    s
    rh  c                 C   sP   t || js&tdt|j| jjf |jdks:| jdkr>dS |j| j@ |jkS )zH
    Returns True if self has at least the same flags set as other.
    3unsupported operand type(s) for 'in': '%s' and '%s'r   F)rD   r   rG   rl   ry   r  r   r6   r6   r9   r    s    r  c                 c   s   |  | jD ]
}|V  qdS )z,
    Returns flags in definition order.
    N)ro  r  )ri   r{   r6   r6   r9   r    s    r  c                 C   s
   t | jS r<   )r   r  r   r6   r6   r9   r    s    r  c                 C   s8   | j }| jd u r d|j| jf S d|j| j| jf S d S )Nz<%s: %r>z<%s.%s: %r>r   r   ry   r  ri   r   r6   r6   r9   r~     s    
c                 C   s4   | j }| jd u r d|j| jf S d|j| jf S d S )Nr   r  rJ  rK  r6   r6   r9   r    s    
c                 C   s
   t | jS r<   rg   r  r   r6   r6   r9   r    s    r  c                 C   s
   t | jS r<   rL  r   r6   r6   r9   r    s    r  c                 C   sD   t || jr|j}n | jtur0t || jr0|}ntS | | j|B S r<   rD   r   r  r  r"  r   ri   r   Zother_valuer6   r6   r9   r     s    r   c                 C   sD   t || jr|j}n | jtur0t || jr0|}ntS | | j|@ S r<   rM  rN  r6   r6   r9   r   "  s    r   c                 C   sD   t || jr|j}n | jtur0t || jr0|}ntS | | j|A S r<   rM  rN  r6   r6   r9   r   ,  s    r   c                 C   s<   | j d u r6| | j| j @ | _ t| j | jr6| | j _ | j S r<   )r  r   r)  r  rD   r   r6   r6   r9   r   6  s
    
r   r   r   r   c                   @   s   e Zd ZdZeZdd ZdS )r%   zSupport for integer-based Flagsc                 C   sf   t |tr| |}n&t || js<tdt|j| jjf |jdksP| jdkrTdS |j| j@ |jkS )zP
        Returns True if self has at least the same flags set as other.
        rI  r   F)rD   r  r   rG   rl   ry   r  r   r6   r6   r9   r  L  s    
zIntFlag.__contains__N)ry   r   r   re   r/   rj  r  r6   r6   r6   r9   r%   G  s   r%   c                 C   s   |   d S )z@returns index of highest bit, or -1 if value is zero or negativer   )rX   rO   r6   r6   r9   r   ]  s    r   c                 C   s    | j jdd }d|| jf S )z{
    use module.enum_name instead of class.enum_name

    the module is the last module in case of a multi-module name
    .rW   r  )r   r   r{  r   )ri   r  r6   r6   r9   global_enum_repra  s    rP  c                    s   | j jdd  | j j}| jdu r4d || jf S t| rJd | jf S | jtj	urvd
 fdd| jdD S g }| jdD ].}|d	  r|| q|d |f  qd
|S dS )
z{
    use module.flag_name instead of class.flag_name

    the module is the last module in case of a multi-module name
    rO  rW   Nz	%s.%s(%r)r  r  c                    s   g | ]}d  |f qS )r  r6   r  r3  r6   r9   r   w  r   z$global_flag_repr.<locals>.<listcomp>r   )r   r   r{  ry   r   r  r	   rj  r+   r/   rz   rw   isdigitrx   )ri   rV  rw   rH   r6   r3  r9   global_flag_reprj  s    
 rR  c                 C   s*   | j du r | jj}d|| jf S | j S dS )z2
    use enum_name instead of class.enum_name
    Nz%s(%r))r   r   ry   r  )ri   rV  r6   r6   r9   
global_str  s    
rS  c                 C   sF   t | trt| _nt| _t | tr&|r,t| _tj	| 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
    )rA   r$   rR  r~   rP  r(   rS  r  r  r  r   rB   r  rF   )r   Z
update_strr6   r6   r9   r    s    
r  )WeakSetc                 C   sx  t |tstd|f z| jd  W nX tyH   t | _t | _Y n8 ty~   ddl	}|
 \}} }td}t| Y n0 || jv rdS || jv rdS | |u r| j| dS | t|dd	v r| j| dS | tu rt|tr| j| dS | tu rt|tr| j| dS | tu rBt|trB| j| dS | tu rht|trh| j| dS | j| dS )
z9
        Override for issubclass(subclass, cls).
        z+issubclass() arg 1 must be a class (got %r)_subclass_cache_r   Npossible 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-aroundTFr0  r6   )rD   rl   rG   rB   r   rT  rU  Z_subclass_negative_cache_RecursionErrorsysr  raise_from_noner  rh   StdlibIntFlagrA   r%   r  r$   StdlibIntEnumr"   r  r!   )r   subclassrX  r7  tbr6   r6   r9   __subclasscheck__  sH    


r^  c                 C   sP   |j }z| |W S  tyJ   dd l}| \}} }td}t| Y n0 d S )Nr   rV  )r   r^  rW  rX  r  rY  )r   r   r\  rX  r7  r]  r6   r6   r9   __instancecheck__  s    r_  c                   C   s   t rtt_tt_d S r<   )r  r^  StdlibEnumMetar_  r6   r6   r6   r9   r0     s    r0   c                   C   s   t rt`t`dS )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)r  r`  r_  r^  r6   r6   r6   r9   r1     s    
r1   c                   @   s   e Zd Zdd Zdd ZdS )r3   c                 G   sZ   |j | _ |j| _g | _|j}|s2dd | D }|D ]}|| | j|< | j| q6d S )Nc                 S   s"   g | ]\}}t |ttfr|qS r6   )rD   r   r!   r   r6   r6   r9   r     r   z'cls2module.__init__.<locals>.<listcomp>)ry   r   _parent_module__all__rB   rC   rx   )ri   r   r   Zall_objectsrw   r6   r6   r9   rk     s    zcls2module.__init__c                 C   s   | t jd| j| jf < d S r  )r  r  ra  ry   r   r6   r6   r9   register  s    zcls2module.registerN)ry   r   r   rk   rc  r6   r6   r6   r9   r3     s   
r3   )N)N)N)NNNF)F)
__future__r   r  Z	_constantr   _tupler   collectionsr   rX  r  rb  r
   rY   r*   ImportErrorremoverW  	NameErrorr  r:   rE   r   r!  r   r`  r!   r  r"   r[  r  rZ  ZStdlibStrEnumZStdlibReprEnumr%   r$   r#   r(   r   r   r   r   r   r2   r   r	   rR   r5   typesr`   r<  r"  r   Z_RouteClassAttributeToGetattrr   rl   r   r   r   r   r   r   r   globalsr   r.   r/   r  r   r   r  r  r   r    r   r   Z	_Addendumr  r  r>  r  rk   r  rx  r   ri  rl  rm  rn  r~   r  PY3r  r  r   r  r  r  r  r  r   r   rw   rP   r  Z
_enum_baseresolver&  r4   r'  r  Z_repr_basesr  r   r&   r'   r-  rx   r   r   r   r   r   r)   r   r4  r   r8  r   r+   Z_flag_basesZ	flag_dictr,   rs  rp  rq  rg  rh  r  r  r  r  r  r  r   r   r   r   r   rP  rR  rS  r  _weakrefsetrT  r^  r_  r0   r1   r3   r6   r6   r6   r9   <module>   s  


&
'	

i
$- ) i l  3      n

(












	


 -



	m






	
	
	
	

.