Viewing File: /opt/hc_python/lib/python3.12/site-packages/aenum/__pycache__/_enum.cpython-312.pyc

�

^��gC����ddlmZddl�ddlmZddlmZddlmZddl	Z
gd�ZeZ
	ddlZ	e	edZ	ddlZeed�red
��ddlmZmZmZdxZxZxZ Z!eefZ	er*	ddlm"Zm#Zeeefz
Z	ddlm$Z ee fz
Z	ddlm%Z!ee!fz
ZdxZ&xZ'xZ(xZ)Z*d�d�Z+d�Z,d�Z-d�Z.d�d�Zd�Z/	ddl0m1Z1e1Z2Gd�de2�Z4e4Z5e1�e4Z1e4Z6Gd�de7�Z8e8de3fi�Z9d�Z:d�Z;d �Z,d!�Z<d"�Z-d#�Z=d$�Z>e+e?��Gd%�d&e��Z@dxZxZ%xZxZ$xZ#xZ"xZAZBGd'�d(e3�Ze8d)e3fi�ZCGd*�d+e�ZDdd,lEmZe4e_4eDe_D[Gd-�d.e�ZFGd/�d0�ZGGd1�d2eH�ZIe8d3e7fi�ZJGd4�d5e7�ZKerGd6�d5eKe�ZKeKZeLeKj�d7e3f�d8e?��9�ZNeNeOd:���ZPeNd;��ZQeNd<��ZReNeOd=���ZSeNeTd>���ZUeNeOd?���ZVeNeOd@���ZWeNeOdA���ZXeNdB��ZYeNdC��ZZe[reNdD��Z\eNdE��Z]eNdF��Z^eNdG��Z_eNdH��Z`eNdI��ZaeNdJ��ZbeNdK��ZceNdL��ZdeNdM��ZeeNe4dN���ZfeNe4dO���ZgeNe4dP���Zhexse3ZieKd7eifeNj���Z[NdQ�ZkekZldR�ZmdS�Zne!ree!fZonefZoeKdTeodUdVi�Z%GdW�dXepe%�ZGdY�dZeqe%�Z$Gd[�d\e$�ZrGd]�d^e$�Zse[rGd_�d`e�Ztej�d`�Gda�dbe�ZvGdc�dde�ZwGde�dfe�ZxGdg�dhe�ZyGdi�dje�ZzerGdk�d	e�Z{Gdl�dme�Z|d�dn�Z}do�Z~d�dp�Zdq�Z�	ddrlm�Z�e+e�e?��ereefZ�nefZ�eLeKj�due��dve?��9�Z�e�e�dw<e�e�dx<e�dy��ZUe�eOdz���Z�e�e�d{<e�eOd|���Z�e�eOd}���ZVe�eOd~���Z�e�eOd���Z�e�d���Z�e�d���Z�e�d���Z�e�d���ZYe�d���ZZe�r	e�d���Z�ne�d���Z�e�d���Z�e�d���Z�e�d���Z�e�d���Z�e�e�d�<e�e�d�<e�e�d�<eKdue�e�j���Z#[�Gd��d�epe%e#�Z"d��Z�d��Z�d��Z�d��Z�d�d��Z�erdd�l�m�Z�d��Z�d��Z�d��Z�d��Z�Gd��d�e3�Z�y#e$rdZej!d	�Y���wxYw#e$reZY���wxYw#e$rd
�ZY���wxYw#e$rdxZxZxZxZxZxZ xZ Z!Y���wxYw#e$rY���wxYw#e$rY���wxYw#e$rY���wxYw#e$re3Z2dZ1Y���wxYw#e$rGds�dte$�Z�Y���wxYw)��)�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��|D]}|s�yy)NTF�)�iterable�elements  �:/opt/hc_python/lib/python3.12/site-packages/aenum/_enum.py�anyr<'s���G��� ��r8�versionz
wrong version)r r"r#)r&r%)r$)r)c�l����	|��fd�}|St|t�r:|jj�D]\}}t	|t�s�|�|<�|St|t
�str;t|t�r+|jj�}|D]
\}}|�|<�|St|�d���)z�
    export([collection,] namespace) -> Export members to target namespace.

    If collection is not given, act as a decorator.
    c���t|��S�N)r3)�
collection�	namespaces �r;�export_decoratorz export.<locals>.export_decoratorVs����*�i�0�0r=z is not a supported collection)	�
issubclassr�__dict__�items�
isinstancer"�stdlib_enums�__members__�	TypeError)rBrCrD�n�c�data�ms `     r;r3r3Ns�������	�	1���	�J�
�	.��'�'�-�-�/�D�A�q��!�]�+� �	�!��0���

�J��	%��*�Z�Q]�:^��%�%�+�+�-���D�A�q��I�a�L�����j�J�L�Lr=c�.�d}|r||dz
z}|dz
}|r�|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)
    rrr8��num�counts  r;r	r	es/��B
�E�

��s�Q�w���
��
����Lr=c�(�|dk(ry||dz
z}|dk(S)z>
    True if only one bit set in value (should be an int)
    rFrr8��values r;r
r
�s&��
��z��	�U�Q�Y��E��A�:�r=c#�<K�|r||dzz}|��||z}|r�yy�w)zZ
    Return each bit value one at a time.

    >>> list(_iter_bits_lsb(6))
    [2, 4]
    rNr8)rV�bits  r;�_iter_bits_lsbrY�s.�������v��z�"���	�
�����s��c��d|j�z}|dk\r t||z�jddd�}nt||dz
|zz�}|dd}|dd}|sd}|�t|�|kr|d|z|z|d}|�d	|��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�0rN����� )�
bit_length�
_bltin_bin�replace�len)rV�max_bits�ceiling�s�sign�digitss      r;rr�s����E�%�%�'�'�G���z��u�w��'�/�/��S�!�<����v��1��� 7�7�8���R�a�5�D�
�q�r�U�F�������v�;��!��2�h��)�F�2�X�I�J�?�F��F�#�#r=c�*�tt|��SrA)�listrYrUs r;r6r6�s����u�%�&�&r=)�DynamicClassAttributec�J�eZdZdZdd�Zd�Zd�Zd�Zd�Zd
d�Z	d	�Z
d
�Zd�Zy)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��||_||_||_|xs|j|_|du|_tt
|dd��|_y)N�__isabstractmethod__F)�fget�fset�fdel�__doc__�
overwrite_doc�bool�getattrro)�selfrprqrr�docs     r;�__init__zproperty.__init__�sJ����	���	���	��*�d�l�l��� �D�[���$(���7M�u�)U�$V��!r=c���|jr|jnd}t|�||j|j|xs|j�}|jdu|_|SrA)rtrs�typerqrr)rwrp�fdoc�results    r;�getterzproperty.getter�sR��#�1�1�t�|�|�t����d��D�$�)�)�T�Y�Y��8L����M��#�|�|�t�3����
r=c���|jrtjnd}t|�|j||j|j�}|jdu|_|SrA)rtrprsr{rr)rwrqr|r}s    r;�setterzproperty.setter�sM��#�1�1�t�|�|�t����d��D�I�I�t�T�Y�Y����E��#�|�|�t�3����
r=c���|jrtjnd}t|�|j|j||j�}|jdu|_|SrA)rtrprsr{rq)rwrrr|r}s    r;�deleterzproperty.deleter�sM��#�1�1�t�|�|�t����d��D�I�I�t�y�y�$����E��#�|�|�t�3����
r=c�H�|jjj|j�}|jxs|j
xs|j}g}|r|jd|z�|r|jd|jz�ddj|�zS)Nz%rzfunction=%szproperty(%s)�, )
�
ownerclass�_member_map_�get�namerprqrr�append�__name__�join)rw�member�func�stringss    r;�__repr__zproperty.__repr__�s�����-�-�1�1�$�)�)�<���y�y�2�D�I�I�2���������N�N�4�&�=�)���N�N�=�4�=�=�8�9���	�	�'� 2�2�2r=c��|�	|j|jS|j�|j	|�S|j
�td|j�d|����	|j|jS#t$rt|�d|j����wxYw#t$rt|�d|j����wxYw)Nz has no attribute zcannot read attribute z on z member has no attribute )r�r��KeyError�AttributeErrorrprqrF)rw�instancer�s   r;�__get__zproperty.__get__�s�����
�!�.�.�t�y�y�9�9��y�y�$��y�y��*�*��9�9�(�(�@D�	�	�:�V���"�'�0�0����;�;���
�$�4>��	�	�J���
��$�"�,�CM�t�y�y� Y�"�"�"�s�A;�"B"�;$B�"$Cc���|j�L|j�&td|j�d|j�d���||j
|j<y|j||�S)Nzcannot set attribute � on <aenum �>)rqrpr�r��clsnamerF)rwr�rVs   r;�__set__zproperty.__set__sZ���9�9���y�y�$�$�CG�9�9�d�l�l�[���05��!�!�$�)�)�,��9�9�X�u�-�-r=c�d�|j��|js|jr&td|j�d|j
�d���|j|jvr|j|j=ytd|j�d|j
�d���|j|�S)Nzcannot delete attribute r�r�z
no attribute z> member)rrrprqr�r�r�rF)rwr�s  r;�
__delete__zproperty.__delete__s����9�9���y�y�D�I�I�$�FJ�i�i�QU�Q]�Q]�^������h�/�/�/��%�%�d�i�i�0�$�BF�)�)�T�\�\�Z����9�9�X�&�&r=c�B�||_|j|_||_yrA)r�r�r�r�)rwr�r�s   r;�__set_name__zproperty.__set_name__+s����	�!�*�*���$��r=)NNNNrA)
r��
__module__�__qualname__rsryr~r�r�r�r�r�r�r�r8r=r;rr�s5���W����3�"�0	.�
'�%r=rc��eZdZd�Zy)�SentinelTypec� �d|jzS)Nz<%s>�r���clss r;r�zSentinelType.__repr__9s������$�$r=N)r�r�r�r�r8r=r;r�r�8s��%r=r��Sentinelc�0�|dkry|dt|�zk(S)NrFr[)�	_high_bitrUs r;�
_power_of_twor�=s!���q�y���A��5�)�)�)�)r=c	���|dvrt|�Sd}|dkrd}|}t|dz	�t|dz�z}|r(ddj|D�cgc]
}d|dk(��c}�z}|Scc}w)	N)rrFrTrr\��10)�strr
r�)rR�negativer}�ds    r;r
r
Bs{��
�f�}��3�x���H�
�Q�w����d��
�#�q�&�\�C��A��J�
&�F���r�w�w�f�=�f���Q��V��f�=�>�>���M�� >s�A%
c�.�d}|r||dz
z}|dz
}|r�|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.
    rrr8rQs  r;r	r	Os.��<
�E�

��s�Q�w���
��
����Mr=c�(�d}|r
|dz
}|dz}|r�
|S)Nrrr8)rR�lengths  r;�bit_lenr�ss(��
�F�

��!�����	����Mr=c�&�|dk7xr||dz
zdk(S)z<
    True if only one bit set in num (should be an int)
    rrr8)rRs r;r
r
zs ��
�1�H�0�3�#��'�?�q�0�0r=c��t|t�r|jt�}t	|d|�}t|�\}}}}|duxr|duS)z6check if new generate method supports *args and **kwds�im_funcN)rH�staticmethodr�r{rv�
getargspec)�method�args�varargs�keywords�defaultss     r;�_check_auto_argsr��sP���&�,�'�����%��
�V�Y��
/�F�(2�6�(:�%�D�'�8�X��$��7�8�4�#7�7r=c�`��|s|St|d��t�t�s-t�fd�|ddD��st	d��t|�St|dd��	t�fd�|ddD��rt|d���St	d	��#t$rt|d
���cYSwxYw)zC
    sorts things by value if all same type; otherwise by name
    rc3�8�K�|]}t|��u���y�wrA�r{��.0�v�	sort_types  �r;�	<genexpr>zenumsort.<locals>.<genexpr>�s�����>�:�a�D��G�y�(�:�s�rNz$cannot sort items of different typesc3�>�K�|]}t|d��u���y�w)rNr�r�s  �r;r�zenumsort.<locals>.<genexpr>�s�����A�j��D��1��J�)�+�j�s�c��|dS�Nrr8��is r;�<lambda>zenumsort.<locals>.<lambda>�s��A�a�Dr=��keyztry name sort insteadc��|dS�Nrr8r�s r;r�zenumsort.<locals>.<lambda>�s���!�r=)r{rE�tuple�allrK�sorted)�thingsr�s @r;�enumsortr��s������
