ok

Mini Shell

Direktori : /opt/cloudlinux/venv/lib64/python3.11/site-packages/distlib/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/distlib/__pycache__/compat.cpython-311.pyc

�

�܋f����ddlmZddlZddlZddlZddlZ	ddlZn
#e$rdZYnwxYwejddkr�ddl	m	Z	e
fZeZ
ddlmZddlZddlZddlmZmZmZmZmZddlmZmZmZmZm Z m!Z!m"Z"d�Zddl#Z#dd	l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,erdd
l#m-Z-ddl.Z.ddl/Z/ddl0Z1ddl2m2Z2ddl3Z3e4Z4ddl5m6Z7dd
l5m8Z9n�ddl:m	Z	e;fZe;Z
ddl:m<ZddlZddlZddl=mZmZmZmZmZmZmZm"Z"ddl>m%Z%mZm$Z$mZm Z m(Z(m)Z)m*Z*m+Z+m,Z,erdd
l>m-Z-ddl?m'Z'm&Z&m!Z!ddl@mAZ.ddl>mBZ#ddlCmAZ/ddl1Z1ddlDm2Z2ddlEmFZ3eGZ4ddl5m9Z9e7Z7	ddlmHZHmIZIn #e$rGd�deJ��ZIdRd�ZKd�ZHYnwxYw	ddlmLZMn#e$rGd�deN��ZMYnwxYw	ddlmOZOn#e$rejPejQzdfd�ZOYnwxYwddlRmSZTeUeTd��reTZSn"dd lRmVZWGd!�d"eW��ZVGd#�d$eT��ZS	dd%lXmYZYn#e$rd&�ZYYnwxYwddlZZZ	e[Z[n#e\$rdd'l]m^Z^d(�Z[YnwxYw	ej_Z_ej`Z`n-#ea$r%ejb��pd)Zcecd*krd+Zdnd,Zdd-�Z_d.�Z`YnwxYw	dd/lemfZfn)#e$r!dd0lgmhZhmiZiejjd1��Zkd2�Zld3�ZfYnwxYw	dd4lmmnZnn#e$r	dd4lomnZnYnwxYwejdd5�d6kre2��jpZpndd7lmmpZp	dd8lqmrZrn6#e$r.dd9lqmsZs	dd:ltmuZvn#e$rdSd<�ZvYnwxYwGd=�d>es��ZrYnwxYw	dd?lwmxZxn#e$rdTd@�ZxYnwxYw	ddAlqmyZynI#e$rA	ddBlzm{Z|n#e$r	ddBl}m{Z|YnwxYw	ddCl~mZm�Z�m�Z�n#e$rYnwxYwGdD�dEe���ZyYnwxYw	ddFl�m�Z�m�Z�dS#e$rYejjdGej���Z�dH�Z�GdI�dJe���Z�dTdK�Z�GdL�dMe���Z�GdN�dOe���Z�GdP�dQeN��Z�YdSwxYw)U�)�absolute_importN�)�StringIO)�FileType)�urlparse�
urlunparse�urljoin�urlsplit�
urlunsplit)�urlretrieve�quote�unquote�url2pathname�pathname2url�ContentTooShortError�	splittypec�t�t|t��r|�d��}t|��S)N�utf-8)�
isinstance�unicode�encode�_quote)�ss �_/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/distlib/compat.pyr
r
s1���a��!�!�	"�����!�!�A��a�y�y��)	�Request�urlopen�URLError�	HTTPError�HTTPBasicAuthHandler�HTTPPasswordMgr�HTTPHandler�HTTPRedirectHandler�build_opener)�HTTPSHandler)�
HTMLParser)�ifilter)�ifilterfalse)�
TextIOWrapper)rrr	r
rr
rr)
rrrrrr r!r"r#r$)rrr)�filterfalse)�match_hostname�CertificateErrorc��eZdZdS)r,N)�__name__�
__module__�__qualname__�rrr,r,]s�������rr,�c�l�g}|sdS|�d��}|d|dd�}}|�d��}||krtdt|��z���|s*|���|���kS|dkr|�d��n�|�d	��s|�d	��r(|�tj|����n;|�tj|���	d
d����|D])}|�tj|�����*tj
dd
�|��zdztj��}	|	�
|��S)zpMatching according to RFC 6125, section 6.4.3

        http://tools.ietf.org/html/rfc6125#section-6.4.3
        F�.rr2N�*z,too many wildcards in certificate DNS name: z[^.]+zxn--z\*z[^.]*z\Az\.z\Z)�split�countr,�repr�lower�append�
startswith�re�escape�replace�compile�join�
IGNORECASE�match)
�dn�hostname�
max_wildcards�pats�parts�leftmost�	remainder�	wildcards�frag�pats
          r�_dnsname_matchrM`s���
���	��5�����
�
��#�A�h��a�b�b�	�)���N�N�3�'�'�	��}�$�$�
#�>��b���I�K�K�
K��	2��8�8�:�:����!1�!1�1�1�
�s�?�?�
�K�K�� � � � �
�
 �
 ��
(�
(�	E�H�,?�,?��,G�,G�	E�

�K�K��	�(�+�+�,�,�,�,�
�K�K��	�(�+�+�3�3�E�7�C�C�D�D�D��	)�	)�D��K�K��	�$���(�(�(�(��j�����D�!1�!1�1�E�9�2�=�I�I���y�y��"�"�"rc�z�|std���g}|�dd��}|D]3\}}|dkr(t||��rdS|�|���4|sP|�dd��D]9}|D]4\}}|dkr)t||��rdS|�|���5�:t	|��dkr;td	|�d
d�tt|���������t	|��dkrtd	|�d|d
�����td���)a=Verify that *cert* (in decoded format as returned by
        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
        rules are followed, but IP addresses are not accepted for *hostname*.

        CertificateError is raised on failure. On success, the function
        returns nothing.
        ztempty or no certificate, match_hostname needs a SSL socket or SSL context with either CERT_OPTIONAL or CERT_REQUIRED�subjectAltNamer1�DNSN�subject�
commonNamer2z	hostname z doesn't match either of �, z doesn't match rz=no appropriate commonName or subjectAltName fields were found)	�
ValueError�getrMr:�lenr,r@�mapr8)�certrD�dnsnames�san�key�value�subs       rr+r+�s����	?��>�?�?�
?����h�h�'��,�,���	'�	'�J�C���e�|�|�!�%��2�2���F�F�����&�&�&���
	/��x�x�	�2�.�.�
/�
/��"%�/�/�J�C���l�*�*�)�%��:�:�#�"�F�F�F� ����.�.�.��
/��x�=�=�1���"�"�$,�H�H�d�i�i��D�(�8K�8K�.L�.L�.L�$N�O�O�
O���]�]�a�
�
�"�"�$,�H�H�h�q�k�k�$;�<�<�
<�#�$F�G�G�
Gr)�SimpleNamespacec��eZdZdZd�ZdS)�	ContainerzR
        A generic container for when multiple values need to be returned
        c�:�|j�|��dS�N��__dict__�update)�self�kwargss  r�__init__zContainer.__init__�s���M� � ��(�(�(�(�(rN)r.r/r0�__doc__rhr1rrr`r`�s-������	�	�	)�	)�	)�	)�	)rr`)�whichc�f��d�}tj����r|�|��r�SdS|�*tj�dtj��}|sdS|�tj��}tj	dkr�tj
|vr |�dtj
��tj�dd���tj��}t�fd�|D����r�g}n�fd	�|D��}n�g}t��}|D]q}tj�|��}||vrL|�|��|D]4}	tj�||	��}
||
|��r|
ccS�5�rdS)
aKGiven a command, mode, and a PATH string, return the path which
        conforms to the given mode on the PATH, or None if there is no such
        file.

        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
        of os.environ.get("PATH"), or can be overridden with a custom search
        path.

        c��tj�|��o4tj||��otj�|��Srb)�os�path�exists�access�isdir)�fn�modes  r�
_access_checkzwhich.<locals>._access_check�sD���G�N�N�2�&�&�.�2�9�R��+>�+>�.��G�M�M�"�-�-�-�
/rN�PATH�win32r�PATHEXT�c3��K�|]=}�����|�����V��>dSrb)r9�endswith��.0�ext�cmds  �r�	<genexpr>zwhich.<locals>.<genexpr>�sA�����H�H��3�9�9�;�;�'�'��	�	���4�4�H�H�H�H�H�Hrc���g|]}�|z��Sr1r1r{s  �r�
<listcomp>zwhich.<locals>.<listcomp>�s���6�6�6�s��s��6�6�6r)rmrn�dirname�environrU�defpathr6�pathsep�sys�platform�curdir�insert�any�set�normcase�addr@)r~rsrnrt�pathext�files�seen�dir�normdir�thefile�names`          rrjrj�s����	/�	/�	/��7�?�?�3���	��}�S�$�'�'�
��
��4��<��:�>�>�&�"�*�5�5�D��	��4��z�z�"�*�%�%���<�7�"�"��y��$�$����A�r�y�)�)�)��j�n�n�Y��3�3�9�9�"�*�E�E�G�
�H�H�H�H��H�H�H�H�H�
7�����6�6�6�6�g�6�6�6����E�E��u�u���	$�	$�C��g�&�&�s�+�+�G��d�"�"�����!�!�!�$�$�$�G��7�<�<��W�5�5�D�$�}�T�4�0�0�$�#������$���tr)�ZipFile�	__enter__)�
ZipExtFilec� �eZdZd�Zd�Zd�ZdS)r�c�D�|j�|j��dSrbrc)rf�bases  rrhzZipExtFile.__init__s ���M� � ���/�/�/�/�/rc��|Srbr1�rfs rr�zZipExtFile.__enter__����Krc�.�|���dSrb��close�rf�exc_infos  r�__exit__zZipExtFile.__exit__����J�J�L�L�L�L�LrN)r.r/r0rhr�r�r1rrr�r�sA������	0�	0�	0�	�	�	�	�	�	�	�	rr�c� �eZdZd�Zd�Zd�ZdS)r�c��|Srbr1r�s rr�zZipFile.__enter__$r�rc�.�|���dSrbr�r�s  rr�zZipFile.__exit__'r�rc�J�tj|g|�Ri|��}t|��Srb)�BaseZipFile�openr�)rf�argsrgr�s    rr�zZipFile.open+s0���#�D�:�4�:�:�:�6�:�:�D��d�#�#�#rN)r.r/r0r�r�r�r1rrr�r�"sA������	�	�	�	�	�	�	$�	$�	$�	$�	$rr�)�python_implementationc��dtjvrdStjdkrdStj�d��rdSdS)z6Return a string identifying the Python implementation.�PyPy�java�Jython�
IronPython�CPython)r��versionrmr�r;r1rrr�r�4sH���S�[� � ��6�
�7�f����8��;�!�!�,�/�/�	 ��<��yr)�Callablec�,�t|t��Srb)rr�)�objs r�callabler�Fs���#�x�(�(�(rr�mbcs�strict�surrogateescapec���t|t��r|St|t��r |�tt
��St
dt|��jz����Nzexpect bytes or str, not %s)	r�bytes�	text_typer�_fsencoding�	_fserrors�	TypeError�typer.��filenames r�fsencoder�Zse���h��&�&�	5��O�
��)�
,�
,�	5��?�?�;�	�:�:�:��9� ��N�N�3�4�5�5�
5rc���t|t��r|St|t��r |�tt
��St
dt|��jz���r�)	rr�r��decoder�r�r�r�r.r�s r�fsdecoder�cse���h�	�*�*�	5��O�
��%�
(�
(�	5��?�?�;�	�:�:�:��9� ��N�N�3�4�5�5�
5r)�detect_encoding)�BOM_UTF8�lookupzcoding[:=]\s*([-\w.]+)c���|dd�����dd��}|dks|�d��rdS|dvs|�d��rd	S|S)
z(Imitates get_normal_name in tokenizer.c.N��_�-rzutf-8-)zlatin-1�
iso-8859-1ziso-latin-1)zlatin-1-ziso-8859-1-ziso-latin-1-r�)r9r>r;)�orig_enc�encs  r�_get_normal_namer�tsv���s��s�m�!�!�#�#�+�+�C��5�5���'�>�>�S�^�^�H�5�5�>��7��:�:�:��>�>�E�F�F�;��<��rc�R����	�jj�n#t$rd�YnwxYwd�d}d}�fd�}��fd�}|��}|�t��rd�|dd�}d}|s|gfS||��}|r||gfS|��}|s||gfS||��}|r|||gfS|||gfS)	a?
        The detect_encoding() function is used to detect the encoding that should
        be used to decode a Python source file.  It requires one argument, readline,
        in the same way as the tokenize() generator.

        It will call readline a maximum of twice, and return the encoding used
        (as a string) and a list of any lines (left as bytes) it has read in.

        It detects the encoding from the presence of a utf-8 bom or an encoding
        cookie as specified in pep-0263.  If both a bom and a cookie are present,
        but disagree, a SyntaxError will be raised.  If the encoding cookie is an
        invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
        'utf-8-sig' is returned.

        If no encoding is specified, then the default of 'utf-8' will be returned.
        NFrc�<��	���S#t$rYdSwxYw)Nr)�
StopIteration)�readlines�r�read_or_stopz%detect_encoding.<locals>.read_or_stop�s6���
��x�z�z�!�� �
�
�
��s�s�
���s�	
�
�c���	|�d��}n7#t$r*d}��d�|���}t|���wxYwt�|��}|sdSt
|d��}	t|��}n;#t$r.��d|z}nd��|��}t|���wxYw�r9|j	dkr)��d}nd����}t|���|d	z
}|S)
Nrz'invalid or missing encoding declarationz{} for {!r}rzunknown encoding: zunknown encoding for {!r}: {}zencoding problem: utf-8z encoding problem for {!r}: utf-8z-sig)
r��UnicodeDecodeError�format�SyntaxError�	cookie_re�findallr�r��LookupErrorr�)�line�line_string�msg�matches�encoding�codec�	bom_foundr�s      ��r�find_cookiez$detect_encoding.<locals>.find_cookie�s[���	
'�#�k�k�'�2�2����%�
'�
'�
'�?���'�'�.�.�s�H�=�=�C�!�#�&�&�&�	
'���� �'�'��4�4�G��
��t�'���
�3�3�H�	
'��x�(�(�����
'�
'�
'��#�.��9�C�C�9�@�@� �(�,�,�C�!�#�&�&�&�
'�����	
#��:��(�(��'�7���@�G�G�$�&�&��%�c�*�*�*��F�"���Os��4A
�B�8CTrz	utf-8-sig)�__self__r��AttributeErrorr;r�)	r�r��defaultr�r��first�secondr�r�s	`      @@rr�r�sG�����"	��(�-�H�H���	�	�	��H�H�H�	�����	�����	�	�	�	�	�%	�%	�%	�%	�%	�%	�N��������H�%�%�	"��I��!�"�"�I�E�!�G��	��B�;���;�u�%�%���	%��e�W�$�$�������	$��U�G�#�#��;�v�&�&���	-��e�V�_�,�,�����'�'s��!�!)r=�)r�)�unescape)�ChainMap)�MutableMapping)�recursive_repr�...c����fd�}|S)zm
            Decorator to make a repr function return fillvalue for a recursive
            call
            c������t������fd�}t�d��|_t�d��|_t�d��|_t�di��|_|S)Nc����t|��t��f}|�vr�S��|��	�|��}��|��n#��|��wxYw|Srb)�id�	get_identr��discard)rfr[�result�	fillvalue�repr_running�
user_functions   ���r�wrapperz=_recursive_repr.<locals>.decorating_function.<locals>.wrapper�s�����T�(�(�I�K�K�/�C��l�*�*�(�(� �$�$�S�)�)�)�2�!.��t�!4�!4��$�,�,�S�1�1�1�1���,�,�S�1�1�1�1����!�Ms�A�A3r/rir.�__annotations__)r��getattrr/rir.r�)r�r�r�r�s` @�r�decorating_functionz,_recursive_repr.<locals>.decorating_function�s������"�u�u��	"�	"�	"�	"�	"�	"�	"�&-�]�L�%I�%I��"�")�-��"C�"C���#*�=�*�#E�#E�� �*1�-�2C�R�+I�+I��'��rr1)r�rs` r�_recursive_reprr�s$���
�
�
�
�
�,'�&rc���eZdZdZd�Zd�Zd�Zdd�Zd�Zd�Z	d	�Z
d
�Ze��d���Z
ed���Zd
�ZeZd�Zed���Zd�Zd�Zd�Zd�Zd�ZdS)r�a�
        A ChainMap groups multiple dicts (or other mappings) together
        to create a single, updateable view.

        The underlying mappings are stored in a list.  That list is public and can
        accessed or updated using the *maps* attribute.  There is no other state.

        Lookups search the underlying mappings successively until a key is found.
        In contrast, writes, updates, and deletions only operate on the first
        mapping.
        c�4�t|��pig|_dS)z�Initialize a ChainMap by setting *maps* to the given mappings.
            If no mappings are provided, a single empty dictionary is used.

            N)�list�maps)rfrs  rrhzChainMap.__init__s��
�T�
�
�*�r�d�D�I�I�Irc� �t|���rb)�KeyError�rfr[s  r�__missing__zChainMap.__missing__!s���3�-�-�rc�t�|jD]}	||cS#t$rY�wxYw|�|��Srb)rrr
)rfr[�mappings   r�__getitem__zChainMap.__getitem__$sm���9�
�
���"������������D������#�#����
s��
"�"Nc��||vr||n|Srbr1�rfr[r�s   rrUzChainMap.get.s�� #�t���4��9�9��8rc�R�tt��j|j���Srb)rVr��unionrr�s r�__len__zChainMap.__len__1s(���{�s�u�u�{������
rc�R�tt��j|j���Srb)�iterr�rrr�s r�__iter__zChainMap.__iter__5s��������T�Y�/�0�0�0rc�D��t�fd�|jD����S)Nc3� �K�|]}�|vV��	dSrbr1)r|�mr[s  �rrz(ChainMap.__contains__.<locals>.<genexpr>9s'�����3�3�A�s�a�x�3�3�3�3�3�3r�r�rr	s `r�__contains__zChainMap.__contains__8s(����3�3�3�3���3�3�3�3�3�3rc�*�t|j��Srbrr�s r�__bool__zChainMap.__bool__;s���t�y�>�>�!rc	��d�|d�tt|j������S)Nz{0.__class__.__name__}({1})rS)r�r@rWr8rr�s r�__repr__zChainMap.__repr__>s7��0�7�7��d�i�i��D�$�)� 4� 4�5�5�7�7�
7rc�8�|tj|g|�R���S)z?Create a ChainMap with a single dict created from the iterable.)�dict�fromkeys)�cls�iterabler�s   rr!zChainMap.fromkeysCs&���3�t�}�X�5��5�5�5�6�6�6rc�r�|j|jd���g|jdd��R�S)zHNew ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]rr2N)�	__class__r�copyr�s rr&z
ChainMap.copyHs8��!�4�>�$�)�A�,�"3�"3�"5�"5�F��	�!�"�"�
�F�F�F�Frc�(�|jig|j�R�S)z;New ChainMap with a new dict followed by all previous maps.�r%rr�s r�	new_childzChainMap.new_childNs��!�4�>�"�1�t�y�1�1�1�1rc�0�|j|jdd��S)zNew ChainMap from maps[1:].r2Nr(r�s r�parentszChainMap.parentsRs��"�4�>�4�9�Q�R�R�=�1�1rc�&�||jd|<dS)Nr)r)rfr[r\s   r�__setitem__zChainMap.__setitem__Ws�� %�D�I�a�L����rc��	|jd|=dS#t$r#td�|�����wxYw)Nr�(Key not found in the first mapping: {!r})rrr�r	s  r�__delitem__zChainMap.__delitem__Zsa��
L��I�a�L��%�%�%���
L�
L�
L��>�E�E�c�J�J�L�L�L�
L���s��-?c�|�	|jd���S#t$rtd���wxYw)zPRemove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.rz#No keys found in the first mapping.)r�popitemrr�s rr2zChainMap.popitemasN��
F��y��|�+�+�-�-�-���
F�
F�
F��D�E�E�E�
F���s�!�;c��	|jdj|g|�R�S#t$r#td�|�����wxYw)zWRemove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].rr/)r�poprr�)rfr[r�s   rr4zChainMap.pophsn��
L�'�t�y��|�'��3�d�3�3�3�3���
L�
L�
L��>�E�E�c�J�J�L�L�L�
L���s	��-Ac�D�|jd���dS)z'Clear maps[0], leaving maps[1:] intact.rN)r�clearr�s rr6zChainMap.clearps ���I�a�L��� � � � � rrb)r.r/r0rirhr
r
rUrrrrrr�classmethodr!r&�__copy__r)�propertyr+r-r0r2r4r6r1rrr�r�
sq������
	�
	�	+�	+�	+�	 �	 �	 �	�	�	�	9�	9�	9�	9�	�	�	�	1�	1�	1�	4�	4�	4�	"�	"�	"�
��	�	�	7�	7�
�	�	7�
�	7�	7�
��	7�	G�	G�	G���	2�	2�	2�
�	2�	2�
��	2�	&�	&�	&�	L�	L�	L�	F�	F�	F�	L�	L�	L�	!�	!�	!�	!�	!rr�)�cache_from_sourcec�P�|�d��sJ�|�d}|rd}nd}||zS)Nz.pyT�c�o)rz)rn�debug_override�suffixs   rr:r:ysC���}�}�U�#�#�#�#�#��!�&�N��	��F�F��F��f�}�r)�OrderedDict)r�)�KeysView�
ValuesView�	ItemsViewc��eZdZdZd�Zejfd�Zejfd�Zd�Zd�Z	d�Z
dd	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�ZeZe��Zefd�Zdd�Zdd�Zd�Zd�Zedd���Zd�Zd�Zd�Zd�Z d�Z!dS)r@z)Dictionary that remembers insertion orderc���t|��dkrtdt|��z���	|jn*#t$rgx|_}||dg|dd�<i|_YnwxYw|j|i|��dS)z�Initialize an ordered dictionary.  Signature is the same as for
            regular dictionaries, but keyword arguments are not recommended
            because their insertion order is arbitrary.

            r2z$expected at most 1 arguments, got %dN)rVr��_OrderedDict__rootr��_OrderedDict__map�_OrderedDict__update)rfr��kwds�roots    rrhzOrderedDict.__init__�s����4�y�y�1�}�}�� F� #�D�	�	�!*�+�+�+�
 ������!�
 �
 �
 �%'�'���d���t�,��Q�Q�Q����
�
�
�
 ����
�D�M�4�(�4�(�(�(�(�(s�<�$A#�"A#c�t�||vr&|j}|d}|||gx|d<x|d<|j|<||||��dS)z!od.__setitem__(i, y) <==> od[i]=yrr2N)rFrG)rfr[r\�dict_setitemrJ�lasts      rr-zOrderedDict.__setitem__�s[���$����{���A�w��7;�T�3�6G�G��Q��G�$�q�'�D�J�s�O��L��s�E�*�*�*�*�*rc�n�|||��|j�|��\}}}||d<||d<dS)z od.__delitem__(y) <==> del od[y]r2rN)rGr4)rfr[�dict_delitem�	link_prev�	link_nexts     rr0zOrderedDict.__delitem__�sF��
�L��s�#�#�#�(,�
���s�(;�(;�%�I�y�#�$�I�a�L�$�I�a�L�L�Lrc#�`K�|j}|d}||ur|dV�|d}||u�dSdS)zod.__iter__() <==> iter(od)r2r�N�rF�rfrJ�currs   rrzOrderedDict.__iter__��P�����;�D���7�D��d�"�"��1�g�
�
�
��A�w���d�"�"�"�"�"�"rc#�`K�|j}|d}||ur|dV�|d}||u�dSdS)z#od.__reversed__() <==> reversed(od)rr�NrSrTs   r�__reversed__zOrderedDict.__reversed__�rVrc���	|j���D]}|dd�=�|j}||dg|dd�<|j���n#t$rYnwxYwt
�|��dS)z.od.clear() -> None.  Remove all items from od.N)rG�
itervaluesrFr6r�r )rf�noderJs   rr6zOrderedDict.clear�s���
� �J�1�1�3�3� � �D��Q�Q�Q����{����t�,��Q�Q�Q���
� � �"�"�"�"��!�
�
�
���
�����J�J�t�����s�AA�
A�ATc��|std���|j}|r|d}|d}||d<||d<n|d}|d}||d<||d<|d}|j|=t�||��}||fS)z�od.popitem() -> (k, v), return and remove a (key, value) pair.
            Pairs are returned in LIFO order if last is true or FIFO order if false.

            zdictionary is emptyrr2r�)rrFrGr r4)rfrMrJ�linkrPrQr[r\s        rr2zOrderedDict.popitem�s���
�
6��4�5�5�5��;�D��	
$��A�w�� ��G�	�#�	�!��#��Q����A�w�� ��G�	�#��Q��#�	�!���q�'�C��
�3���H�H�T�3�'�'�E���:�rc� �t|��S)zod.keys() -> list of keys in od)rr�s r�keyszOrderedDict.keys������:�:�rc� ���fd��D��S)z#od.values() -> list of values in odc� ��g|]
}�|��Sr1r1�r|r[rfs  �rr�z&OrderedDict.values.<locals>.<listcomp>s���.�.�.�#�D��I�.�.�.rr1r�s`r�valueszOrderedDict.values�s���.�.�.�.��.�.�.�.rc� ���fd��D��S)z.od.items() -> list of (key, value) pairs in odc�$��g|]}|�|f��
Sr1r1rcs  �rr�z%OrderedDict.items.<locals>.<listcomp>s"���5�5�5��S�$�s�)�$�5�5�5rr1r�s`r�itemszOrderedDict.itemss���5�5�5�5��5�5�5�5rc� �t|��S)z0od.iterkeys() -> an iterator over the keys in od)rr�s r�iterkeyszOrderedDict.iterkeysr`rc#�(K�|D]}||V��
dS)z2od.itervalues -> an iterator over the values in odNr1�rf�ks  rrZzOrderedDict.itervalues
s.�����
�
���1�g�
�
�
�
�
�
rc#�,K�|D]}|||fV��dS)z=od.iteritems -> an iterator over the (key, value) items in odNr1rks  r�	iteritemszOrderedDict.iteritemss6�����
#�
#���$�q�'�l�"�"�"�"�
#�
#rc���t|��dkr tdt|��fz���|std���|d}d}t|��dkr|d}t|t��r|D]
}||||<�n@t	|d��r#|���D]
}||||<�n
|D]
\}}|||<�|���D]
\}}|||<�dS)	a�od.update(E, **F) -> None.  Update od from dict/iterable E and F.

            If E is a dict instance, does:           for k in E: od[k] = E[k]
            If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
            Or if E is an iterable of items, does:   for k, v in E: od[k] = v
            In either case, this is followed by:     for k, v in F.items(): od[k] = v

            r�z8update() takes at most 2 positional arguments (%d given)z,update() takes at least 1 argument (0 given)rr1r2r_N)rVr�rr �hasattrr_rg)r�rIrf�otherr[r\s      rrezOrderedDict.updates>���4�y�y�1�}�}��!7�:=�d�)�)��!G�H�H�H��
P�� N�O�O�O���7�D��E��4�y�y�A�~�~��Q����%��&�&�
&� �+�+�C� %�c�
�D��I�I�+����'�'�
&� �:�:�<�<�+�+�C� %�c�
�D��I�I�+�#(�&�&�J�C�� %�D��I�I�"�j�j�l�l�
"�
"�
��U�!��S�	�	�
"�
"rc�X�||vr
||}||=|S||jurt|���|S)z�od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
            If key is not found, d is returned if given, otherwise KeyError is raised.

            )�_OrderedDict__markerr)rfr[r�r�s    rr4zOrderedDict.pop7s@��
�d�{�{��c�����I��
��$�-�'�'��s�m�m�#��NrNc�(�||vr||S|||<|S)zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr1rs   r�
setdefaultzOrderedDict.setdefaultDs#���d�{�{��C�y� ��D��I��Nrc���|si}t|��t��f}||vrdSd||<	|s|jj�d�||=S|jj�d|����d�||=S#||=wxYw)zod.__repr__() <==> repr(od)r�r2�()�(�))r��
_get_identr%r.rg)rf�
_repr_running�call_keys   rrzOrderedDict.__repr__Ks��� �
#� "�
��$�x�x����-�H��=�(�(��u�&'�M�(�#�
,��@�%)�^�%<�%<�%<�?�"�(�+�+�$(�>�#:�#:�#:�D�J�J�L�L�L�L�I�!�(�+�+��M�(�+�+�+�+�+s�A)�#A)�)A.c����fd��D��}t������}tt����D]}|�|d���|r�j|f|fS�j|ffS)z%Return state information for picklingc�$��g|]}|�|g��
Sr1r1)r|rlrfs  �rr�z*OrderedDict.__reduce__.<locals>.<listcomp>\s!���0�0�0�a�a��a��\�0�0�0rN)�varsr&r@r4r%)rfrg�	inst_dictrls`   r�
__reduce__zOrderedDict.__reduce__Zs����0�0�0�0�4�0�0�0�E��T�
�
���)�)�I��+�-�-�(�(�
'�
'���
�
�a��&�&�&�&��
>����	�9�=�=��>�E�9�,�,rc�,�|�|��S)z!od.copy() -> a shallow copy of od)r%r�s rr&zOrderedDict.copyds���>�>�$�'�'�'rc�.�|��}|D]}|||<�|S)z�OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
            and values equal to v (which defaults to None).

            r1)r"r#r\�dr[s     rr!zOrderedDict.fromkeyshs.������A��
�
����#����Hrc��t|t��rJt|��t|��ko)|���|���kSt�||��S)z�od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
            while comparison to a regular mapping is order-insensitive.

            )rr@rVrgr �__eq__�rfrqs  rr�zOrderedDict.__eq__ssi��
�%��-�-�
=��4�y�y�C��%�%��=�#�z�z�|�|�u�{�{�}�}�<�=��;�;�t�U�+�+�+rc��||kSrbr1r�s  r�__ne__zOrderedDict.__ne__}s���u�}�$�$rc� �t|��S)z@od.viewkeys() -> a set-like object providing a view on od's keys)rAr�s r�viewkeyszOrderedDict.viewkeys�s���D�>�>�!rc� �t|��S)z<od.viewvalues() -> an object providing a view on od's values)rBr�s r�
viewvalueszOrderedDict.viewvalues�s���d�#�#�#rc� �t|��S)zBod.viewitems() -> a set-like object providing a view on od's items)rCr�s r�	viewitemszOrderedDict.viewitems�s���T�?�?�"r)Trb)"r.r/r0rirhr r-r0rrXr6r2r_rdrgrirZrnrerH�objectrsr4rurr�r&r7r!r�r�r�r�r�r1rrr@r@�s�������3�3�	)�	)�	)�"8<�7G�	+�	+�	+�	+�15�0@�	%�	%�	%�	%�	�	�	�	�	�	�
	�
	�
	�	�	�	�	�2	�	�	�	/�	/�	/�	6�	6�	6�	�	�	�	�	�	�
	#�	#�	#�
	"�	"�	"�>���6�8�8��#+�	�	�	�	�	�	�	�	�
	,�
	,�
	,�
	,�	-�	-�	-�	(�	(�	(�
�	�	�	�
��	�	,�	,�	,�	%�	%�	%�
	"�	"�	"�	$�	$�	$�	#�	#�	#�	#�	#rr@)�BaseConfigurator�valid_identz^[a-z_][a-z0-9_]*$c�b�t�|��}|std|z���dS)Nz!Not a valid Python identifier: %rT)�
IDENTIFIERrBrT)rrs  rr�r��s7�����Q�����	F��@�1�D�E�E�E��trc� �eZdZdZd�Zdd�ZdS)�ConvertingDictz A converting dictionary wrapper.c���t�||��}|j�|��}||ur6|||<t	|��t
ttfvr||_||_	|Srb)
r r
�configurator�convertr�r��ConvertingList�ConvertingTuple�parentr[�rfr[r\r�s    rr
zConvertingDict.__getitem__��s���$�$�T�3�/�/�E��&�.�.�u�5�5�F��F�"�"�"��S�	���<�<�N�N�$3�$5�5�5�$(�F�M�!$�F�J��MrNc���t�|||��}|j�|��}||ur6|||<t	|��t
ttfvr||_||_	|Srb)
r rUr�r�r�r�r�r�r�r[�rfr[r�r\r�s     rrUzConvertingDict.get�ss���H�H�T�3��0�0�E��&�.�.�u�5�5�F��F�"�"�"��S�	���<�<�N�N�$3�$5�5�5�$(�F�M�!$�F�J��Mrrb)r.r/r0rir
rUr1rrr�r��s=������.�.�
	�
	�
	�
	�
	�
	�
	�
	�
	rr�c���t�|||��}|j�|��}||ur1t	|��t
ttfvr||_||_	|Srb)
r r4r�r�r�r�r�r�r�r[r�s     rr4r4�sj������s�G�,�,���"�*�*�5�1�1�������F�|�|��� /� 1�1�1� $��
� ��
��
rc� �eZdZdZd�Zdd�ZdS)r�zA converting list wrapper.c���t�||��}|j�|��}||ur6|||<t	|��t
ttfvr||_||_	|Srb)
rr
r�r�r�r�r�r�r�r[r�s    rr
zConvertingList.__getitem__�r�r���c���t�||��}|j�|��}||ur*t	|��t
ttfvr||_|Srb)	rr4r�r�r�r�r�r�r�)rf�idxr\r�s    rr4zConvertingList.pop�sa���H�H�T�3�'�'�E��&�.�.�u�5�5�F��F�"�"���<�<�N�N�$3�$5�5�5�$(�F�M��MrN)r�)r.r/r0rir
r4r1rrr�r��s=������(�(�
	�
	�
	�	�	�	�	�	�	rr�c��eZdZdZd�ZdS)r�zA converting tuple wrapper.c���t�||��}|j�|��}||ur1t	|��t
ttfvr||_||_	|Srb)
�tupler
r�r�r�r�r�r�r�r[r�s    rr
zConvertingTuple.__getitem__�sj���%�%�d�C�0�0�E��&�.�.�u�5�5�F��F�"�"���<�<�N�N�$3�$5�5�5�$(�F�M�!$�F�J��MrN)r.r/r0rir
r1rrr�r��s)������)�)�	�	�	�	�	rr�c��eZdZdZejd��Zejd��Zejd��Zejd��Z	ejd��Z
ddd	�Zee
��Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�ZdS)r�zQ
        The configurator base class which defines some useful defaults.
        z%^(?P<prefix>[a-z]+)://(?P<suffix>.*)$z^\s*(\w+)\s*z^\.\s*(\w+)\s*z^\[\s*(\w+)\s*\]\s*z^\d+$�ext_convert�cfg_convert)r}�cfgc�F�t|��|_||j_dSrb)r��configr�)rfr�s  rrhzBaseConfigurator.__init__s!��(��0�0�D�K�'+�D�K�$�$�$rc���|�d��}|�d��}	|�|��}|D]P}|d|zz
}	t||��}�#t$r(|�|��t||��}Y�MwxYw|S#t
$rEt
j��dd�\}}td|�d|����}||c|_	|_
|�wxYw)zl
            Resolve strings to objects using standard import and attribute
            syntax.
            r4rr2NzCannot resolve z: )r6r4�importerrr��ImportErrorr�r�rT�	__cause__�
__traceback__)	rfrr��used�foundrK�e�tb�vs	         r�resolvezBaseConfigurator.resolves��
�7�7�3�<�<�D��8�8�A�;�;�D�
��
�
�d�+�+�� �5�5�D��C�$�J�&�D�5� '��t� 4� 4����)�5�5�5��
�
�d�+�+�+� '��t� 4� 4����5��������
�
�
�����q�r�r�*���2��J�!�!�!�Q�Q�?�@�@��/0�"�,���Q�_���	
���s0�!B�A�B�/B�B�B�B�AC%c�,�|�|��S)z*Default converter for the ext:// protocol.)r��rfr\s  rr�zBaseConfigurator.ext_converts���<�<��&�&�&rc���|}|j�|��}|�td|z���||���d�}|j|���d}|r�|j�|��}|r!||���d}n�|j�|��}|rn|���d}|j�|��s	||}n1	t|��}||}n#t$r||}YnwxYw|r||���d�}ntd|�d|�����|��|S)z*Default converter for the cfg:// protocol.NzUnable to convert %rrzUnable to convert z at )�WORD_PATTERNrBrT�endr��groups�DOT_PATTERN�
INDEX_PATTERN�
DIGIT_PATTERN�intr�)rfr\�restrr�r��ns       rr�zBaseConfigurator.cfg_convert s����D��!�'�'��-�-�A��y� �!7�%�!?�@�@�@��A�E�E�G�G�H�H�~���K����
�
�1�
�.���E��(�.�.�t�4�4�A��/��a�h�h�j�j��m�,��� �.�4�4�T�:�:���/�"#�(�(�*�*�Q�-�C�#'�#5�#;�#;�C�#@�#@�	/�$%�c�F���!/�(+�(+�)&�)&�A�)*�!��A�A��'0�!/�!/�!/�()�#��A�A�A�!/�����E�#�A�E�E�G�G�H�H�~���(�j�7<�u�u�d�d�*D�E�E�E�+�E�0�Hs�D#�#D8�7D8c��t|t��s-t|t��rt|��}||_�nt|t��s,t|t
��rt	|��}||_n�t|t��s,t|t��rt
|��}||_n�t|t��rx|j	�
|��}|r\|���}|d}|j�
|d��}|r#|d}t||��}||��}|S)z�
            Convert values to an appropriate type. dicts, lists and tuples are
            replaced by their converting alternatives. Strings are checked to
            see if they have a conversion format and are converted if they do.
            �prefixNr?)rr�r r�r�rr�r��string_types�CONVERT_PATTERNrB�	groupdict�value_convertersrUr)rfr\rr�r��	converterr?s       rr�zBaseConfigurator.convertCsQ���e�^�4�4�
2���4�:!�:!�
2�&�u�-�-��%)��"�"���~�6�6�
2�:��4�<!�<!�
2�&�u�-�-��%)��"�"����7�7�
2�J�u�e�<T�<T�
2�'��.�.��%)��"�"��E�<�0�0�	
2��(�.�.�u�5�5���2����
�
�A��x�[�F� $� 5� 9� 9�&�$� G� G�I� �2�!"�8���$+�D�)�$<�$<�	� )�	�&� 1� 1���Lrc�F����d��}t|��s|�|��}��dd��}t�fd��D����}|di|��}|r+|���D]\}}t|||���|S)z1Configure an object with a user-supplied factory.rwr4Nc�B��g|]}t|���|�|f��Sr1)r�)r|rlr�s  �rr�z5BaseConfigurator.configure_custom.<locals>.<listcomp>gs,���L�L�L�a�[��^�^�L�A�v�a�y�>�L�L�Lrr1)r4r�r�r rg�setattr)rfr�r<�propsrgr�r�r\s `      r�configure_customz!BaseConfigurator.configure_custom`s�����
�
�4� � �A��A�;�;�
$��L�L��O�O���J�J�s�D�)�)�E��L�L�L�L�6�L�L�L�M�M�F��Q�[�[��[�[�F��
1�#(�;�;�=�=�1�1�K�D�%��F�D�%�0�0�0�0��Mrc�N�t|t��rt|��}|S)z0Utility function which converts lists to tuples.)rrr�r�s  r�as_tuplezBaseConfigurator.as_tuplens$���%��&�&�
%��e�����LrN)r.r/r0rir<r?r�r�r�r�r�r��staticmethod�
__import__r�rhr�r�r�r�r�r�r1rrr�r��s������	�	�%�"�*�%M�N�N��!�r�z�/�2�2�� �b�j�!2�3�3��"��
�#9�:�:�
�"��
�8�,�,�
�!� �
�
�� �<�
�+�+��	,�	,�	,�	�	�	�.	'�	'�	'�!	�!	�!	�F	�	�	�:	�	�	�	�	�	�	�	rr�)r2)r�rb)��
__future__rrmr<�shutilr��sslr��version_infor�
basestringr�rr��typesr�	file_type�__builtin__�builtins�ConfigParser�configparserrrr	r
r�urllibrr
rrrrrr�urllib2rrrrr r!r"r#r$r%�httplib�	xmlrpclib�Queue�queuer&�htmlentitydefs�	raw_input�	itertoolsr'�filterr(r*�io�strr)�urllib.parse�urllib.request�urllib.error�http.client�client�request�
xmlrpc.client�html.parser�
html.entities�entities�inputr+r,rTrMr^r`r�rj�F_OK�X_OK�zipfiler�r�rpr��BaseZipExtFiler�r��	sysconfigr��	NameError�collections.abcr�r�r�r��getfilesystemencodingr�r��tokenizer��codecsr�r�r?r�r��htmlr=�cgir��collectionsr�r��reprlibr�r�importlib.utilr:r@�threadr�rz�dummy_thread�_abcollrArBrCr �logging.configr�r��Ir�r�r4rr�r�r�r1rr�<module>r
s7��'�&�&�&�&�&�	�	�	�	�	�	�	�	�
�
�
�
�
�
�
�
���J�J�J�J������
�C�C�C�������A�����!�!�!�!�!�!��;�L��I�+�+�+�+�+�+�"�"�"�"�'�'�'�'�L�L�L�L�L�L�L�L�L�L�L�L�L�L�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G����
�N�N�N�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<�<��)�(�(�(�(�(�(��N�N�N���������%�%�%�%�%�%������I�+�+�+�+�+�+�5�5�5�5�5�5�5� �������4�L��I�-�-�-�-�-�-��O�O�O�����?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C��0�/�/�/�/�/�/�F�F�F�F�F�F�F�F�F�F�!�!�!�!�!�!�$�$�$�$�$�$�%�%�%�%�%�%��L�L�L�&�&�&�&�&�&�*�*�*�*�*�*��I�%�%�%�%�%�%�
�F�`G�4�4�4�4�4�4�4�4�4���^G�^G�^G�
�
�
�
�
�:�
�
�
�/#�/#�/#�/#�b(G�(G�(G�(G�(G�m^G����B
)�2�2�2�2�2�2�2���)�)�)�)�)�)�)�)�F�)�)�)�)�)�)����A����������?�?�?���"�'�)��=�=�=�=�=�=�?����H+�*�*�*�*�*�
�7�;��$�$�$��G�G�4�4�4�4�4�4�	�	�	�	�	�^�	�	�	�$�$�$�$�$�+�$�$�$��.�.�.�.�.�.�.���
�
�
������
��������)��H�H���)�)�)�(�(�(�(�(�(�)�)�)�)�)�)���� 5��{�H��{�H�H���5�5�5�,�#�+�-�-�8��K��f����	�	�%�	�5�5�5�5�5�5�5�5�-5����@l(�(�(�(�(�(�(�(���j(�j(�j(�'�'�'�'�'�'�'�'���
�4�5�5�I�	�	�	�Z(�Z(�Z(�Z(�Z(�!j(����\���������������������������B�Q�B��&� � ��z�|�|�$�H�H�������L!�$�$�$�$�$�$�$���J!�J!�J!�*�*�*�*�*�*� '�=�=�=�=�=�=�=���'�'�'�	'�	'�	'�	'�	'�	'�'����@e!�e!�e!�e!�e!�>�e!�e!�e!�e!�e!�KJ!����Z�0�0�0�0�0�0�0���
�
�
�������
����H#�'�'�'�'�'�'�'���F#�F#�F#�9�2�2�2�2�2�2�2���9�9�9�8�8�8�8�8�8�8�8�9����
�;�;�;�;�;�;�;�;�;�;�;���
�
�
���
����x#�x#�x#�x#�x#�d�x#�x#�x#�x#�x#�F#����Rc�<�<�<�<�<�<�<�<�<�<���a�a�a����0�"�$�7�7�J�������������6�������������0�����%����E�E�E�E�E�6�E�E�E�E�E�E�ya���sQ��'�'�E�E(�'E(�,E3�3F	�F	�
F�F/�.F/�*G1�1G<�;G<�H�H�H�H+�+'I�I�I � #J�J�
J�J�J�K�L�K&�%L�&	K2�/L�1K2�2L�L�
L�	L�L�!L(�(M.�.L5�4M.�5M�M.�M�M.�
M�M.�M�M.�M�M.�-M.�2M<�<AO�O

Zerion Mini Shell 1.0