HEX
Server: Microsoft-IIS/10.0
System: Windows NT ITPWINWEBSVR22 10.0 build 20348 (Windows Server 2022) AMD64
User: www.conferencesearch.co.uk (0)
PHP: 8.3.30
Disabled: NONE
Upload Files
File: D:/Python311/Lib/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-311.pyc
�

�miɁ��j�dZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlm
Z
ddlmZmZddlmZddlmZddlmZmZmZmZdd	lmZmZmZmZmZmZm Z dd
lm!Z"ddlm#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+dd
l,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2dZ3ej4��Z5ddd�Z6d�7ej8ded���d����Z9ej:dkrd�Z;d�Z#d�Z<d�Z=dJd�Z>d�Z?d �Z@ejAd!���ZBd"�ZCd#�ZDd$�ZEd%�ZFdJd&�ZGd'�ZHd(�ZId)�ZJd*�ZKd+�ZLd,�ZMd-�ZNd.�ZOePd/��ZQd0�ZRd1�ZSd2�ZTd3�ZUd4�ZVd5�ZWejAd6���ZXd7�ZYdKd8�ZZd9�Z[dLd:�Z\dMd<�Z]d=�Z^d>�Z_d?�`d@��ZaeadAzZbeadBzZcdC�ZddD�ZedE�ZfdF�ZgdG�ZhdH�ZidI�ZjdS)Nz�
requests.utils
~~~~~~~~~~~~~~

This module provides utility functions that are used within Requests
that are also useful for external consumption.
�N)�OrderedDict)�make_headers�	parse_url�)�certs��__version__)�_HEADER_VALIDATORS_BYTE�_HEADER_VALIDATORS_STR�HEADER_VALIDATORS�to_native_string)�Mapping�
basestring�bytes�
getproxies�getproxies_environment�
integer_types�is_urllib3_1)�parse_http_list)�proxy_bypass�proxy_bypass_environment�quote�str�unquote�urlparse�
urlunparse��cookiejar_from_dict)�FileModeWarning�
InvalidHeader�
InvalidURL�UnrewindableBodyError)�CaseInsensitiveDict)z.netrc�_netrc�Pi�)�http�httpsz, z,\s*T)�accept_encodingzaccept-encoding�win32c�l�	ddl}n#t$rYdSwxYw	|�|jd��}t	|�|d��d��}|�|d��d}n#ttf$rYdSwxYw|r|sdS|�d��}td|��}|D]t}|dkrd|vrd	S|�
dd
��}|�
dd��}|�
d
d��}tj||tj
��rd	S�udS)NrFz;Software\Microsoft\Windows\CurrentVersion\Internet Settings�ProxyEnable�
ProxyOverride�;z<local>�.Tz\.�*z.*�?)�winreg�ImportError�OpenKey�HKEY_CURRENT_USER�int�QueryValueEx�OSError�
ValueError�split�filter�replace�re�match�I)�hostr1�internetSettings�proxyEnable�
proxyOverride�tests      �<D:\Python311\Lib\site-packages\pip/_vendor/requests/utils.py�proxy_bypass_registryrEMs���	��M�M�M�M���	�	�	��5�5�	����
	�%�~�~��(�N� � ��
�f�1�1�2B�M�R�R�ST�U�V�V�K�"�/�/�0@�/�R�R�ST�U�M�M����$�	�	�	��5�5�	�����	�-�	��5�
&�+�+�C�0�0�
��t�]�3�3�
�!�	�	�D��y� �
 ��d�?� ��4�4��<�<��U�+�+�D��<�<��U�+�+�D��<�<��T�*�*�D��x��d�B�D�)�)�
��t�t�
��us��
��A A:�:B�Bc�Z�t��rt|��St|��S)z�Return True, if the host should be bypassed.

        Checks proxy settings gathered from the environment, if specified,
        or the registry.
        )rrrE)r?s rDrrss.��"�#�#�	/�+�D�1�1�1�(��.�.�.�c�N�t|d��r|���}|S)z/Returns an internal sequence dictionary update.�items)�hasattrrI)�ds rD�dict_to_sequencerLs(���q�'����
�G�G�I�I���HrGc�H�d}d}ts*t|t��r|�d��}t	|d��rt|��}n�t	|d��r|j}n~t	|d��rn	|���}tj|��j	}d|j
vrtjdt��n#tjt f$rYnwxYwt	|d��r�	|���}t	|d	��rW|�U	|�dd
��|���}|�|pd��n'#t&$rd}YnwxYwn#t&$r|�|}YnwxYw|�d}t)d||z
��S)Nr�utf-8�__len__�len�fileno�ba%Requests has determined the content-length for this request using the binary size of the file: however, the file has been opened in text mode (i.e. without the 'b' flag in the mode). This may lead to an incorrect content-length. In Requests 3.0, support will be removed for files in text mode.�tell�seek�)r�
isinstancer�encoderJrPrQ�os�fstat�st_size�mode�warnings�warnr�io�UnsupportedOperation�AttributeErrorrSrTr7�max)�o�total_length�current_positionrQs    rD�	super_lenre�s���L�����J�q�#�.�.��
�H�H�W�����q�)�����1�v�v���	��E�	�	���u���	��H�	�	��	��X�X�Z�Z�F��8�F�+�+�3�L��!�&� �
��
�2�$�
�
�
����'��8�	�	�	�
�D�		����.�q�&���%�	%� �v�v�x�x���q�&�!�!�
%�l�
%�	%��F�F�1�a�L�L�L�#$�6�6�8�8�L��F�F�+�0�q�1�1�1�1���%�%�%�#$�L�L�L�%������%�	0�	0�	0�
�
0�#/� ���
	0����*�����q�,�!1�1�2�2�2s7�?C�C)�(C)�=E9�$AE&�&E5�4E5�9F
�	F
Fc� �tj�d��}|�|f}nd�tD��}	ddlm}m}d}|D]D}tj�|��}tj�|��r|}n�E|�dSt|��}	|	j
}
	||���|