��V�A�Y��I��i��'��>�6�!�"�:�>�>��B�C�C��f�~������1��&�	�	6��A�f�Q�R�j�A�A��f�.�9�9�� 7�8�8���	6��&�n�5�5�	6�s�#$B�B�B-�,B-c�l�eZdZedd�Zedd�Zedd�Zedd�Zed	d
�Zd�Z	y)
�
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 aliasedrz(duplicate valued members are not allowedc��|jSrA��_name_�rws r;r�zEnumConstants.__repr__�s���{�{�r=N)
r�r�r��constantrrrrrr�r8r=r;r�r��sH���
�$a�b�H��,�(a�b�J��,�(M�N�J��y�"V�W�G�
�h� J�
K�F�r=r�c�N�eZdZdZd�Zed��Zed��Zd�Zd�Z	d�Z
d�Zy	)
rz+
    Helper class to track args, kwds.
    c�|�||_t|j��|_t	|�|_d|_yrA)�_args�dictrG�_kwds�hash�_hashr�)rwr��kwdss   r;ryz
enum.__init__�s-����
��$�*�*�,�'��
��$�Z��
���	r=c��|jSrA)r�r�s r;r�z	enum.args�s���z�z�r=c�6�|jj�SrA)r��copyr�s r;r�z	enum.kwds�s���z�z��� � r=c��|jSrA)r�r�s r;�__hash__z
enum.__hash__�s���z�z�r=c��t||j�stS|j|jk(xr|j|jk(SrA�rH�	__class__�NotImplementedr�r��rw�others  r;�__eq__zenum.__eq__�s;���%����0�!�!��y�y�E�J�J�&�B�4�9�9��
�
�+B�Br=c��t||j�stS|j|jk7xs|j|jk7SrAr�r�s  r;�__ne__zenum.__ne__�s;���%����0�!�!��y�y�E�J�J�&�A�$�)�)�u�z�z�*A�Ar=c	��g}dj|jD�cgc]}|���c}�}|r|j|�djtt	|j
j
���D��cgc]\}}|�d|����c}}�}|r|j|�|jj�ddj|��d�Scc}wcc}}w)Nr��=�(�))	r�r�r�r�rkr�rGr�r�)rw�final�ar��kr�r�s       r;r�z
enum.__repr__�s������y�y��	�	�:�	�1�!�,�	�:�;����L�L����y�y��$�t�y�y���GX�BY�9Z�[�9Z���A�q�!�,�9Z�[�\����L�L����>�>�2�2�D�I�I�e�4D�E�E��
;��\s�
C�:C
N)r�r�r�rsry�bltin_propertyr�r�r�r�r�r�r8r=r;rr�sK���������!��!��C�
B�
Fr=r�no_valuec��eZdZdZeZeZgZd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd	�Zd
�Zd�Zd�Zd
�Zerd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%d�Z&d �Z'e(d!��Z)e)jTd"��Z)d%d$�Z+y#)&rzP
    Instances are replaced with an appropriate value in Enum class suites.
    c��|j�}|jdd|_|jjt||ff�|SrA�r��_operationsr��_and_�rwr��new_autos   r;�__and__zauto.__and__��C���>�>�#��#�/�/��2������#�#�U�T�5�M�$:�;��r=c��|j�}|jdd|_|jjt||ff�|SrArrs   r;�__rand__z
auto.__rand__�C���>�>�#��#�/�/��2������#�#�U�U�D�M�$:�;��r=c��|j�}|jdd|_|jjt|ff�|SrA)r�rr��_inv_�rwrs  r;�
__invert__zauto.__invert__sA���>�>�#��#�/�/��2������#�#�U�T�G�$4�5��r=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_or_rs   r;�__or__zauto.__or__sC���>�>�#��#�/�/��2������#�#�T�D�%�=�$9�:��r=c��|j�}|jdd|_|jjt||ff�|SrArrs   r;�__ror__zauto.__ror__sC���>�>�#��#�/�/��2������#�#�T�E�4�=�$9�:��r=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_xor_rs   r;�__xor__zauto.__xor__rr=c��|j�}|jdd|_|jjt||ff�|SrArrs   r;�__rxor__z
auto.__rxor__rr=c��|j�}|jdd|_|jjt|ff�|SrA)r�rr��_abs_rs  r;�__abs__zauto.__abs__$�A���>�>�#��#�/�/��2������#�#�U�T�H�$5�6��r=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_add_rs   r;�__add__zauto.__add__*rr=c��|j�}|jdd|_|jjt||ff�|SrAr!rs   r;�__radd__z
auto.__radd__0rr=c��|j�}|jdd|_|jjt|ff�|SrA)r�rr��_neg_rs  r;�__neg__zauto.__neg__6rr=c��|j�}|jdd|_|jjt|ff�|SrA)r�rr��_pos_rs  r;�__pos__zauto.__pos__<rr=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_div_rs   r;�__div__zauto.__div__CsC���~�~�'�H�#'�#3�#3�A�#6�H� �� � �'�'���u�
�(>�?��Or=c��|j�}|jdd|_|jjt||ff�|SrAr-rs   r;�__rdiv__z
auto.__rdiv__Irr=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��
_floordiv_rs   r;�__floordiv__zauto.__floordiv__OsC���>�>�#��#�/�/��2������#�#�Z�$���$?�@��r=c��|j�}|jdd|_|jjt||ff�|SrAr3rs   r;�
__rfloordiv__zauto.__rfloordiv__UsC���>�>�#��#�/�/��2������#�#�Z�%���$?�@��r=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��	_truediv_rs   r;�__truediv__zauto.__truediv__[sC���>�>�#��#�/�/��2������#�#�Y��u�
�$>�?��r=c��|j�}|jdd|_|jjt||ff�|SrAr9rs   r;�__rtruediv__zauto.__rtruediv__asC���>�>�#��#�/�/��2������#�#�Y���
�$>�?��r=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_lshift_rs   r;�
__lshift__zauto.__lshift__g�C���>�>�#��#�/�/��2������#�#�X��e�}�$=�>��r=c��|j�}|jdd|_|jjt||ff�|SrAr?rs   r;�__rlshift__zauto.__rlshift__m�C���>�>�#��#�/�/��2������#�#�X��t�}�$=�>��r=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_rshift_rs   r;�
__rshift__zauto.__rshift__srBr=c��|j�}|jdd|_|jjt||ff�|SrArGrs   r;�__rrshift__zauto.__rrshift__yrEr=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_mod_rs   r;�__mod__zauto.__mod__rr=c��|j�}|jdd|_|jjt||ff�|SrArMrs   r;�__rmod__z
auto.__rmod__�rr=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_mul_rs   r;�__mul__zauto.__mul__�rr=c��|j�}|jdd|_|jjt||ff�|SrArSrs   r;�__rmul__z
auto.__rmul__�rr=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_pow_rs   r;�__pow__zauto.__pow__�rr=c��|j�}|jdd|_|jjt||ff�|SrArYrs   r;�__rpow__z
auto.__rpow__�rr=c��|j�}|jdd|_|jjt||ff�|SrA�r�rr��_sub_rs   r;�__sub__zauto.__sub__�rr=c��|j�}|jdd|_|jjt||ff�|SrAr_rs   r;�__rsub__z
auto.__rsub__�rr=c�p�|jryd|j�d|j�d|j�d�S)Nz	auto(...)zauto(z, *z, **r�)r�_valuer�r�r�s r;r�z
auto.__repr__�s.�������-1�K�K����T�Z�Z�P�Pr=c��|jtur|jrtd��|jtur|js|jS|jtur|jS|j	�S)Nzauto() object out of sync)re�
_auto_nullrrK�_resolver�s r;rVz
auto.value�sb���;�;�j�(�T�-=�-=��7�8�8�
�[�[�J�
&�t�/?�/?��;�;��
�[�[�
�
*��;�;���=�=�?�"r=c�L�|jr|j|�}||_yrA)rrhre�rwrVs  r;rVz
auto.value�s ������M�M�%�(�E���r=Nc�`�|j}|jD]|\}}g}|D]k}t||�rL|jtur|�
tccS|j|��?|j|j��[|j|��m||�}�~g|jdd|_|SrA)r�rrHrVrgr�re)rw�
base_valuer��op�params�values�paramrVs        r;rhz
auto._resolve�s����.�.�C�"�.�.�
��F���#�E�!�%��-� �;�;�*�4�)�1�'1� 1� &�
�
�j� 9�"�M�M�%�+�+�6��
�
�e�,�$��F���/�#%�D���Q���D�K��Lr=rA),r�r�r�rsrg�enum_memberrerrr
rrrrrrr#r%r(r+�PY2r/r1r5r7r;r=rArDrIrKrOrQrUrWr[r]rarcr�r�rVr�rhr8r=r;rr�s�����K�
�F��K��������������	������������������Q��#��#��\�\����
r=r)�_commonc�&�eZdZdZdZdZdZdZd�Zy)�_EnumArgSpec)rz all args except *args and **kwds)rzthe name of the *args variable)r[zthe name of the **kwds variable)r^zany default values)�z0number of required values (no default available)c��t|�}|\}}}}|r|dt|�}n|dd}tjt|||||f�Sr�)r�rdr��__new__ru)r��	_new_func�argspecr�r�r�r��reqss        r;rxz_EnumArgSpec.__new__�sV���Y�'��,3�)��g�x�����3�x�=�.�)�D����8�D��}�}�\�D�'�8�X�t�+T�U�Ur=N)	r�r�r�r�r�r�r��requiredrxr8r=r;ruru�s!��0�D�1�G�3�H�&�H�D�H�Vr=ruc��eZdZdZd�Zd�Zy)�
_proto_memberzW
    intermediate step for enum members between class execution and final creation
    c��||_yrArUrjs  r;ryz_proto_member.__init__�s	����
r=c	���t||�|j�i}d}d}d}d}t�t�r�rt�dt�r�}�d�t�t�r+�jt
ur�j}�j}n�t�t�r3�j}�jf�jz}�j�n_t�t�r�j}�j}n6t�t�r�j��f}nt�t�s�f}n�}|��f|ddz�i}�}~|jsd|jvr�|jr+|d}|dd}d|jvr|dd}n|}|dd}|d�n�|jr\|jrP|t|j�dzd}|js"|dt|jj�}|d�n3|jr|dd}|dd}|d�n|jr|d�n|}n|}|j tur|f}|j"s|j%|�}	n|j$|g|��i|��}	t'|	d�s2|j t(ur�|	_n	|j |i|��|	_|	j*�||	_||	_|	j6|i|��t|j8�|	_t<�jt?|t<�rZ|xj@�zc_ tC��r|xjD�zc_"d|j@jG�zdz
|_$|jJr|j8jM|�n�tOtP�}		|jR�}	|jTr||	jVjM|�|r{g}|j]�D]=\}}d	j_|�}|jM|�d
|�d||j�d���?ta|jb�d
dj_|�����t|jt�r|	|j_2d}d}d}|jfddD]\}|jhjk|�}|��!t|tltnf�r|}|}d}n tq|�r|}|xsd}|xs|}�Yd}|}�^|r�tm�}|	|_9|ju||�|dvrltw|dd�|_<tw|dd�|_=tw|dd�|_>tw|dd�|_?tw|dd�|_@tw|dd�|_A||_B||_Ct�|||�n
t�|||	�|	|j�|<�f|z}|jr
|vr||fz
}||	_F|D]o�|jr:�|jRvst��fd�|jXD��rta��d���	|jJrt/d��|	|jR�<�qy#t,$r}
t/d�}|
|_|�d}
~
wwxYw#t.$r]|jXD]D\}
}|jV}|
|	j*k(s�"|jTr||jM|�|}	ntZ�Y��wxYw#tZ$rrt<�t?|t<�s|j8jM|�n<t<�6t?|t<�r&tC��r|j8jM|�Y���wxYw#t.$r|xjX�|	ffz
c_,Y���wxYw)zR
        convert each quasi-member into an instance of the new enum class
        r8NrrrV�_value_z/_value_ not set in __new__, unable to create itr[�,z --> z [�]z: duplicate names found: z;  r�desc�attr)rr�rpr�rqr�rrr�c3�.�K�|]\}}|�k(���y�wrAr8)r�r�rOrVs   �r;r�z-_proto_member.__set_name__.<locals>.<genexpr>�s�����R�4Q�&�1�a�1��:�4Q�s�z has already been usedzcannot use dict to store value)H�delattrrVrHr�rrgr�r�r�Member�_multivalue_�_creating_init_�_auto_init_�
_new_args_rd�_auto_args_�
_member_type_�
_use_args_�_new_member_�hasattr�objectr��	ExceptionrK�	__cause__r��__objclass__ry�_member_names_�_sort_order_r%rE�_flag_mask_r
�_singles_mask_ra�
_all_bits_�	_noalias_r�rrk�_value2member_map_�_unique_r��_value2member_seq_r�rGr��
ValueErrorr�rq�__mro__rFr�rrl�
is_descriptorr�r�rvrp�_getrq�_setrr�_del�
_attr_type�	_cls_type�setattrr��_values_r<)rw�
enum_class�member_namer�r��	init_args�
extra_mv_argsr��mv_argrq�exc�te�	nonunique�unhashable_value�canonical_memberr��message�aliases�bad_aliases�found_descriptor�descriptor_type�
class_type�baser��redirectrorVs                          @r;r�z_proto_member.__set_name__�s����
	�
�K�(��
�
�������	��
��
��e�U�#��*�U�1�X�t�2L��J��!�H�E��e�T�"�u�{�{�j�'@��:�:�D��:�:�D�
��t�
$��:�:�D��K�K�?�U�Z�Z�/�D��K�K�E�
��t�
$��:�:�D��:�:�D�
��v�
&��K�K�E��9�D��E�5�)��9�D��D��!��I�
�1�2��.�E��D��D���"�"�g��1K�1K�&K��&�&��a��� $�Q�R��
��j�8�8�8� $�Q�R��I� $�I��A�a�y���Q����)�)�j�.C�.C�!%�c�*�*D�*D�&E�%E�a�%G�%H� I�I�%�1�1�#�$D�S��)>�)>�)C�)C�%D�E�� ��G�E��+�+� $�Q�R��I���!�9�D� ��G�E��*�*� ��G�E�!%�I��I��#�#�u�,��8�D��$�$�$�1�1�*�=�K�1�*�1�1�*�L�t�L�t�L�K��{�I�.��'�'�6�1�&+��#��*B�*�*B�*B�D�*Q�D�*Q�K�'�
�#�#��(���#-�� �����i�0�4�0�#&�z�'@�'@�#A�� ���
�:�t� <��"�"�e�+�"��U�#��)�)�U�2�)�$%�:�+A�+A�*M�*M�*O�$P�ST�$T�J�!�����%�%�,�,�[�9�#�D�)�I� 
B�'�",�"?�"?��"F�K�!�*�*�!�+�"2�"2�3�:�:�;�G�8���%.�_�_�%6�M�D�'�"%�(�(�7�"3�K��N�N�t�[�*�UY�JZ�J`�J`�#a�b�&7�!�'�0�0�%�*�*�W�2E�G���
�d�j�j�$�'�%0�D�J�J�"������
��&�&�q�r�*�D��=�=�$�$�[�1�D����d�X�/D�$E�F�'+�$�!%�J�&,�O��"�4�(�'+�$�&5�&?��O�!+�!3�t�J��&,�O�!%�J�+� ��z�H�)�H�O��!�!�*�k�:��/�1� '�(8�&�$� G��
� '�(8�)�T� J��
� '�(8�&�$� G��
� '�(8�)�T� J��
� '�(8�&�$� G��
� '�(8�,�� M��
�"1�H��!+�H���J��X�6��J��[�9�/:�
����,���]�*���"�"�v�V�';��v�j� �F�%����E��&�&��Z�:�:�:��R�J�4Q�4Q�R�R� �u�!G�H�H�
J��'�'�#�$D�E�E�7B�
�-�-�e�4���e!��"�#T�U�B�#&�B�L��H����:!�
'�>H�>[�>[�:�(�*:�/�4�4��+�{�/B�/B�B�)�2�2� )�$�� 6� 6�{� C�*:�K�!�
?\�'��"�
'���
B���)�*�d�;��-�-�4�4�[�A��(�&�z�4�8�)�%�0��-�-�4�4�[�A��
B��p�
J��-�-�5�+�2F�1I�I�-�-�
J�s[�Y�9Y>�0&]%�	Y;�"Y6�6Y;�>6[$�5+[$� ['�#[$�$['�'A7]"�!]"�%!^
�	^
N)r�r�r�rsryr�r8r=r;r~r~�s����aJr=r~c�B��eZdZdZ�fd�Z�fd�Z�fd�Zd�Zd�Z�xZ	S)r!z�Track 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�d��tt|��||_||_||_||_d|_g|_t�|_
||_t|vx|_
}t|v|_t |v|_|jr|jrt%d|z��|j"r|jrt%d|z��||_||_d|_d|_t|v|_g|_g|_|jr	gd�|_d|_d|_g|_d|_y)Nz2%r: AddValue and MagicValue are mutually exclusivez4%r: MultiValue and MagicValue are mutually exclusiver8F)rr��classmethodT)�superr!ry�	_cls_name�_constructor_init�_constructor_start�_constructor_boundary�_generate_next_value�
_member_names�set�_member_names_set�	_settingsr�	_addvaluer�_magicvaluer�_multivaluerK�_start�_addvalue_value�	_new_args�
_auto_args�_locked�_init�_ignore�_ignore_init_done�_allow_init�_last_values�_auto_called)	rw�cls_name�settings�start�constructor_init�constructor_start�constructor_boundaryr�r�s	        �r;ryzEnumDict.__init__�s&���
�h��&�(�!���!1���"3���%9��"�$(��!����!$����!���$,��$8�8����%��1���%��1����>�>�d�.�.��P�S[�[�\�\����� 0� 0��R�U]�]�^�^����$���������!��1�����
�������F�D�L�!&���������!��r=c���||jk(r|j|vrtS|js(||vs$||jvst	|�st|�rtt|�#|�S|jrR|j||jt|j�|jdd�}|j||�|St!d��)Nz"Magic is not set -- why am I here?)r�rr�r��	is_sunder�	is_dunderr�r!�__getitem__r�r�r�rdr�r��__setitem__r�)rwr�rVr�s   �r;r�zEnumDict.__getitem__s�����$�.�.� �T�^�^�4�%?��K�����$�;��$�,�,�&��S�>��S�>���4�4�S�9�9�
�
�
��-�-�c�4�;�;��D�DV�DV�@W�Y]�Yj�Yj�kl�Ym�n�E����S�%�(��L��@�A�Ar=c
�>��d}t|j|�r�nst|j|�r�n[t|��r?|dvrt	|j�d|�d���|j
s|dvrt	|j�d|�d���|dk(r�|jrtd	|jz��t|t�r|j�}nt|�}||_t|�|jz}|r0t	|j�d
djd�|D������d|_�nV|d
k(r%|j �rDtd|jz��|dk(r-|j"rtd|jz��||_�n�|dk(�r�t|tt&f�s|f}t|t�st|�}|xj(|zc_t*|vr t,|vrtd|jz��t.|vr t*|vrtd|jz��t0j3gd��}|j(D])}||vrt|j�d|�d|�d���d||<�+|d|_|d|_|d|_|j8|_|j8r|js	gd�|_|j6r6|j<r*d|j<vr|j<j?dd�t'|j(�}�nb|dk(r�|j@rtd|jz��|}t|t�r |jCd d!�j�}|j6r*d|j<vr|j<j?dd�|j8rtd"|jz��||_|}�n�|d#k(�r�|jDrtd$��|}|�bt|tF�r
|jH}n5t|tJ�rtd&|jz��|}tG|�}tM|�|_'tQ|d'|��ntS|�r�|d(k(r)d)}|j
smt	|j�d|�d���|d*k(r-t|tF�r|jH}tU|�|_+n |d+k(rt|tJ�stK|�}tY|��ryd|_�np||jvrt|j�d,|����||jvr�n8tY|��sd-|_||vr t|j�d.|�d/||����t[|�t\ur,||_/|j6�rtd0|jz��|j6r |j4s|ja||�}�n�|j4rdt[|�t&ur|f}t|dtb�r|je||d�f|d1d%z}|j6�rl|ja||�}�nXt|tb�r|je||�}�n4t[|�t&ur�tgd2�|D��rqg}	|D]^}
t|
tb�r;d-}|je||
�}
|
jh}
|jjjm|
�|	jm|
��`t'|	�}n�t|tb�s�|jVxr|jVjn}tq|j<xs|�}t|t&�rtq|�}
nd1}
tq|j<�d1kDxs|}|
|kr|ja||�}n	|j<rt|tb�r
|jr}nt|t&�s|f}n|}tq|j<�tq|�k7r+t|j�d3|�d4|j<�d5|�d6���|jtjm|�|jjw|�nd|_d-|_t|�s�tS|�s�t|j|�s�tY|�s�|sd}n�t|tb�r&|jjjm|jh�n�t[|�t&ur]|rvt|dtb�r)|jjjm|djh�n:|jjjm|d�n|jjjm|�txtz|��||�y%)7z�Changes 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: _sunder_ names, such as z", are reserved for future Enum use)�create_pseudo_member_r�r�r�z
: cannot set z after init phaser�z%%r: ignore can only be specified oncez,: _ignore_ cannot specify already set names r�c3�2K�|]}t|����y�wrA)�repr)r�r�s  r;r�z'EnumDict.__setitem__.<locals>.<genexpr>Cs����%?�w�!�d�1�g�w���r�z4%r: boundary specified in constructor and class bodyr�z1%r: start specified in constructor and class bodyr��-%r: NoAlias and Unique are mutually exclusivez*cannot specify both MultiValue and NoAlias�r�r�r�rr��: unknown qualifier z (from r�r�r�r�)rr�r�rVrr�z3%r: init specified in constructor and in class bodyr�r`z0%r: _init_ and MagicValue are mutually exclusiver�z4_generate_next_value_ must be defined before membersNzB%r: _generate_next_value must be a staticmethod, not a classmethodr��	__order__r�rx�__init_subclass__z: attempt to reuse name: F�: z already defined as z(%r: enum() and AddValue are incompatiblerc3�<K�|]}t|t����y�wrA)rHr)r�r�s  r;r�z'EnumDict.__setitem__.<locals>.<genexpr>�s����-Q�5�a�j��D�.A�5����.z/: number of fields provided do not match init [z != r�)?�is_internal_classr��is_private_namer�r�r�r�rKrH�
basestring�splitrkr�r�r�r�r�r�r�r�r�rrrr��fromkeysr�r�r�r�r��insertr�rcr�r��__func__r�r�r�r�r�rur�r�r{rr��_gnvr�
_convert_autor<rVr�r�r|rdr�r��addr�r!r�)rwr�rV�
auto_store�already�allowed_settings�argr��gnv�auto_valuedr��new_args�
target_len�
source_len�
multi_args�
test_valuer�s                �r;r�zEnumDict.__setitem__s-����
��T�^�^�U�3��
�T�^�^�S�
1��
�s�^����!��>�>�3�"0����%�%�#�6�+�!����Y\�!]�^�^��
�"��)�)�#�$K�d�n�n�$\�]�]��e�Z�0�!�K�K�M�E� ��K�E�$����e�*�t�'=�'=�=���$� �N�N� �I�I�%?�w�%?�?�&���*.��&���$��-�-�#�$Z�]a�]k�]k�$k�l�l��	�!��*�*�#�$W�Z^�Zh�Zh�$h�i�i�#�����$�!�%�#�u��6�"�I�E�!�%��-���J�E����%�'���e�#��%��#�$S�VZ�Vd�Vd�$d�e�e��5�(�W��-=�#�$P�SW�Sa�Sa�$a�b�b�#'�=�=�1n�#o� ��>�>�C��"2�2�'�PT�P^�P^�`c�ej�(k�l�l�,0�$�S�)�*�$4�L�#A�� �!1�*�!=���#3�L�#A�� �#'�#3�#3�3����#�#�D�,B�,B�#N�D�L��>�>�d�j�j�W�D�J�J�5N��J�J�%�%�a��1��d�n�n�-������)�)�#�$Y�\`�\j�\j�$j�k�k����f�j�1�#�^�^�C��4�:�:�<�F��>�>�g�T�Z�Z�&?��J�J�%�%�a��1��#�#�#�$V�Y]�Yg�Yg�$g�h�h�#��
����/�/��$�$�#�$Z�[�[����$�!�%��6�#�n�n��#�E�;�7�'�(l�os�o}�o}�(}�~�~�#�� ,�U� 3��&6�u�&=�D�O���4�c�:�
�s�^��k�!����'�'�$�T�^�^�]`�%a�b�b��	�!��e�\�2�!�N�N�E�!-�e�!4����+�+�!�%��5�'��.�E��U�#�#���
�D�*�*�
*��t�~�~�s�S�T�T�
�D�L�L�
 ���u�%�$�D���d�{��$�.�.�RU�W[�\_�W`� a�b�b��E�{�d�"� ��
��>�>�#�$N�QU�Q_�Q_�$_�`�`�����(8�(8��	�	�#�u�-���!�!��E�{�e�+�"�I�E��e�A�h��-�!�/�/��U�1�X�>�A�E�!�"�I�M�E��>�>� �I�I�c�5�1�E��E�4�(��*�*�3��6���e���%�#�-Q�5�-Q�*Q�!���A�!�!�T�*�%*�
� �.�.�s�A�6���G�G���)�)�0�0��3��&�&�q�)�
��k�*����t�,�
"&���!K�D�N�N�4K�4K�� ����!7�x�8�
��e�U�+�!$�U��J�!"�J� ����_�q�0�<�H�
��
�*� �I�I�c�5�1�E���z�z��e�T�*�!&���J�#�E�5�1�"'��J�!&�J��t�z�z�?�c�*�o�5�#�#�~�~�s�D�J�J�
�L���
���%�%�c�*��"�"�&�&�s�+� �D�L�$�D���#��)�C�.�O�D�N�N�TW�4X�\i�jo�\p��!�
��E�4�(��!�!�(�(����5��e���%��!�%��(�D�1��)�)�0�0��q����@��)�)�0�0��q��:��!�!�(�(��/�
�h��)�#�u�5r=c��|js|js|jtur�|js|jr
|j}nd}|jxr|jj
}t
|jxs|�xsd}t|�turt
|�}nd}t
|j�dkDxs|}||kr5|j||�}d|_|jr	||_|S||_|S)Nr8rT)
r�r�rVrgr�r|rdr�r{r�rr�r�)rwr�rVrorrrrs        r;rzEnumDict._convert_auto�s����:�:����u�{�{�j�'@��z�z�U�Z�Z�������!�^�^�G����0G�0G�H��T�Z�Z�3�8�4�9��J��F�|�u�$� ��[�
��
��T�Z�Z��1�,�8��J��J�&����3��/��$(��!��:�:�"(�E�K���#)�E�K��r=c��|jrTt|t�s|f}|j||jt|j�|jddg|���}n>|j||jt|j�|jdd�}t|t�rt|�dk(r|d}|S�Nrr)r�rHr�r�r�rdr�r�)rwr�rVs   r;rz
EnumDict._gnvs����?�?��e�U�+��	��-�D�-�-�c�4�;�;��D�DV�DV�@W�Y]�Yj�Yj�kl�Ym�v�pu�v�E��-�-�c�4�;�;��D�DV�DV�@W�Y]�Yj�Yj�kl�Ym�n�E��e�U�#��E�
�a���!�H�E��r=)
r�r�r�rsryr�r�rr�
__classcell__�r�s@r;r!r!�s%����
!"�FB�$O6�b�0
r=r!rc���eZdZdZedd��Zd�Zd�fd�	Zd�Ze	ddddddfd�Z
d	�Zd
�Zd�Z
ed��Zd
�Zd�Zd�Zd�ZeZd�Zd�Zd�Zdd�Zdd�Zed��Zed��Zed��Zed��Zed��Zed��Z �xZ!S)rzMetaclass for EnumNc���|j||�t�|dk(rd}nd}|du}	|du}
|du}t|t�s|f}t	|�}d}d}
|j||�\�}|�\t
|dd�}t
|d|�}||j|�z}|xs|jdd}|j}
|�|j}nd}t|vr.|r,d|vr(t|t�r|jdd�nd	|z}t|vrt|vrt!d
|z��t"|vrt|vrt!d|z��t$j'gd��}|D]}||vs�t!|�d
|����t)||||	|
|��}�|_dtduxr|dk(xstduxrt-d�|D��|_t�bt-d�|D��rP�t0t2fzvr@t|vrd�}t5|�|d<�fd�}||d<n�	t7|j8�|_n�|snt=|d�rt7|j8�|_|r||d<d|_|�^t|t@�r |jCdd�jE�}||_#n&t=|d�rt7|j8�|_|
�t5|
�|d<|S#t $rY�wxYw)Nr%TFr�r�rrVrzvalue r�z1%r: MultiValue and NoAlias are mutually exclusiver�r�)r�r�r�r�r�r�)r�flagc3�<K�|]}t|t����y�wrA)rEr%�r��bs  r;r�z'EnumType.__prepare__.<locals>.<genexpr>As����(L�e���A�t�)<�e�r�c3�,K�|]}|tu���y�wrA)r%rs  r;r�z'EnumType.__prepare__.<locals>.<genexpr>Cs����#=�u�!�A��I�u�s�c��d|zf|zS)Nr[r8)r�r�rSror�r�s      r;r�z3EnumType.__prepare__.<locals>._generate_next_value_Ls����J�>�D�0�0r=c�:���j||�}||_|SrA)rxr�)r��
flag_value�
type_value�obj�member_types    �r;rxz%EnumType.__prepare__.<locals>.__new__Os!���%�-�-�c�:�>�C�",�C�K��Jr=rx�__new_member__r�r`r�)$�_check_for_existing_members_r%rHr�r��_get_mixins_rv�_get_settings_r��_order_function_r�rrkrrrrKrr�rr!�_member_typer<�
_base_type�baseintegerr�r�rur&r�r��_inherited_gnvrrcrr�)�metaclsr��bases�initr�r��boundaryr��initial_flagr�r�r��generate�order�
first_enumrr�	enum_dictr�rxr%s                    @r;�__prepare__zEnumType.__prepare__s"����,�,�S�%�8��<�C�6�M��L� �L��t�+��!��-��'�t�3���(�E�*��y�H��x�=������")�"6�"6�s�E�"B���Z��!��z�+B�D�I�H��x��H�=�H���.�.�u�5�5�H��4�:�1�1�!�4�D��/�/�E��}�"�*�*���E��x��D�W�D�-@��$��%����A�w�'��$����h��6�X�#5��K�c�Q�R�R���!�g��&9��O�RU�U�V�V��=�=�)f�g���C��*�*��c�3� G�H�H���c�H�E�\l�AR�i}�~�	�!,�	��/����.����M��D� �L�S�(L�e�(L�%L� �	��
���#=�u�#=� =�+�Va�ek�dn�Vn�Bo��u�}�1�5A�BW�5X�	�1�2��(/�	�)�$��*6�z�7P�7P�*Q�I�'���z�#3�4�&2�:�3L�3L�&M�	�#��5=�	�1�2�+/�	�(����d�J�/��<�<��C�0�6�6�8�D�"&�	��
�Z�!1�
2�".�z�/H�/H�"I�I����#/��#6�I�i� ����!!����s�K�	K�Kc��yrAr8)r�r�r�s   r;ryzEnumType.__init__is��r=c���<�t|�tu�r|jdd�}|jdd�}|jdd�}|jd|jdd��}	|jdd�}
|jdd�}|jd	d�}|jd
d�}
|jdd�}|jdd�}|jd
d�}|jdd�}|jdd�}|jdd�}|jdd�}|jdd�}t|d|�}t|d|�}t	|j�D��cgc]6\}}t
|�s&t|�st||�st|�s||f��8c}}�}|}|j||||��}|r||d<|xs|j}|	�$|jd�}	|	�|	j|�}	t|t�r|}�n�|	�6t!t#|j���D��cgc]\}}|��	}}}�nvt|	t$�r$|	j'dd�j)�x}}	�nBt+|	��r4|r!t|t$�sdj-|�}t/d|xrd|zxsddg�}g}|j�D]�\}}|rt|t0�s|f}|f|z}n
t1||f�}|j2t5|�k7rdt7d|j2dj-|j8�t5|�dj-|D�cgc]
}t;|���c}�fz��|j=||����t?||	��D�cgc]}|j@��}}n|	}dD]}tC�|} | ��| ||<�|D]}	||||<�
|j�D]\}}||vs�|||<�~	~
~~~
~~~d |_#|jH}!tK|!�tKd!d"g�z}"|"rtMd#dj-|"�����|jdd�}	t|	t$�r |	j'dd�j)�}	|j}|jN}|jP}g}#|jR}$|jT}%d$}&|�d }&|dd}#d|#vr|#d%dk7rt7d&��tV|v}'tX|v}(tZ|v})t\|v}*|j_dg�j=d�|d}+|+D]},|j|,d��|xs|jdd�}|jd
�}-|-�t|-�t`urta|-�}-t	|j��}|-�|-|d
<|jc||�\�<}.|je|�<|.�\}}/}0ta|�|d'<|0|d(<|!D]}||}tg|�||<�|#|d)<|(|d*<|'|d+<|)|d,<|*|d-<g|d.<t�|d/<�<|d0<i|d1<d|d2<||d<||d<||d3<|$|d4<|%|d5<d|d6<|ji||�|d7<|xs
t|.dd�|d<d%|d8<d%|d9<d%|d:<d|d;<|j�D]%\}}1t|1tj�s�|1jl||<�'d$}2d<|vr+�<tnur#d=}3tq�<fd>�|3D��s
ts|�d }2d?|vrd@|d?<	d}4tju||||�}5|4�|4�tzt|kr�|!D]!}5j~|j�|5|��#5j~j�D])\}}1||!vr�t�|1dA�s�|1j�|5|��+t��t�|5dB�rt�|5|5���t���t�|vr{�<tnurt7dC��dD|vr �<j�5_F|5j�|dD<dE|vr@�<j�}7|7tnj�ur�<j�}7|75_G|5j�|dE<dFD]P}||vr�t5|�}8t�<|d�}9t|.|d�}:|9��1|9|8k(s�7|d<k(r|2r�?t�|5||:�|:||<�Rt��<t�5t��r,dGD]'}||vs�t�|5|tt�|��:||<�)tzt�kr,t�5t��rTt�|5dHtt�dH��n8t�r2t�5t��r"dID]}7t�|5|7tt�|7���t��:|/rt�5dJ|5j~d�t�5dt�j~d�|	r[t|	t`�r|	j�}	t+|	�r4ta|	�5_Pt?|5|	��D�cgc]}|j@��}	}t��|dKk7st��Mt�5t��s=t�5d�t�|5d8�t�|5d9�t�|5d:�t�|5d;�n�t���t�5t��r�|5D�cgc]}|j���c}t?|5D�cgc]}|j���c}�k7r|5j�|5_T|	r5|	D�;cgc]*};|;|5j�vst�|5|;j��r|;��,}	};5j~j�D]R\}}t|t��s�t|jlt��s�2|5|jljl�|_6�T|	rc|	D�;cgc].};|;|5j�vs|;|5j�vr|;|5j�vr|;��0}	};|	|5j�k7rt7dL|5j��dM|	����|5Scc}}wcc}}wcc}wcc}w#tD$rY��"wxYw#tv$r}6|6jxxs|6}4Yd}6~6���d}6~6wwxYwcc}wcc}wcc}wcc};wcc};w)NNr�r�r�r8r�r�r�r�r�r�r�r�r�r�r�r�r�rxr�r)r1r�r�r`r�zname r�rVz)%d values expected (%s), %d received (%s)r�r�)r�r�r�r�r�r�r�r�rxr�r�r�r�r�r�r�T�mror�zinvalid enum member name(s): Frz7'value', if specified, must be the first item in 'init'r�r�r�r��_magicvalue_r�r�r�r�r�r�r�r�r�r�r*�_value_repr_r�r�r��
_inverted_�
__reduce_ex__)�__getnewargs_ex__�__getnewargs__r?�
__reduce__c3�:�K�|]}|�jv���y�wrA)rF)r�rOr%s  �r;r�z#EnumType.__new__.<locals>.<genexpr>7s�����F�g��1�� 4� 4�4�g�s�rszAn enumeration.r�r�zOReprEnum subclasses must be mixed with a data type (i.e. int, str, float, etc.)�
__format__�__str__)r�rErDr?)rrrrr
rr�__cmp__)�__le__�__lt__�__gt__�__ge__r�r�r�r&r%z%member order does not match _order_:
�
)Zr{r!�poprvr�rGr�r�rr�r8r�r�r�rH�OrderedDictr�rkrrcr�callabler�rr��
_defined_len_rdrK�_fields_r�r�r�r��localsr�r�r�r�r�r�r�r�r�rrrr�
setdefaultr�r(�
_find_new_r~�_find_data_repr_�	nonmemberrVr�r<�make_class_unpicklablerx�RuntimeErrorr��pyver�PY3_6rFr�r�r"r�r�r)rDrEr�r�r%rE�PY2_6�intrrrr*r�r�r�r�r�r
r�rr�)>r/r�r0�clsdictr1r�r�r2r�r�r�r�r�r�r�r�r�r�r�r�r�rxr�r��enum_members�
original_dict�calced_orderr�rVr��
name_valuerOr��member_names�
invalid_names�
creating_initr�	auto_args�	auto_initr�r�r�r�ignorer�rr6�save_new�
new_uses_argsr$�unpicklable�methodsr�r��er��class_method�
obj_method�enum_method�or%r�s>                                                            @�r;rxzEnumType.__new__ls������=��(��;�;�x��.�D��K�K�	�4�0�E��{�{�<��4�H��k�k�)�W�[�[��d�-K�L�G��{�{�:�t�4�H�%,�[�[�1I�4�%P�"�,3�K�K�8W�Y]�,^�)�$+�K�K�0G��$N�!����K��6�I�%�k�k�*;�T�B�O�$�[�[�)9�4�@�N� ���\�4�8�J�#�K�K���>�M�%,�[�[�1I�4�%P�"�#*�;�;�/E�t�#L� ��k�k�)�T�2�G��g�y�'�:�G��g�z�7�;�G��)0����!�)8�v��1�%�a�L�I�a�L�O�C�QR�<S�Wd�ef�Wg���F��!��L�$�M��)�)�#�u�4�u�)�M�G��(0���%��(�7�=�=�D���!�+�+�i�0���&�%�o�o�c�2�G��-��5�,����:B�4��HZ�HZ�H\�C]�:^�_�:^��$���:^��_��G�Z�0�)0����c�)B�)H�)H�)J�J��w��'�"��%�d�J�7�"�x�x��~��#�H�d�.E�w��~�.Z�&�RY�IZ�[��!��#/�#5�#5�#7�K�D�%��)�%��7�%*�I�E�&*�X��%5�
�%*�D�%�=�%9�
��+�+�s�:��>�'�(S�"�0�0� �I�I�f�o�o�6��
�O� �I�I�
�&C�
�1�t�A�w�
�&C�D�	W�)���!�'�'��
�(;�<�$8�17�|��0Q�R�0Q�1����0Q��R�&�����x��~���#�$(�G�D�M��"���!.�q�!1�G�A�J�"�&�+�+�-���1��L�(�!"�G�A�J�.���#9�;X�%�y�/�>�����,�,���L�)�C����,<�<�
����	�	�-�(�,�-�
-��+�+�i��.���g�z�*��o�o�c�#�.�4�4�6�G��}�}�������$�$���
��$�$���&�&�	��	����I� ��G�M��m�#�
�a�(8�G�(C��U�V�V��8�+�
��8�+�
��X�%���8�#��	���:�r�*�1�1�*�=���$���C��K�K��T�"���>�w�{�{�<��>���{�{�2�3�����T�
�,� >���%�D��w�}�}��'����/3�G�+�,�")�"6�"6�s�E�"B���Z�+2�+=�+=����,�(���=�
#/�w�"7���� -����!�D��D�M�E�)�%�0�G�D�M�!�
&3��!�"�",����",����&����$��
��%'�� �!�"-�-����#.��� �(*��$�%�(*��$�%� (����"��	��!%��
�� (����!*��
��&*��"�#�")�":�":�3��"F�����;��:�|�T�:�	���"#��
��$%�� �!� !���� $����!����I�D�#��#�y�)� #�	�	���
�)����'�)��&�(�7���F�g�F�F�*�7�3�"&�K��G�#�!2�G�I��	#��C����g�s�E�7�C�J��?��I��5�=�$���#�#�D�)�6�6�z�4�H�%�'�0�0�6�6�8�	��c��<�'���3��/��$�$�Z��6�	9�
��G�J�8K�$L��j�*�?�A���H��$5��f�$��2����7�*�(3�(>�(>�
�%�(2�(=�(=���%���'�$�,�,���V�^�^�+�)�1�1�F�%+�
�"�%/�%7�%7��	�"�J�D��w���"�:�t�4�L� ��d�D�9�J�!�*�d�D�9�K��%�*��*D��?�*�{���
�D�+�6� +���
�K���
�:�t� <���
�w�&��J��g�d�D�.A�B�$/�G�D�M���5�=��*�c�*��
�I�w�s�I�/F�G�
��*�c�*��F��J����V�0D�E������
�$4�j�6I�6I�)�6T�U��J�	�4�=�=��+C�D���'�<�0�!�*�*���� �.:�7�.C�
�+�+1�*�'�+J�K�+J�a�1�6�6�+J��K�������#�J�z�4�,H��J��-��J�
�.��J� 0�1��J��-��J��-�
�
�*�Z��">�#-�.�:�a��	�	�:�.�&�Z�9X�Z��!�)�)�Z�9X�2Y�Y�+5�+J�+J�
�(��")��!(�A��J�$;�$;�;�}�Z�XY�]�Mb�Mb�?c��!(����'�'�-�-�/�D�A�q��!�X�&�:�a�g�g�t�+D�$�Q�W�W�]�]�3���0��%��$����!8�!8�8��j�5�5�5�!�z�?X�?X�:X��$�
���*�3�3�3��%�4�4�g�?������}
!��  `��*'D�� S��$ �����N�	#��+�+�"��C��		#��`L��/��9X����s`�7;o.
�	o4�3o:�8o?�2p�8p�	p;�q�4q
�'/q
�
3q�	p�p�	p8�p3�3p8c��y)z6
        classes/types should always be True.
        Tr8r�s r;�__bool__zEnumType.__bool__�s��r=rc	�Z�|�|j||�S|j|||||||��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.
        )�module�qualnamer{r�r2)rx�_create_)r�rV�namesrsrtr{r�r2s        r;�__call__zEnumType.__call__�s:���=��;�;�s�E�*�*��|�|�E�5��(�QU�]b�mu�|�v�vr=c��t||�ry	||jvS#t$r+||jD��cgc]\}}|��	ncc}}wc}}vcYSwxYw)z�Return 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.
        T)rHr�rKr�)r�rVr�rOs    r;�__contains__zEnumType.__contains__�s_���e�S�!��	B��C�2�2�2�2���	B��#�*@�*@�A�*@�3�1�Q�Q�*@��A�A�A�	B�s�
�A�A
�A�Ac�B�||jvrt|j�d|�d���t||�}t	|t
�rt|j�d|����t	|t�rt|j�d|����tj||�y)Nz: cannot delete Enum member r�z: cannot delete constant z: cannot delete property )	r�r�r��get_attr_from_chainrHr�rr{�__delattr__)r�r��
found_attrs   r;r|zEnumType.__delattr__
s����3�#�#�#� �;>�<�<��N��
�)��d�3�
��j�(�+� �7:�|�|�T�J��
��
�H�
-� �7:�|�|�T�J��
�	
����d�#r=c�D�t|jgd�z�}|jtjur|jd�|jtjur|jd�ttd�r|jd�dD]@}t||�tt|�tt|�fvs�0|j|��B|jturt|�Sttt|j��|z�S)N)	r�ryrsr��__iter__�__len__rJr�r�rxr�r�)ryrDr�rE)r�r�r�r�rxrr�r"r�rvr%r�r��dir)r��interestingr�s   r;�__dir__zEnumType.__dir__s����#�,�,�0����
���6�>�>�1��O�O�I�&�� � ��(>�(>�>��O�O�/�0��6�>�*��O�O�N�+�G�F��s�F�#�G�D�&�,A�7�4�QW�CX�+Y�Y�����'�H�����&��+�&�&��#�c�#�"3�"3�4�5��C�D�Dr=c�6�|jj�S)z�Returns a mapping of member name->value.

        This mapping lists all enum members, including aliases. Note that this
        is a copy of the internal mapping.
        )r�r�r�s r;rJzEnumType.__members__1s�����$�$�&�&r=c�T�	|j|S#t$rtj�d}YnwxYwt�Lt|t�r<d|vr8	|d�}|j
d�D]
}|||z}�|S#t$r|�wxYw|j|�}t||�r|S|�)Nr�|r)	r�r��_sys�exc_infor%rErr�rH)r�r�r�r}rLs     r;r�zEnumType.__getitem__:s���	%��#�#�D�)�)���	%��-�-�/�!�$�C�	%����
�3�� 5�#��+�
��Q������C��A��c�!�f�$�F�)��
���
��	�
���#�#�D�)���f�c�"��M��Is�� 4�4�'A:�:Bc�.���fd��jD�S)Nc3�<�K�|]}�j|���y�wrA�r��r�r�r�s  �r;r�z$EnumType.__iter__.<locals>.<genexpr>Os�����F�3E�4�� � ��&�3E����r�r�s`r;rzEnumType.__iter__Ns���F�3�3E�3E�F�Fr=c�@���fd�t�j�D�S)Nc3�<�K�|]}�j|���y�wrAr�r�s  �r;r�z(EnumType.__reversed__.<locals>.<genexpr>Rs�����P�3O�4�� � ��&�3O�r�)�reversedr�r�s`r;�__reversed__zEnumType.__reversed__Qs���P�8�C�<N�<N�3O�P�Pr=c�,�t|j�SrA)rdr�r�s r;r�zEnumType.__len__Ts���3�%�%�&�&r=c�"�d|j�d�S)N�<aenum r�r�r�s r;r�zEnumType.__repr__Ys��"�|�|�.�.r=c��|jjdi�}||vrt|j�d|�d���t	||�}t|t�rt|j�d|����t|ttf�r*t|t�st|j�d|����tj|||�y)aBlock 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.
        r�z: cannot rebind member r�z: cannot rebind constant z: cannot rebind property N)rFr�r�r�r{rHr�r�rr{�__setattr__)r�r�rV�
member_mapr}s     r;r�zEnumType.__setattr__\s����\�\�%�%�n�b�9�
��:�� �69�l�l�D�I��
�)��d�3�
��j�(�+� �7:�|�|�T�J��
��
�^�X�$>�
?�
�SX�Zb�Hc� �7:�|�|�T�J��
�	
����d�E�*r=c�^�ddl}|jdtd��|j|i|��S)NrzB_convert is deprecated and will be removed, use _convert_ instead.r[)�
stacklevel)�warnings�warn�DeprecationWarning�	_convert_)r�r�r�r�s    r;�_convertzEnumType._convertss7����
�
�,�-?�A�	�	O��s�}�}�d�+�d�+�+r=c���ttj|�}|rt|�}n|}|j�D�cgc]}||�s�|||f��}	}	|	j	d���|||	||xst��}t|_|rt|�n|j|j�|||<|Scc}w#t
$r|	j	d���Y�rwxYw)z[
        Create a new Enum subclass that replaces a collection of global constants
        c��|d|dfSrr8��ts r;r�z$EnumType._convert_.<locals>.<lambda>�s���!��a��d�|r=r�c��|dSr�r8r�s r;r�z$EnumType._convert_.<locals>.<lambda>�s��q��tr=)rsr2)�varsr��modules�keys�sortrKr0r5r?�global_enum�updaterJ)
r�r�rs�filter�sourcer2�	as_global�module_globalsr��memberss
          r;r�zEnumType._convert_ys����d�l�l�6�2�3����&�\�F�#�F�17����N��#�&��+�C����%���N�	-��L�L�3�L�4��$����9I�T�J��.��������!�!�#�/�/�2�"��t���
��O���	-��L�L�^�L�,�	-�s�
B;�
	B;�C�C�Cc	��tr"t|t�r	|jd�}|j}|�|f}	n||f}	|j||	�\}
}t|dd�}t|d|�}t|t�r |jdd�j�}t|ttf�r`|r^t|dt�rK|g}}
g}t|
�D]7\}}|||||dd�}|j|�|j||f��9d}d}|D]K}|�%t|t�ri}n|j!||	�}t|t�r|||}}n|\}}|||<�M|�|j!||	�}|j#|||	||�	�}|�#	t%j&d
�j(d}|�t/|�n||_|�||_|S#t$rt|�d���wxYw#t*t,f$rY�LwxYw)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 is not representable in ASCIINr�r�r�r`r)r2r[r�)rrrH�unicode�encode�UnicodeEncodeErrorrKr�r(rvrrcrr�rk�	enumerater�r8rxr��	_getframe�	f_globalsr�r�rVr�r�)r��
class_namervrsrtr{r�r2r/r0�_r6r4�original_names�last_valuesrSr�rV�itemr\r��member_valuer�s                       r;ruzEnumType._create_�s3����*�g�.�Y�!+�!2�!2�7�!;�J��-�-���<��G�E��3�K�E��(�(��U�;�
��:��:�'>��E���8�Y��9���e�Z�(��M�M�#�s�+�1�1�3�E��e�e�T�]�+��*�U�1�X�z�:Z�$)�2�E�N��K�(��8���t� ��u�e�[��^�D���"�"�5�)����d�E�]�+� 9�
�����D����d�J�/� �G�&�1�1�*�e�D�G��$�
�+�,0�%��+�\��,0�)��\�#/�G�K� ���?��)�)�*�e�<�G��_�_�W�j�%��S[�_�\�
��>�
�����*�4�4�Z�@���>�"�:�.�$*�J�!���&.�J�#����k*�Y�#�*�$W�X�X�Y��Z#�H�-�
��
�s�G�"G2�G/�2H�Hc��t�y|D]A}|jD]0}t|t�s�|js�!t	d|�d|�����Cy)Nr�z> cannot extend )r"r�rEr�rK��mclsr�r0�chainr�s     r;r'z%EnumType._check_for_existing_members_�sK���<���E��
�
���d�D�)�d�.A�.A�#�)�4�1���&�r=c��|rt�ttfS|j||�|d}|tvr|d}t	|t�std��|j
||�xst}|jrtd��||fS)z�Returns the type for creating enum members, and the first inherited
        enum class.

        bases: the tuple of bases that was given to __new__
        r_���zZnew enumerations should be created as `EnumName([mixin_type, ...] [data_type,] enum_type)`z*cannot extend enumerations via subclassing)r"r�r'rIrErK�_find_data_type_r�)r�r�r0r6r%s     r;r(zEnumType._get_mixins_�s�������4�<���)�)�*�e�<��2�Y�
���%��r��J��*�d�+��K�L�
L��+�+�J��>�H�&���$�$��H�I�I��J�&�&r=c�V�|D]�}|jD]�}|tftzvr�t|t�r|j
ccSd|jvs�Cd|jvr1d|jvr#|jdjr
tccS|jdccS��y)Nr��__dataclass_fields__�__dataclass_params__)	r�r�rIrHrr=rFr��_dataclass_reprr�s     r;rTzEnumType._find_data_repr_s����E��
�
���V�J��5�6����h�/��,�,�,��4�=�=�0�3�d�m�m�C� 6�$�-�-� G� $�
�
�.D� E� J� J�.�.�#�}�}�Z�8�8�!&��$r=c��t�}|D]�}d}|jD]�}|tftzvr�t	|t
�r0|jtus�7|j|j��ed|jvsd|jvr?t	|t
�r��t�t|t�r��|j|xs|���|xs|}����t|�dkDrt|�d|����|r|j�Sy)Nrxr�rz: too many data types: )r�r�r�rIrHrr�rrF�
StdlibFlagrErdrKrL)r�r�r0�
data_typesr��	candidater�s       r;r�zEnumType._find_data_type_s����U�
��E��I��
�
���V�J��5�6����h�/��)�)��7�"���t�'9�'9�:���$�-�-�/�3I�T�]�]�3Z�!�$��1� �#�/�J�t�Z�4P� ��N�N�9�#4��5�� )� 1�T�I�&��$�z�?�Q���Z��T�U�U�
��>�>�#�#�r=c��t�}|D]F}|jD]5}t|t�s�|jD]}|j|���7�H|S)zuReturns the combined _settings_ of all Enum base classes

        bases: the tuple of bases given to __new__
        )r�r�rEr"r�r)r0r�r�r�rgs     r;r)zEnumType._get_settings_5sM���5���E��
�
���d�D�)�!�_�_�� ���Q��-�&��
�r=c�~�|jdd�}|duxr|du}|�rdD]]}||fD]P}t||d�}|ddjtjtjt
jfvs�N|}n|��]ntj}|�"|tjtjfvrd}	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__
        rxN)r&rxFT)r�rvrxr�r"�
StdlibEnum)
r�r\r%r6rxrgr��possible�targetrhs
          r;rSzEnumType._find_new_Cs����+�+�i��.���T�)�A�g�T�.A���?�8��!,�j� 9�H�$�X�v�t�<�F�� � �L�L�"�N�N� �L�L�&�.�.�&��#)���!:��&��8�!�.�.�����T�\�\�6�>�>�,J�!J�!�M� �M���-�/�/r=)NNr8N)NNF)NNNrN)"r�r�r�rsr�r8ryrxrqrrwryr|r�r�rJr�rr�r��__nonzero__r�r�r�r�rur'r(rTr�r�r)rSrrs@r;rrs�����U��U�n
�t�l�#�$�t�d�QU�]^�im�w�(B�$�$E�*�'��'��(G�Q�'��K�/�+�.,��<E�N�	��	��'��'�2����*����6�����*0��*0r=rc��eZdZy)rN)r�r�r�r8r=r;rrws��r=r"zNGeneric enumeration.

    Derive from this class to define new enumerations.

)r�rx�nsc��|jryy)Nz	(*values)z\(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)r�r�s r;�
__signature__r��s������mr=c��|j}|�yd|vr|dd}|r�t|�t|�kr$tdt|�|t|�|fz��t||�D]\}}t	|||��t|�t|�kr||t|�d}|D];}|j|t�}|turtd|����t	|||��=|r+tddj|j��z��yyy)NrVrz,%d arguments expected (%s), %d received (%s)zmissing value for: zinvalid keyword(s): %sr�)	r�rdrK�zipr�rL�	undefinedr�r�)rwr�r�r�r�r�remaining_argsrVs        r;ryry�s���"�"�K�����+��!�!�"�o����{��c�$�i�'��J��;�'��c�$�i��F�G�H�
H��[�$�/�I�D�#��D�$��$�0��t�9�s�;�'�'�(��T���4�N�&������y�1���I�%�#�t�$F�G�G���d�E�*�	'�
�� 8�4�9�9�T�Y�Y�[�;Q� Q�R�R��(�
r=c��t|jvrtd��t|�|ur|S	|j|S#t
$rYn-t$r"|jD]\}}||k(s�|ccYSYnwxYw|j|�}t||�r|S|�t|dd�tur|S|�:|turt|j�d���t|�d|j����td|j�d|�d���)Nz1NoAlias enumerations cannot be looked up by valuer�z () should be called with a value� is not a valid z	error in z._missing_: returned z" instead of None or a valid member)rr�rKr{r�r�r�r�rHrvr/rr�r�)r�rVr�r�r}s     r;rxrx�s
��
�#�.�.� ��K�L�L��E�{�c����	��%�%�e�,�,���
����$'�$:�$:� �L�&��u�$��
�%;����
 �
 ��
'�F��&�#���
�	�	���\�4� @�E� I��
��>���� ����!X�Y�Y� �5�#�,�,�!O�P�P���|�|�V�-��
s!�=�	A2�A2�(A2�.A2�1A2c�f�ttkr|rtd|����ytt|�di|��y)Nzunconsumed keyword arguments: r8)rXrYrKr�r"r�)r�r�s  r;r�r��s5��
�u�}���$�I�J�J��	�d�C�*�2�T�2r=c�f�t|�D]	}	|dz}n|}|r|f|zS|S#t$rY�#wxYwr�)r�rK)r�r�rSr�r�r��
last_value�	new_values        r;r�r��sU���{�+�
�	�"�Q��I��,��	���}�t�#�#�����	��	�s�$�	0�0c��y)z'deprecated, use _missing_value_ insteadNr8�r�rVs  r;r�r�����r=c�$�|j|�S)zused for failed value access)r�r�s  r;r�r��s���=�=���r=c��y)zused for failed item accessNr8)r�r�s  r;r�r��r�r=c���|jjxs |jjj}d|jj�d|j
�d||j��d�S)N�<r�r�r�)r�r=r�r�r�r�)rw�v_reprs  r;r�r��sJ��
�^�^�
(�
(�
K�D�L�L�,B�,B�,K�,K�F� �N�N�3�3�T�[�[�&����BV�W�Wr=c�L�|jj�d|j��S�Nr�)r�r�r�r�s r;rErE�s���n�n�-�-�t�{�{�;�;r=c����jjturtgd��}n't�fd�tj	��D��}t�dg�D]}|ddk7s�|j
|���jj�D]�}|jj�D]�\}}|ddk(r�t|t�r>|j�|�jvr|j
|��K|j|��]t|�j�r�t|j
|�����t|�S)z<
        Returns all members and all public methods
        )r�rsr�r�r�c3�@�K�|]}|�jvs�|���y�wrAr�)r�rLrws  �r;r�z__dir__.<locals>.<genexpr>
	s!�����\�)=�A��$�J[�J[�A[�a�)=�s��rFrr�)r�r�r�r�r�rvrr;rFrGrHrrpr��discardr�)rwr�r�r�r$s`    r;r�r�	s���
�>�>�'�'�6�1��Z�[�K��\�����)=�\�\�K��D�*�b�1�D��A�w�#�~�����%�2��>�>�%�%�'�C� �\�\�/�/�1�	��c���7�c�>���c�8�,��x�x�+�t�4�;L�;L�/L�#����-�$�+�+�D�1�#�C����8��O�O�D�)�2�(��k�"�"r=c�@�tjt|�|�SrA)r�rD)rw�format_specs  r;rDrD	s���>�>�#�d�)�[�1�1r=c�,�t|j�SrA)r�r�r�s r;r�r�!	s�������r=c�4�|j|jffSrA)r�r��rw�protos  r;r?r?%	s���>�>�D�L�L�+�+�+r=c�v�td|jj�d|jj�d���)N�unorderable types: z() <= �()�rKr�r�r�s  r;rGrG)	�)��
����9P�9P�RW�Ra�Ra�Rj�Rj�k�
l�lr=c�v�td|jj�d|jj�d���)Nr�z() < r�r�r�s  r;rHrH-	�)��
����8O�8O�QV�Q`�Q`�Qi�Qi�j�
k�kr=c�v�td|jj�d|jj�d���)Nr�z() >= r�r�r�s  r;rJrJ1	r�r=c�v�td|jj�d|jj�d���)Nr�z() > r�r�r�s  r;rIrI5	r�r=c�B�t||j�r||uStSrA�rHr�r�r�s  r;r�r�:	s ���%����(��u�}���r=c�B�t||j�r||uStSrAr�r�s  r;r�r�@	s!���%����(��5� � ��r=c��|jSrAr�r�s r;r�r�N	s���;�;�r=c��|jSrA)r�r�s r;rVrVS	s���<�<�r=c��|jSrA)r�r�s r;roroX	s���=�=�r=c��|jSrA)r�r�s  r;�pickle_by_global_namerc	s���9�9�r=c�>�t|j|jffSrA)rvr�r�r�s  r;�pickle_by_enum_namerh	s���T�^�^�T�[�[�1�1�1r=c�p����j�dj��fd��j�D��S)Nr�c3�^�K�|]$}�|jr|�dt�|������&y�w)r�N)r�rv)r�r��dcfrws  ��r;r�z"_dataclass_repr.<locals>.<genexpr>n	s0���������1�v�{�{��'�$��*�+��s�*-)r�r�r�)rwr	s`@r;r�r�l	s2���
�
#�
#�C��9�9���X�X�Z���r=r)rszIOnly changes the repr(), leaving str() and format() to the mixed-in type.c��eZdZdZy)r#z8
    Enum where members are also (and must be) ints
    N)r�r�r�rsr8r=r;r#r#	s��r=r#c�4�eZdZdZd�ZejZd�Zy)r$zr
    Enum where members are also (and must already be) strings

    default value is member name, lower-cased
    c