��}|r|drdnd}|||dfSdS#|tf$r|r�YdSwxYw#ttf$rYdSwxYw)z;Returns the Requests tuple auth for a given url from netrc.�NETRCNc3� K�|]	}d|��V��
dS)z~/N�)�.0�fs  rD�	<genexpr>z!get_netrc_auth.<locals>.<genexpr>�s(����9�9��8��8�8�9�9�9�9�9�9rGr)�NetrcParseError�netrcrrU)rX�environ�get�NETRC_FILESrnrm�path�
expanduser�existsr�hostname�authenticatorsr7r2r`)
�url�raise_errors�
netrc_file�netrc_locationsrmrn�
netrc_pathrk�loc�rir?r$�login_is
             rD�get_netrc_authr�s��������(�(�J��:�%�-���9�9�[�9�9�9�� 
�0�0�0�0�0�0�0�0��
� �	�	�A��'�$�$�Q�'�'�C��w�~�~�c�"�"�
� �
���
�
�	��F�
�c�]�]���{��
	��U�:�&�&�5�5�d�;�;�F��
4�%�a�y�/�!�!�a���w�����3�3�
4�
4�� ��)�	�	�	��
��
�
�
�	�����
��(�
�
�
����
���s6�AC8�
C8�$;C"�"C5�1C8�4C5�5C8�8D
�D
c���t|dd��}|rLt|t��r9|ddkr/|ddkr%tj�|��SdSdSdSdS)z0Tries to guess the filename of the given object.�nameNr�<����>)�getattrrVrrXrr�basename)�objr�s  rD�guess_filenamer��s����3���%�%�D��&�
�4��,�,�&��a��C��&�D��H�PS�O�&��w����%�%�%�&�&�&�&�&�&�&�&rGc��tj�|��r|Stj�|��\}}|r|tj�|��s]tj�|��\}}|sn8d�||g��}|rtj�|���]tj|��s|Stj|��}||���vr|Stj
��}tj�||�d��d��}tj�|��sOt|��5}|�|�
|����ddd��n#1swxYwY|S)z�Replace nonexistent paths that look like they refer to a member of a zip
    archive with the location of an extracted copy of the target, or else
    just return the provided path unchanged.
    �/r�N)rXrrrtr9�join�zipfile�
is_zipfile�ZipFile�namelist�tempfile�
gettempdir�atomic_open�write�read)rr�archive�member�prefix�zip_file�tmp�extracted_path�file_handlers        rD�extract_zipped_pathsr�s���

�w�~�~�d�������g�m�m�D�)�)�O�G�V�
�,�"�'�.�.��1�1�,��'�-�-��0�0�����	�
����6�6�*�+�+��
�,�"�'�.�.��1�1�,���g�&�&������w�'�'�H�
�X�&�&�(�(�(�����
�
�
�C��W�\�\�#�v�|�|�C�'8�'8��'<�=�=�N�
�7�>�>�.�)�)�6�
��
(�
(�	6�L����x�}�}�V�4�4�5�5�5�	6�	6�	6�	6�	6�	6�	6�	6�	6�	6�	6����	6�	6�	6�	6��s�>)F3�3F7�:F7c#�HK�tjtj�|�����\}}	tj|d��5}|V�ddd��n#1swxYwYtj||��dS#t$rtj|���wxYw)z-Write a file to the disk in an atomic fashion)�dir�wbN)	r��mkstemprXrr�dirname�fdopenr;�
BaseException�remove)�filename�tmp_descriptor�tmp_name�tmp_handlers    rDr�r�'s����� (�/�B�G�O�O�H�4M�4M�N�N�N��N�H��
�Y�~�t�
,�
,�	������	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�
�
�8�X�&�&�&�&�&������
�	�(����
����s/�B�A�B�A#�#B�&A#�'B� B!c��|�dSt|ttttf��rtd���t
|��S)aTake an object and test to see if it can be represented as a
    dictionary. Unless it can not be represented as such, return an
    OrderedDict, e.g.,

    ::

        >>> from_key_val_list([('key', 'val')])
        OrderedDict([('key', 'val')])
        >>> from_key_val_list('string')
        Traceback (most recent call last):
        ...
        ValueError: cannot encode objects that are not 2-tuples
        >>> from_key_val_list({'key': 'val'})
        OrderedDict([('key', 'val')])

    :rtype: OrderedDict
    N�+cannot encode objects that are not 2-tuples)rVrr�boolr5r8r��values rD�from_key_val_listr�4sJ��$
���t��%�#�u�d�C�0�1�1�H��F�G�G�G��u���rGc���|�dSt|ttttf��rtd���t|t��r|���}t|��S)a�Take an object and test to see if it can be represented as a
    dictionary. If it can be, return a list of tuples, e.g.,

    ::

        >>> to_key_val_list([('key', 'val')])
        [('key', 'val')]
        >>> to_key_val_list({'key': 'val'})
        [('key', 'val')]
        >>> to_key_val_list('string')
        Traceback (most recent call last):
        ...
        ValueError: cannot encode objects that are not 2-tuples

    :rtype: list
    Nr�)	rVrrr�r5r8rrI�listr�s rD�to_key_val_listr�Osg��"
���t��%�#�u�d�C�0�1�1�H��F�G�G�G��%��!�!�����
�
����;�;�rGc���g}t|��D]N}|dd�|dd�cxkrdkrnnt|dd���}|�|���O|S)aParse lists as described by RFC 2068 Section 2.

    In particular, parse comma-separated lists where the elements of
    the list may include quoted-strings.  A quoted-string could
    contain a comma.  A non-quoted string could have quotes in the
    middle.  Quotes are removed automatically after parsing.

    It basically works like :func:`parse_set_header` just that items
    may appear multiple times and case sensitivity is preserved.

    The return value is a standard :class:`list`:

    >>> parse_list_header('token, "quoted value"')
    ['token', 'quoted value']

    To create a header from the :class:`list` again, use the
    :func:`dump_header` function.

    :param value: a string with a list header.
    :return: :class:`list`
    :rtype: list
    Nrr��")�_parse_list_header�unquote_header_value�append)r��result�items   rD�parse_list_headerr�ms���.�F�"�5�)�)��������8�t�B�C�C�y�	4�	4�	4�	4�C�	4�	4�	4�	4�	4�'��Q�r�T�
�3�3�D��
�
�d������MrGc���i}t|��D]a}d|vrd||<�|�dd��\}}|dd�|dd�cxkrdkrnnt|dd���}|||<�b|S)a^Parse lists of key, value pairs as described by RFC 2068 Section 2 and
    convert them into a python dict:

    >>> d = parse_dict_header('foo="is a fish", bar="as well"')
    >>> type(d) is dict
    True
    >>> sorted(d.items())
    [('bar', 'as well'), ('foo', 'is a fish')]

    If there is no value for a key it will be `None`:

    >>> parse_dict_header('key_without_value')
    {'key_without_value': None}

    To create a header from the :class:`dict` again, use the
    :func:`dump_header` function.

    :param value: a string with a dict header.
    :return: :class:`dict`
    :rtype: dict
    �=Nrr�r�)r�r9r�)r�r�r�r�s    rD�parse_dict_headerr��s���,�F�"�5�)�)�����d�?�	��F�4�L���j�j��a�(�(���e���!��9��b�c�c�
�	6�	6�	6�	6�c�	6�	6�	6�	6�	6�(��q��t��5�5�E���t����MrGc���|r`|d|dcxkrdkrGnnD|dd�}|r|dd�dkr*|�dd���d	d��S|S)
z�Unquotes a header value.  (Reversal of :func:`quote_header_value`).
    This does not use the real unquoting but what browsers are actually
    using for quoting.

    :param value: the header value to unquote.
    :rtype: str
    rr�r�rNrUz\\�\z\")r;)r��is_filenames  rDr�r��s���
�
C��q��U�2�Y�
C�
C�
C�
C�#�
C�
C�
C�
C�
C�
�a��d����	C�e�B�Q�B�i�6�1�	C��=�=���.�.�6�6�u�c�B�B�B��LrGc��d�|D��}|S)z�Returns a key/value dictionary from a CookieJar.

    :param cj: CookieJar object to extract cookies from.
    :rtype: dict
    c�(�i|]}|j|j��Sri)r�r�)rj�cookies  rD�
<dictcomp>z'dict_from_cookiejar.<locals>.<dictcomp>�s��>�>�>��6�;���>�>�>rGri��cj�cookie_dicts  rD�dict_from_cookiejarr��s��?�>�2�>�>�>�K��rGc�"�t||��S)z�Returns a CookieJar from a key/value dictionary.

    :param cj: CookieJar to insert cookies into.
    :param cookie_dict: Dict of key/values to insert into CookieJar.
    :rtype: CookieJar
    rr�s  rD�add_dict_to_cookiejarr��s���{�B�/�/�/rGc�`�tjdt��tjdtj���}tjdtj���}tjd��}|�|��|�|��z|�|��zS)zlReturns encodings from given content string.

    :param content: bytestring to extract encodings from.
    z�In requests 3.0, get_encodings_from_content will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)z!<meta.*?charset=["\']*(.+?)["\'>])�flagsz+<meta.*?content=["\']*;?charset=(.+?)["\'>]z$^<\?xml.*?encoding=["\']*(.+?)["\'>])r\r]�DeprecationWarningr<�compiler>�findall)�content�
charset_re�	pragma_re�xml_res    rD�get_encodings_from_contentr��s���

�M�
1�	�
�����@���M�M�M�J��
�I�QS�QU�V�V�V�I�
�Z�?�
@�
@�F�	���7�#�#�
�
�
�G�
$�
$�	%�
�.�.��
!�
!�	"�rGc��|�d��}|d���|dd�}}i}d}|D]�}|���}|rs|d}}|�d��}	|	dkr=|d|	��|��}||	dzd��|��}|||���<��||fS)	z�Returns content type and parameters from given header

    :param header: string
    :return: tuple containing content type and dictionary of
         parameters
    r-rrNz"' Tr�r�)r9�strip�find�lower)
�header�tokens�content_type�params�params_dict�items_to_strip�param�keyr��index_of_equalss
          rD�_parse_content_type_headerr��s����\�\�#�
�
�F�!�!�9�?�?�,�,�f�Q�R�R�j�&�L��K��N��-�-�����
�
���	-����C�#�j�j��o�o�O��"�$�
K��,�_�,�-�3�3�N�C�C���o��1�3�3�4�:�:�>�J�J��',�K��	�	���$����$�$rGc��|�d��}|sdSt|��\}}d|vr|d�d��Sd|vrdSd|vrdSdS)	z}Returns encodings from given HTTP Header Dict.

    :param headers: dictionary to extract encoding from.
    :rtype: str
    zcontent-typeN�charsetz'"�textz
ISO-8859-1zapplication/jsonrN)rpr�r�)�headersr�r�s   rD�get_encoding_from_headersr�s����;�;�~�.�.�L����t�5�l�C�C��L�&��F��.��i� �&�&�u�-�-�-�
�����|��\�)���w��rGc#��K�|j�
|Ed{V��dStj|j��d���}|D]}|�|��}|r|V��|�dd���}|r|V�dSdS)zStream decodes an iterator.Nr;��errorsrGT)�final)�encoding�codecs�getincrementaldecoder�decode)�iterator�r�decoder�chunk�rvs     rD�stream_decode_response_unicoder�*s�����	�z������������6�f�*�1�:�6�6�i�H�H�H�G�����
�^�^�E�
"�
"��
�	��H�H�H��	����4��	(�	(�B�	���������rGc#�K�d}|�|dkrt|��}|t|��kr)||||z�V�||z
}|t|��k�'dSdS)z Iterate over slices of a string.rN)rP)�string�slice_length�poss   rD�iter_slicesr�;s�����
�C��#�|�q�0�#��6�{�{��

��F���
���S�3��-�-�.�.�.�.��|�����F���
�����rGc�:�tjdt��g}t|j��}|r;	t|j|��S#t$r|�|��YnwxYw	t|j|d���S#t$r
|jcYSwxYw)z�Returns the requested content back in unicode.

    :param r: Response object to get unicode content from.

    Tried:

    1. charset from content-type
    2. fall back and replace all unicode characters

    :rtype: str
    z�In requests 3.0, get_unicode_from_response will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)r;r�)
r\r]r�r�r�rr��UnicodeErrorr��	TypeError)r��tried_encodingsr�s   rD�get_unicode_from_responser�Es���
�M�
1�	�
����O�)���3�3�H��-�	-��q�y�(�+�+�+���	-�	-�	-��"�"�8�,�,�,�,�,�	-������1�9�h�y�9�9�9�9�������y�������s#�A	�	A+�*A+�/B�B�BzBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~c��|�d��}tdt|����D]�}||dd�}t|��dkr�|���ro	t	t|d����}n!#t$rtd|�d����wxYw|tvr|||dd�z||<��d||��||<��d||��||<��d	�	|��S)
z�Un-escape any percent-escape sequences in a URI that are unreserved
    characters. This leaves all reserved, illegal and non-ASCII bytes encoded.

    :rtype: str
    �%rrrU�z"Invalid percent-escape sequence: '�'N�)
r9�rangerP�isalnum�chrr5r8r!�UNRESERVED_SETr�)�uri�parts�i�h�cs     rD�unquote_unreservedr
rs��
�I�I�c�N�N�E�
�1�c�%�j�j�
!�
!�
&�
&���!�H�Q�q�S�M���q�6�6�Q�;�	&�1�9�9�;�;�	&�
L���A�r�
�
�O�O�����
L�
L�
L� �!J�a�!J�!J�!J�K�K�K�
L�����N�"�
*��u�Q�x����|�+��a���)�u�Q�x�>�>��a���%�5��8�~�~�E�!�H�H�
�7�7�5�>�>�s�-B�B)c��d}d}	tt|��|���S#t$rt||���cYSwxYw)z�Re-quote the given URI.

    This function passes the given URI through an unquote/quote cycle to
    ensure that it is fully and consistently quoted.

    :rtype: str
    z!#$%&'()*+,/:;=?@[]~z!#$&'()*+,/:;=?@[]~)�safe)rr
r!)r�safe_with_percent�safe_without_percents   rD�requote_urir�sk��/��0��	5��'��,�,�3D�E�E�E�E���5�5�5��S�3�4�4�4�4�4�4�	5���s�$�A�Ac
��tjdtj|����d}|�d��\}}tjdtjtt
|��������d}tjdtj|����d|z}||z||zkS)z�This function allows you to check if an IP belongs to a network subnet

    Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
             returns False if ip = 192.168.1.1 and net = 192.168.100.0/24

    :rtype: bool
    z=Lrr�)�struct�unpack�socket�	inet_atonr9�dotted_netmaskr5)�ip�net�ipaddr�netaddr�bits�netmask�networks       rD�address_in_networkr �s����]�4��!1�"�!5�!5�
6�
6�q�
9�F��I�I�c�N�N�M�G�T��m�D�&�"2�>�#�d�)�)�3L�3L�"M�"M�N�N�q�Q�G��m�D�&�"2�7�";�";�<�<�Q�?�'�I�G��W��'�G�"3�4�4rGc�l�ddd|z
zdz
z}tjtjd|����S)z�Converts mask from /xx format to xxx.xxx.xxx.xxx

    Example: if mask is 24 function returns 255.255.255.0

    :rtype: str
    l��r� z>I)r�	inet_ntoar�pack)�maskrs  rDrr�s8����b�4�i��1�,�,�D���F�K��d�3�3�4�4�4rGc�T�	tj|��n#t$rYdSwxYwdS)z
    :rtype: bool
    FT)rrr7)�	string_ips rD�is_ipv4_addressr(�sB������#�#�#�#�������u�u������4s��
%�%c�N�|�d��dkr�	t|�d��d��}n#t$rYdSwxYw|dks|dkrdS	t	j|�d��d��n#t$rYdSwxYwdSdS)zV
    Very simple check of the cidr format in no_proxy variable.

    :rtype: bool
    r�rFr"rT)�countr5r9r8rrr7)�string_networkr%s  rD�
is_valid_cidrr,�s������C� � �A�%��	��~�+�+�C�0�0��3�4�4�D�D���	�	�	��5�5�	�����!�8�	�t�b�y�	��5�	���^�1�1�#�6�6�q�9�:�:�:�:���	�	�	��5�5�	�����u��4s#�(A�
A�A�$-B�
B �B c#�K�|du}|r.tj�|��}|tj|<	dV�|r"|�tj|=dS|tj|<dSdS#|r|�tj|=n|tj|<wxYw)z�Set the environment variable 'env_name' to 'value'

    Save previous value, yield, and then restore the previous value stored in
    the environment variable 'env_name'.

    If 'value' is None, do nothingN)rXrorp)�env_namer��
value_changed�	old_values    rD�set_environr1�s�������%�M��%��J�N�N�8�,�,�	�$��
�8��1�
�����	1��
1��J�x�(�(�(�'0��
�8�$�$�$�		1�	1��=�	1��
1��J�x�(�(�'0��
�8�$�0�0�0�0s�A"�"#Bc���d�}|}|�|d��}t|��}|j�dS|r�d�|�dd���d��D��}t	|j��r<|D]8}t|��rt
|j|��rdS�*|j|krdS�9nR|j}|jr
|d	|j��z
}|D]4}|j�|��s|�|��rdS�5td|��5	t|j��}n#ttj
f$rd
}YnwxYwddd��n#1swxYwY|rdSd
S)zL
    Returns whether we should bypass proxies or not.

    :rtype: bool
    c��tj�|��p0tj�|�����S�N)rXrorp�upper)r�s rD�	get_proxyz(should_bypass_proxies.<locals>.get_proxy�s1���z�~�~�c�"�"�A�b�j�n�n�S�Y�Y�[�[�&A�&A�ArGN�no_proxyTc3�K�|]}|�|V��	dSr4ri)rjr?s  rDrlz(should_bypass_proxies.<locals>.<genexpr>
s'����R�R�T�T�R�D�R�R�R�R�R�RrG� r�,�:F)rrur;r9r(r,r �port�endswithr1rr�r�gaierror)	rwr7r6�no_proxy_arg�parsed�proxy_ip�host_with_portr?�bypasss	         rD�should_bypass_proxiesrD�s)��B�B�B�
�L��)��9�Z�(�(��
�c�]�]�F�
����t�� �S�R�X�%5�%5�c�2�%>�%>�%D�%D�S�%I�%I�R�R�R���6�?�+�+�	 �$�
 �
 �� ��*�*� �)�&�/�8�D�D�$�#�t�t�$��_��0� � �4�4� �	
 �$�_�N��{�
4��"3�f�k�"3�"3�3�� �
 �
 ���?�+�+�D�1�1� �^�5L�5L�T�5R�5R� � �4�4� �

�Z��	.�	.���	�!�&�/�2�2�F�F���6�?�+�	�	�	��F�F�F�	����	���������������������t��5s6�E�D)�(E�)E�E�E�E�E�Ec�D�t||���riSt��S)zA
    Return a dict of environment proxies.

    :rtype: dict
    �r7)rDr)rwr7s  rD�get_environ_proxiesrG0s(���S�8�4�4�4���	��|�|�rGc��|pi}t|��}|j�.|�|j|�d����S|jdz|jz|jd|jzdg}d}|D]}||vr
||}n�|S)z�Select a proxy for the url, if applicable.

    :param url: The url being for the request
    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
    N�allz://zall://)rrurp�scheme)rw�proxies�urlparts�
proxy_keys�proxy�	proxy_keys      rD�select_proxyrP<s����m��G���}�}�H���@��{�{�8�?�G�K�K��,>�,>�?�?�?�	��%��(�"3�3����8�$�$�
�	�J�
�E����	����	��I�&�E��E�	��LrGc�d�|�|ni}|j}t|��j}|�d��}|���}|rct||���sRt
||���}|�||�d����}|r|�||��|S)a�This method takes proxy information from a request and configuration
    input to resolve a mapping of target proxies. This will consider settings
    such as NO_PROXY to strip proxy configurations.

    :param request: Request or PreparedRequest
    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
    :param trust_env: Boolean declaring whether to trust environment configs

    :rtype: dict
    Nr7rFrI)rwrrJrp�copyrDrG�
setdefault)	�requestrK�	trust_envrwrJr7�new_proxies�environ_proxiesrNs	         rD�resolve_proxiesrXVs���!�4�g�g�"�G�
�+�C�
�c�]�]�
!�F��{�{�:�&�&�H��,�,�.�.�K��2�.�s�X�F�F�F�2�-�c�H�E�E�E���#�#�F�O�,?�,?��,F�,F�G�G���	2��"�"�6�5�1�1�1��rG�python-requestsc��|�dt��S)zO
    Return a string representing the default user agent.

    :rtype: str
    r�r)r�s rD�default_user_agentr[qs���"�"�[�"�"�"rGc�L�tt��tddd���S)z9
    :rtype: requests.structures.CaseInsensitiveDict
    z*/*z
keep-alive)z
User-AgentzAccept-Encoding�Accept�
Connection)r#r[�DEFAULT_ACCEPT_ENCODINGrirGrD�default_headersr`zs2���,�.�.�6��&�		
�	
���rGc��g}d}|�|��}|s|Stjd|��D]�}	|�dd��\}}n#t$r|d}}YnwxYwd|�d��i}|�d��D]X}	|�d��\}}n#t$rYn0wxYw|�|��||�|��<�Y|�|����|S)	z�Return a list of parsed link headers proxies.

    i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"

    :rtype: list
    z '"z, *<r-rrrwz<> '"r�)r�r<r9r8r�)	r��links�
replace_chars�valrwr��linkr�r�s	         rD�parse_header_linksrf�sA��
�E��M��K�K�
�&�&�E������x���&�&����	"��)�)�C��+�+�K�C�����	"�	"�	"��r��C�C�C�	"�����s�y�y��*�*�+���\�\�#�&�&�	H�	H�E�
�"�[�[��-�-�
��U�U���
�
�
����
����.3�[�[��-G�-G�D����=�)�)�*�*�
���T������Ls#�A�A!� A!�B,�,
B:�9B:��asciirU�c���|dd�}|tjtjfvrdS|dd�tjkrdS|dd�tjtjfvrdS|�t��}|dkrd	S|dkr,|ddd�tkrd
S|ddd�tkrdS|dkr*|dd�tkrd
S|dd�tkrdSdS)z
    :rtype: str
    N�zutf-32riz	utf-8-sigrUzutf-16rrNz	utf-16-berz	utf-16-lez	utf-32-bez	utf-32-le)
r��BOM_UTF32_LE�BOM_UTF32_BE�BOM_UTF8�BOM_UTF16_LE�BOM_UTF16_BEr*�_null�_null2�_null3)�data�sample�	nullcounts   rD�guess_json_utfrw�s���"�1�"�X�F�
�&�%�v�':�;�;���x�
�b�q�b�z�V�_�$���{�
�b�q�b�z�f�)�6�+>�?�?���x����U�#�#�I��A�~���w��A�~���#�#�A�#�;�&� �	��;��!�$�Q�$�<�6�!�	��;��A�~���"�1�"�:���	��;��!�"�"�:���	��;��4rGc��t|��}|\}}}}}}}	|j}
|
s||
}}
|rd�||
g��}
|�|}|�d}t||
|d||	f��S)z�Given a URL that may or may not have a scheme, prepend the given scheme.
    Does not replace a present scheme with the one provided as an argument.

    :rtype: str
    �@Nr)r�netlocr�r)rw�
new_schemer@rJ�authr?r<rr�query�fragmentrzs           rD�prepend_scheme_if_neededr�s����s�^�^�F�6<�3�F�D�$��d�E�8��]�F��$��V����*����4��.�)�)��
���������v�v�t�R���A�B�B�BrGc��t|��}	t|j��t|j��f}n#tt
f$rd}YnwxYw|S)z{Given a url with authentication components, extract them into a tuple of
    username,password.

    :rtype: (str,str)
    )rr)rr�username�passwordr`r�)rwr@r|s   rD�get_auth_from_urlr��sd���c�]�]�F�����(�(�'�&�/�*B�*B�C�����I�&�������������Ks�(:�A�Ac�T�|\}}t||d��t||d��dS)z�Verifies that header parts don't contain leading whitespace
    reserved characters, or return characters.

    :param header: tuple, in the format (name, value).
    rrN)�_validate_header_part)r�r�r�s   rD�check_header_validityr�s7���K�D�%��&�$��*�*�*��&�%��+�+�+�+�+rGc
�D�t|t��rt|}nHt|t��rt|}n%td|�d|�dt
|�������|�|��s|dkrdnd}td|�d|�����dS)	Nz
Header part (z) from z# must be of type str or bytes, not rr�r�zTInvalid leading whitespace, reserved character(s), or return character(s) in header z: )rVrrrr
r �typer=)r��header_part�header_validator_index�	validator�header_kinds     rDr�r�s����+�s�#�#�
�*�+A�B�	�	�	�K��	'�	'�
�+�,B�C�	�	��
E�K�
E�
E�&�
E�
E�15�k�1B�1B�
E�
E�
�
�	
�
�?�?�;�'�'�
� 6�!� ;�H�f�f����
E�&1�
E�
E�5@�
E�
E�
�
�	
�
�
rGc��t|��\}}}}}}|s||}}|�dd��d}t|||||df��S)zW
    Given a url remove the fragment and the authentication part.

    :rtype: str
    ryrr�r)r�rsplitr)rwrJrzrrr�r}r~s       rD�
urldefragauthr�sb��5=�S�M�M�1�F�F�D�&�%���$��V���
�]�]�3��
"�
"�2�
&�F��v�v�t�V�U�B�?�@�@�@rGc���t|jdd��}|�Jt|jt��r0	||j��dS#t
$rt
d���wxYwt
d���)zfMove file pointer back to its recorded starting position
    so it can be read again on redirect.
    rTNz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)r��bodyrV�_body_positionrr7r")�prepared_request�	body_seeks  rD�rewind_bodyr�/s����(�-�v�t�<�<�I��
S���'��"�"�
S�	��I�&�5�6�6�6�6�6���	�	�	�'�M���
�	����
$�$Q�R�R�Rs�A�A )Fr4)T)rY)k�__doc__r��
contextlibr^rXr<rr�sysr�r\r��collectionsr�pip._vendor.urllib3.utilrrrrr	�_internal_utilsr
rrr
�compatrrrrrrrrr�rrrrrrr�cookiesr�
exceptionsrr r!r"�
structuresr#rq�where�DEFAULT_CA_BUNDLE_PATH�
DEFAULT_PORTSr�r9r_�platformrErLrerr�r��contextmanagerr�r�r�r�r�r�r�r�r�r�r�r�r�r��	frozensetrr
rr rr(r,r1rDrGrPrXr[r`rfrWrqrrrsrwrr�r�r�r�r�rirGrD�<module>r�s������
�
�
�����	�	�	�	�	�	�	�	�	�	�	�	�
�
�
�
�
�
�
�
�
�
�
�
�������������#�#�#�#�#�#�<�<�<�<�<�<�<�<�������$�$�$�$�$�$�������������������������������:�9�9�9�9�9�������������������)�(�(�(�(�(�������������,�+�+�+�+�+�"��$�������c�*�*�
��)�)��B�H�W�l�l�4�8�8�8�9J�K�L�L����
�<�7��2/�$�$�$�L	/�	/�	/�
�
�
�D3�D3�D3�N)
�)
�)
�)
�X&�&�&�"�"�"�J��	�	���	����6���<���@���F����2���0�0�0����2%�%�%�2���2���"���$�$�$�P��M����
���05�5�5�,5�5�5�5�5�5�������0��1�1���1�*:�:�:�z	�	�	�	����4����6#�#�#�#����"�"�"�L	�
�
�g����	����	�������@C�C�C�:
�
�
� ,�,�,�
�
�
�&A�A�A�"S�S�S�S�SrG