��|rtd|jz��|r@t|dt�s-t|j�d|d�dt	|d��d���t|�}tj||�}||_|S)Nz#%r: keyword arguments not supportedrz: values must be str [z is a r�)rKr�rHr�r{rxr�)r�ror�rVr�s     r;rxzStrEnum.__new__�	sz����A�S�\�\�R�S�S���f�Q�i��-�����W]�^_�W`�bf�gm�no�gp�bq� r�s�s��V������S�%�(������
r=c�"�|j�S)zD
        Return the lower-cased version of the member name.
        )�lower)r�r�rSr�s    r;r�zStrEnum._generate_next_value_�	s���z�z�|�r=N)r�r�r�rsrxr�rEr�r8r=r;r$r$�	s���	��k�k�G�r=r$c��eZdZdZd�Zy)r'z}
    Enum where members are also (and must already be) lower-case strings

    default value is member name, lower-cased
    c�|�tj||g|��i|��}||j�k7rtd|z��|S)Nz%r is not lower-case)r$r&rr��r�rVr�r�r$s     r;rxzLowerStrEnum.__new__�	�B���$�$�S�%�?�$�?�$�?���E�K�K�M�!��3�e�;�<�<��
r=N�r�r�r�rsrxr8r=r;r'r'�	s���r=r'c��eZdZdZd�Zd�Zy)r(z}
    Enum where members are also (and must already be) upper-case strings

    default value is member name, upper-cased
    c�|�tj||g|��i|��}||j�k7rtd|z��|S)Nz%r is not upper-case)r$r&�upperr�rs     r;rxzUpperStrEnum.__new__�	rr=c�"�|j�SrA)r)r�r�rSr�r�r�s      r;r�z"UpperStrEnum._generate_next_value_�	s���z�z�|�r=N)r�r�r�rsrxr�r8r=r;r(r(�	s����r=r(c��eZdZdZeZy)�AutoEnumza
        automatically use _generate_next_value_ when values are missing (Python 3 only)
        N)r�r�r�rsrr�r8r=r;rr�	s��	� �
r=rc��eZdZdZd�Zy)rz�
    Automatically assign increasing values to members.

    Py3: numbers match creation order
    Py2: numbers are assigned alphabetically by member name
         (unless `_order_` is specified)
    c��t|j�dz}|jturtj	||�}n>|jt
urt
j	||�}ntj	|�}||_|Sr�)rdrJr�r[rx�longr�r�)r�r�r�rVr$s     r;rxzAutoNumberEnum.__new__�	sk���C�O�O�$�q�(������#��+�+�c�5�)�C�
�
�
�$�
&��,�,�s�E�*�C��.�.��%�C�����
r=Nrr8r=r;rr�	s���	r=rc��eZdZeZy)rN)r�r�r�rr�r8r=r;rr�	s���Jr=rc��eZdZdZeZy)rz1
    Multiple values can map to each member.
    N)r�r�r�rsrr�r8r=r;rr�	s����Jr=rc��eZdZdZeZy)rzQ
    Duplicate value members are distinct, but cannot be looked up by value.
    N)r�r�r�rsrr�r8r=r;rr�	s����Jr=rc�(�eZdZdZd�Zd�Zd�Zd�Zy)rz7
    Add ordering based on values of Enum members.
    c�p�|j|jur|j|jk\StSrA�r�r�r�r�s  r;rJzOrderedEnum.__ge__�	�+���>�>�U�_�_�,��<�<�5�=�=�0�0��r=c�p�|j|jur|j|jkDStSrAr"r�s  r;rIzOrderedEnum.__gt__�	�+���>�>�U�_�_�,��<�<�%�-�-�/�/��r=c�p�|j|jur|j|jkStSrAr"r�s  r;rGzOrderedEnum.__le__
r#r=c�p�|j|jur|j|jkStSrAr"r�s  r;rHzOrderedEnum.__lt__
r%r=N)r�r�r�rsrJrIrGrHr8r=r;rr�	s����
�
�
r=rc��eZdZd�Zy)r*c�@�|tjur|jSyrA)r+�PrepareProtocolr�)rw�protocols  r;�__conform__zSqliteEnum.__conform__
s���7�2�2�2��y�y� �3r=N)r�r�r�r,r8r=r;r*r*
s��	!r=c��eZdZdZeZy)rz+
    Ensure no duplicate values exist.
    N)r�r�r�rsrr�r8r=r;rr
s����Jr=rc���ttj|�}|rt|�}n|}t�fd�|j	�D��}||||��}t
|_|j|j�|||<y)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')
    c3�>�K�|]\}}�|�s�||f���y�wrAr8)r�r�rVr�s   �r;r�zconvert.<locals>.<genexpr>.
s �����S�N�[�T�5�f�T�l�D�%�=�N�s��	)rsN)	r�r�r�r�rGr5r?r�rJ)rr�rsr�r�r�r�s   `   r;�convertr0
ss����$�,�,�v�.�/�N�
��f������S�F�L�L�N�S�S�G���g�f�-�D�+�D�����$�*�*�+��N�4�r=c�(�||jvs.||jvs |t|dd�D�cgc]}|d��	c}vr-t|�d|jj	|||�����d}|j
ddD]Q}|jj	|�}|��!t
|ttf�rnt|�d|j����	|j}|j}|j}	|j}
t|j�D��cgc]}|jD]}|���c}}�}
	|j }t"|j$v}t&|j$v}t(|j$v}|j*xsg}|r|st-d	|jz��|	j.}t|d
d�xst|dd�xs|}|sb|D�cgc]}|j0��}}t3|�}t|dd�}|�|xr|d
dzxsd}t|dd�}|�
|||||�f}n|f}|t4j.urd}nd}t3|�dk(r|\}n|}d}i}t
|t6�r|j8}|j:}t
|t<�s|f}n|}d|vr!d|vr|j?d�}n|d|dd}}n|r|d|ddd}}}|r|f}|	t<ur|f}|s||�}tA|d�s*||_!n"||g|��i|��}tA|d�s
|	|�|_!|jB}|r
d|vr|}n|f|z}||_"|jF|_$|jJ|�|f|z|_&t3|j�|_'dx}}tA|d�rr|jP|z}|jR|z}|jTdk7rEtWtY||z��} | r+tdtZ�ddj]d�| D������|rt_||||��S|jL}!|ja�D]X}"t|"d|"jBg�}#|#D]9}$|!D]2}%|$|%k(s�	|s|rt-|�d|"����t_||"|||d��cccS�;�Ztbtdkrtff}&ntfthf}&tk||&�r{tA|d�rotm|�rt_||||��S||jRz|k(r3|
j	|��"|
j	|�}'t_||'|||d��St_||||d��St_||�Scc}wcc}}w#t$rt|�d���wxYw#t$rg}d}d}d}g}Y���wxYwcc}w)z/
    Add a new member to an existing Enum.
    r�r8rz already in use as N� already in use in superclass z is not a supported EnumFz*no values specified for MultiValue enum %rr�r&r�r_r�TrVrr�r��keepz
invalid Flag z -- missing values: r�c3�2K�|]}t|����y�wrA)r�)r�r�s  r;r�zextend_enum.<locals>.<genexpr>�
s����*B�6�a�3�q�6�6�r�)r
�maskr�z is a duplicate of )r�r
r5�is_alias)r
r5r6)7rFr�rvrKr�r�rHrrlr�r�r�r�r�r;r�r�rr�rrr�r�rxrVrdr�rr�r�r�rLr�r�r�r�r�ryr�r�r�r�r�rkrYr�r��_finalize_extend_enumrorXrYr%r�rEr
)(�enumerationr�r�r�r��
descriptorr�r�r�r�r�rr��base_attributesr��
_multi_value_�
_no_alias_r�r��mt_new�_newrOr�rSr�rrhrV�more_values�
new_memberr�r��missed�
new_valuesr��canonical_values_�canonical_valuer��
flag_bases�	canonicals(                                        r;rr4
s'��
�K�(�(�(��{�/�/�/��g�k�;O�QS�&T�U�&T���!��&T�U�U��T�;�;O�;O�;S�;S�TX�Ze�fj�Zk�;l�m�n�n��J��#�#�A�B�'���]�]�&�&�t�,�
��!��*�x�1F�&G�H����d�m�m� \�]�]�
(�H�"�/�/��$�3�3��#�1�1�
�(�;�;���+�/�/�*;�P�*;�Q�Q�Z�Z��q�Z�q�*;�P�Q���(�;�;��"�k�&<�&<�<�
��� 6� 6�6�
��[�3�3�3��!�-�-�3����T��E��H\�H\�\�]�]�
�
"�
"�F��;���5�o���N^�`d�9e�o�io�D��(3�4��1�q�w�w���4��K� ����Y��5���=��9�[��_�q�%8�>�Q�E��{�$;�T�B�����$��u�k�:�=�D��9�D��v�~�~���
��
�
�4�y�A�~�������K�
�D��%����z�z���z�z���e�U�#��y�����+���d�?��H�H�W�%�E��q�'�4���8�4�E�	�#'��7�D���H�b�D�{����9�D�����x����+�&�
��z�9�-�!&�J���+�5��5��5�
��z�9�-�!.��!5�J�����E���k�!��D��9�{�*�D��J��)�3�3�J���J����� �)�k�1�J��!�+�"<�"<�=�J�� $�#�J���{�L�)� �+�+�e�3�
�!�-�-��5���!�!�V�+��.��
�{�)B�C�D�F�����	�	�*B�6�*B� C�E����$�[�*�:�T_�`�`� �(�(�
� ,� 3� 3� 5�� '�(8�*�GW�G_�G_�F`� a��#4��!+�I�&�)�3�#�}�",�*�Vf�-g�"h�h�$9��FV�]a�hr�zE�PT�$U�U�",�$5�!6��5�=���J��z�)�J��k�:�.�7�;��3U��U�#�,�[�*�:�\g�h�h��;�2�2�2�e�;�@R�@V�@V�W\�@]�@i� 2� 6� 6�u� =�I�0��i�d�Yc�ju�AE�F�F�0��j�z�`k�vz�{�{�)��j�A�A��yV��"Q���H���F�G�G�H�������
��
�����
��5s=�U�AU�U
�2U�;AU5�V�U�U2�5V�Vc���|xs|j}d}|jddD]Q}|jj|�}|��!t	|t
tf�rnt|�d|j����|s)t�}|j||�t|||�|s|jj|�||j|<t|d|jg�D]}		||j |	<�|rB||_||_t)|j�r|xj*|jzc_|S#t$r|xj"|	|ffz
c_Y�~wxYw)Nrr2r�)r�r�rFr�rHrrlrKr�r�r�r�r�r�rvr�r�r�r�r�r
r�)
r8r@r�r
r5r6r9r�r�r�s
          r;r7r7�
sZ���"�:�?�?�D��J��#�#�A�B�'���]�]�&�&�t�,�
��!��*�x�1F�&G�H����d�m�m� \�]�]�
(���:�����k�4�0���T�8�,���"�"�)�)�$�/�%/�K���T�"�
�Z��j�.@�.@�-A�
B��	B�0:�K�*�*�1�-�C�
�!%���"&�����+�+�,��&�&�*�*<�*<�<�&�����	B��*�*��:��.A�A�*�	B�s�)E�!E$�#E$c	�,�g}|jj�D]2\}}||jk7s�|j||jf��4|r:dj	|D��cgc]\}}|�d|����c}}�}td|�d|����|Scc}}w)zS
    Class decorator that ensures only unique members exist in an enumeration.
    r�z -> zduplicate names found in r�)rJrGr�r�r�r�)r8�
duplicatesr�r��alias�duplicate_namess      r;rr�
s����J�#�/�/�5�5�7���f��6�;�;�����t�V�[�[�1�2�8���)�)�AK�L��
���u�d�+��L�����o�/��	����Ms�$B
)r,c�H�eZdZdZe�Ze�Ze�Ze�Zy)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)	r�r�r�rsrr-r.r/r0r8r=r;r,r,s%��	�����&������v�r=r,r%zRGeneric flag enumeration.

Derive from this class to define new flag enumerations.r�r�c���|s|r
d|f|duf|zSd|f|duSt|�}	t|�}d|dzz}|r|f|zS|S#t$rYnwxYwtd|z��)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
    rNr[zinvalid Flag value: %r)�maxr�r�rK)	r�r�rSr�r�r�r��high_bitr}s	         r;r�r�/s�������J�u�D�0�1�4�t�;�;��u�:�e�4�/�0�0���%�
�	� ��,�H��8�A�:�&�F���y�D�(�(��
���	��	���0�:�=�>�>s�A�A�	A�Ac#�K�t||jz�D]}|jj|����!y�w)zY
    Extract all members from the value in definition (i.e. increasing value) order.
    N)rYr�r�r�)r�rV�vals   r;r�r�Ks9�����e�c�&8�&8�8�9���$�$�(�(��-�-�:�s�<>r�c#�|K�t|j|��}|jd���|D]}|���y�w)zA
    Extract all members from the value in definition order.
    c��|jSrA�r��rOs r;r�z&_iter_member_by_def_.<locals>.<lambda>]���q�~�~r=r�N)rkr�r�)r�rVr�r�s    r;r�r�Vs;�����3�-�-�e�4�5�G��L�L�-�L�.������s�:<c�$�|j|�S)z;
    return a member matching the given value, or None
    )r�r�s  r;r�r�as���%�%�e�,�,r=c���|dx}}t|t�st|�d|j����|j}|j
}|j}||z}||z}|j}	d|f|dk}
|
rs|
|kre|	tur|S|	turd|
j�z|
z}nD|	turd|
j�z|
z|z}n"t|�d|j����|dz|
z}||z}||z|z}||z}
|	tur|
r1|S|	turd}
n$|	tur|
rt|�d|j����t|j|��}|}d}|r�d}|jj!�D]s\}}||vs�|j"s�|j"|z|j"k(s�5|j"|zs�E|j%|�||j"z}||j"z}�u||z|z}|r8|	turn/|	turd}n$|	tur|St|�d|j����|
|z}
||
z}|f|ddz}|j'd���|j(|g|���}t+|dd�}|j,t.ur|st.j1|�}n!|xs|j,j0|g|���}t3|d	�s||_|rXd
j5|D�cgc]}|j6��c}�|_|
r/|xj6d|j9|
�zz
c_nd|_|j:j=||�}|
�||j:|
<|Scc}w)z$
    Create a composite member.
    rr�Nr[rc��|jSrArTrUs r;r�z(_create_pseudo_member_.<locals>.<lambda>�rVr=r�r&r�r�z|%s)rHr-r�r�r�r�r�r�r/r0rar.r-rkr�r�rGr�r�r�r�rvr�r�rxr�r�r�r�r�rR)r�rorV�error_value�	flag_mask�singles_mask�all_bits�unknown_bits�unnamed_bitsr2�	neg_valuer��
unnamed_value�
unknown_valuer��final_value�
still_unknown�foundrL�pmrx�
pseudo_memberrOs                       r;r�r�is���!��)�#�E�K��e�[�)��*5�s�|�|�D��	����I��%�%�L��~�~�H��i�'�L��y�j�(�L��~�~�H��u�
�e�a�i�(�I����	�!��5� �"�"��T�!��I�0�0�2�3�i�?���W�$��Y�1�1�3�4�y�@�I�M�� �2=�s�|�|�L����q�L�9�,�E��<�'�L��I�%��
�5�M��Y�J�&�M��5�����	�W�	��
�	�V�	���*5�s�|�|�D��
��3�$�$�\�2�3�G��K��M�����%�%�+�+�-�E�A�r��g�%��J�J��J�J��,��
�
�:��J�J��.����r�"��r�z�z�)������#��.��-��/�=�@�
���4����W�$� !�
��U�"�"�"� �.9�3�<�<�H����]�"�M��=� �K��_�v�a�b�z�
)�F��L�L�-�L�.�
.�S�
.�
.�w�
@��
@�F��c�+�T�2�G�
���F�"�7����s�+�
�=��=�C�$5�$5�$=�$=�s�L�V�L�
��=�)�,� +�
���"�x�x�7�(C�7�a����7�(C�D�
���� � �E�C�,>�,>�}�,M�$M�M� �#�
���*�*�5�5�k�=�Q�M���,9����y�)����)Ds�%M$c��|jttfzvr|St|�dkr||j�fzS|S)zB
    Return values to be fed to __new__ to create new member.
    r[)r�r-r�rd)r�r�ros   r;r�r��sE�����[�F�:�5�6��
�	�V��q����*�*�,�/�/�/��
r=c�*�t||j�s9tdt|�j�d|jj�d���|j
dk(s|j
dk(ry|j
|j
z|j
k(S)zH
    Returns True if self has at least the same flags set as other.
    �'unsupported operand type(s) for 'in': '�' and '�'rF)rHr�rKr{r�r�r�s  r;ryry�sw��
�e�T�^�^�,���U��$�$�d�n�n�&=�&=�
?�@�	@�
�}�}���T�\�\�Q�.���=�=�4�<�<�'�5�=�=�8�8r=c#�TK�|j|j�D]}|���y�w)z,
    Returns flags in definition order.
    N)r�r�)rwr�s  r;rr�s&����
�$�$�T�\�\�2����3�s�&(c�,�t|j�SrA)r	r�r�s r;r�r��s���T�\�\�"�"r=c��|j}|j�d|j�d|j�d�Sd|j�d|j�d|j�d�S)Nr�r�r�r��r�r�r�r��rwr�s  r;r�r��sH��
�.�.�C��{�{�� �\�\�4�<�<�8�8��!$���d�k�k�4�<�<�H�Hr=c��|j}|j�|j�d|j�d�S|j�d|j��S)Nr�r�r�rprqs  r;rErEs;��
�.�.�C��{�{���<�<����6�6��,�,����4�4r=c�,�t|j�SrA�rur�r�s r;r�r�����D�L�L�!�!r=c�,�t|j�SrArtr�s r;rqrqrur=c���t||j�r
|j}n1|jturt||j�r|}nt
S|j|j|z�SrA�rHr�r�r�r�r��rwr��other_values   r;rr�Y���%����(��m�m��	
�	�	�6�	)�j���@R�@R�.S������>�>�$�,�,��4�5�5r=c���t||j�r
|j}n1|jturt||j�r|}nt
S|j|j|z�SrArxrys   r;rr"r{r=c���t||j�r
|j}n1|jturt||j�r|}nt
S|j|j|z�SrArxrys   r;rr,r{r=c���|j�_|j|j|jz�|_t	|j|j�r||j_|jSrA)r>r�r�r�rHr�s r;rr6sU�������.�.��)<�)<����}�)L�M����d�o�o�t�~�~�6�)-�D�O�O�&��?�?�r=rr
rc��eZdZdZeZd�Zy)r&zSupport for integer-based Flagsc�n�t|t�r|j|�}nOt||j�s9tdt	|�j
�d|jj
�d���|jdk(s|jdk(ry|j|jz|jk(S)zP
        Returns True if self has at least the same flags set as other.
        rjrkrlrF)rHr[r�rKr{r�r�r�s  r;ryzIntFlag.__contains__Ls����e�S�!��N�N�5�)�E��E�4�>�>�2����K�(�(�$�.�.�*A�*A�C�D�
D��=�=�A������!2���}�}�t�|�|�+�u�}�}�<�<r=N)r�r�r�rsr0r�ryr8r=r;r&r&Gs��%��J�=r=r&c�(�|j�dz
S)z@returns index of highest bit, or -1 if value is zero or negativer)rarUs r;r�r�]s�������!�!r=c�t�|jjjd�d}|�d|j��S)z{
    use module.enum_name instead of class.enum_name

    the module is the last module in case of a multi-module name
    r�r_)r�r�rr�)rwrss  r;�global_enum_reprr�as2���^�^�
&�
&�
,�
,�S�
1�"�
5�F��d�k�k�*�*r=c��|jjjd�d}|jj}|j�|�d|�d|j
�d�St
|�r|�d|j��S|jtjur=dj|jjd�D�cgc]	}|�d|����c}�Sg}|jjd�D]=}|dj�r|j|��(|j|�d|����?dj|�Scc}w)z{
    use module.flag_name instead of class.flag_name

    the module is the last module in case of a multi-module name
    r�r_r�r�r�r)r�r�rr�r�r�r
r�r,r0r�r��isdigitr�)rwrsr�r�rLs     r;�global_flag_reprr�js���^�^�
&�
&�
,�
,�S�
1�"�
5�F��~�~�&�&�H��{�{��$�h����=�=��T�� �$�+�+�.�.����l�/�/�/��x�x�d�i�i�o�o�c�>R�S�>R�d�F�D�1�>R�S�T�T������"�"�3�'�A���t�|�|�~����A�����v�q�1�2�	(�
�x�x��~���Ts�Ec��|j�(|jj}|�d|j�d�S|jS)z2
    use enum_name instead of class.enum_name
    r�r�)r�r�r�r�)rwr�s  r;�
global_strr��s6���{�{���>�>�*�*��#�T�\�\�2�2��{�{�r=c��t|t�rt|_nt|_t|t
�r|rt|_tj|jjj|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
    )rEr%r�r�r�r)r�rEr�r�r�rFr�rJ)r��
update_strs  r;r�r��sY���#�t��'���'����c�8�$�
� ����L�L���� �)�)�0�0����A��Jr=)�WeakSetc���t|t�std|�d���	|jd||jvry||jvry||ur|jj|�y|t|d	d
�vr|jj|�y|tur,t|t �r|jj|�y|t"ur,t|t$�r|jj|�y|t&ur,t|t(�r|jj|�y|t*ur,t|t,�r|jj|�y|jj|�y#t$r"t�|_t�|_Y��t$r2ddl	}|j�\}}}td�}t|�Y���wxYw)z9
        Override for issubclass(subclass, cls).
        z(issubclass() arg 1 must be a class (got r��_subclass_cache_rN��possible 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-aroundTFr�r8)rHr{rKrFr�r�r��_subclass_negative_cache_�RecursionError�sysr��raise_from_nonerrv�
StdlibIntFlagrEr&r�r%�
StdlibIntEnumr#r�r")r��subclassr�r��tbs     r;�__subclasscheck__r��s����(�D�)��X�X�Y�Y�		!��L�L�+�,��s�+�+�+��
��6�6�
6���(�?�� � �$�$�X�.���'�(�I�r�2�2�� � �$�$�X�.���-��J�x��$A�� � �$�$�X�.��
�J�
�:�h��#=�� � �$�$�X�.��
�M�
!�j��7�&C�� � �$�$�X�.���*���H�d�!;�� � �$�$�X�.���%�%�)�)�(�3���G�	6�#*�9�C� �,3�I�C�)��	!���<�<�>�L�C��b� �"V�W�C��C� �		!�s�F�'G)�/6G)�(G)c��|j}	|j|�S#t$r1ddl}|j	�\}}}td�}t|�YywxYw)Nrr�)r�r�r�r�r�r�)r�r�r�r�r�r�s      r;�__instancecheck__r��s_���%�%��	!��(�(��2�2���	!���<�<�>�L�C��b� �"V�W�C��C� �		!�s��7A�Ac�N�trtt_tt_yyrA)r�r��StdlibEnumMetar�r8r=r;r1r1�s���+<��(�+<��(�r=c�*�tr
t`t`yy)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�r8r=r;r2r2�s����,��,�r=c��eZdZd�Zd�Zy)r4c	�X�|j|_|j|_g|_|j}|s9|j�D��cgc]\}}t
|ttf�s�|�� }}}|D]/}|||j|<|jj|��1ycc}}wrA)
r�r��_parent_module�__all__rFrGrHrr"r�)rwr�r��all_objectsr�r�r�s       r;ryzcls2module.__init__�s�������
�!�n�n�������l�l���"-�"3�"3�"5�^�"5�$�!�Q��A�
�W[�G\�9]�A�"5�D�^��D�"-�d�"3�D�M�M�$���L�L����%���_s�B&�*B&c�\�|tj|j�d|j��<yr�)r�r�r�r�r�s r;�registerzcls2module.register�s��GK����� 3� 3�T�]�]�C�Dr=N)r�r�r�ryr�r8r=r;r4r4�s
��	&�Lr=r4rA)NNNF)F)��
__future__rrs�	_constantr�_tupler�collectionsrr�r�r�rrbr+�ImportError�remover��	NameErrorrWr<rIrr�r r�r"r�r#r�r�r��
StdlibStrEnum�StdlibReprEnumr&r%r$r)rrrrrr3r	r
rYr6�typesrlr�r�r�_RouteClassAttributeToGetattrrr{r�r�r�r
r�r�r��globalsr�r/r0rgrr�rur~r�r!rr�	_Addendumr8r7r�r�ryrxr�r�r�r�r�r�r�rE�PY3r�rDr�r?rGrHrJrIr�r�r�rVro�
_enum_base�resolverr5rr��_repr_basesr[r�r'r(rr�rrrrrr*rr0rr7rr,�_flag_bases�	flag_dictr-r�r�r�r�r�ryrr�rrr�rqrrrrr�r�r�r�r��_weakrefsetr�r�r�r1r2r4r8r=r;�<module>r�s�	��%��$��#��

���
�!��
"������	E���t�Y���/�*�*�a�a�FJ�J�
�J�]�J�]�^�!�=�0���
�E��
�M�1�1��
�1���)�)��
�3���*�*��
9=�<�
�<�X�<�
�<�W�v��.%�N��$�4'�!�+� �D�
g%�t�g%�R!)��� �$���
�%�4�%��
�V�J��3��*�

�"�H�1�8�6�Z��	���M���� GK�J��J�x�J�'�J�G�J�d�J�W�J�u�t�'F�6�'F�R�*�v�j�"�
5�
�f�4�f�P��������V�:�V�"iJ�iJ�Vn�t�n�b	
�h���"�	-��`
0�t�`
0�P�
�8�^�
����
�
!�
!�&�6�*�
5�`��9�
�	���n�
��n��S��S�2�&��&�P��3�
��3��
��������
����� �
�� ����
����X��X��<��<���#��#�4�2��2������,��,��m��m��l��l��m��m��l��l�����
�����	��
����	��
����	��
����
!�6�
�����	�(9�(9�(;�<��
��+��2�����&�K��(�K��J���^�.
����c�8���c�8��6�7���7��$� �4� �
�N�N�:���T��*�4���T���$���$��4�!�T�!���� �4jB�X�<�&
�!��|�W�Y��
��
�"�K��(�K��
�
!�
!�&�+�
6�b��9�
�	�!�	�,��"�	�
��
�?��?�6��.�
��.�4�	�/��
���
�����-�
��-���k�
��k�Z��	�
��	��
9��
9������#��#��I��I��5��5���"��"��"��"��6��6��6��6��6��6������	�)���	�*���	�*�����Y�%6�%6�%8�9��
�=�c�8�T�=�,"�+��.�
��#�,�\!�=�
-�L��L��cf�!��G��N�N�<� �!���"�!�N�"�������"�E�AE�E�N�E�Z�E�-�E�-�E�*�E�}�E�_l�o}�E���
��
��
�
��
��
�
��
��v�!��D� ��!��`R��
�w�
��s��S#�T�T�+T�%T;�5U�U�-U�
U/�#S?�>S?�T
�T
�T�T�T8�7T8�;U�U�U�U�U�U�	U,�+U,�/V�V
Back to Directory File Manager