B

L��g�v�@sl
dZd
dl
Z
d
dlZd
dlZd
dlmZ
d
dlmZ
ddlm	Z	
ddl
mZ
ddlm
Z

dd	lmZmZmZmZ
dd
lmZmZmZmZ
ddlmZmZmZmZ
ddlmZmZ
dd
l m!Z!m"Z"m#Z#m$Z$
ddl%m&Z&
ddl'm(Z(
ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3
ej4dk�
r$ej5Z6nejZ6ef
dd�
Z7ef
dd�
Z8Gdd�d�Z9Gdd�de9�Z:dd�Z;dS)z�
requests.sessions
~~~~~~~~~~~~~~~~~

This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
�N)
�OrderedDict)
�	timedelta�
)
�to_native_string)
�HTTPAdapter)
�_basic_auth_str)�Mapping�	cookielib�urljoin�urlparse)�RequestsCookieJar�cookiejar_from_dict�extract_cookies_to_jar�
merge_cookies)�ChunkedEncodingError�ContentDecodingError�
InvalidSchema�TooManyRedirects)�
default_hooks�
dispatch_hook)�DEFAULT_REDIRECT_LIMIT�REDIRECT_STATI�PreparedRequest�Request)
�codes)
�CaseInsensitiveDict)
�
DEFAULT_PORTS�default_headers�get_auth_from_url�get_environ_proxies�get_netrc_auth�requote_uri�resolve_proxies�rewind_body�should_bypass_proxies�to_key_val_list�win32cCst|
d
kr|S|d
kr|
St|
t
�r,t|t
�s0|S|t|
�
�
}|�t|�
�

dd�|��D�
}x|D]
}||=qbW|S)z�Determines appropriate setting for a given request, taking into account
    the explicit setting on that request, and the setting in the session. If a
    setting is a dictionary, they will be merged together using `dict_class`
    Nc
Ssg|]\}
}|dkr|
�qS)
N�)�.0�
k�
vr'r'�A/tmp/pip-unpacked-wheel-hv55ucu3/pip/_vendor/requests/sessions.py�
<listcomp>Tsz!merge_setting.<locals>.<listcomp>)�
isinstancerr%�update�items)�request_setting�session_setting�
dict_class�merged_setting�	none_keys�keyr'r'r+�
merge_setting=s






r6cCs@|
d
ks|
�d�
gkr|S|d
ks0|�d�
gkr4|
St
||
|�S)z�Properly merges both requests and session hooks.

    This is necessary because when request_hooks == {'response': []}, the
    merge breaks Session hooks entirely.
    N�response)�getr6)�
request_hooks�
session_hooksr2r'r'r+�merge_hooks[s


r;c@s>eZ
dZd
d�Zdd�Zddd	�
Zd
d�Zdd
�Zdd�ZdS)�SessionRedirectMixincCs(|
jr$|
j
d
}|�d�
}t|d�SdS)z7Receives a Response. Returns a redirect URI or ``None``�location�latin1�utf8N)�is_redirect�headers�encoder)�self�respr=r'r'r+�get_redirect_targetks






z(SessionRedirectMixin.get_redirect_targetcCs�t|
�
}t|�
}|j
|j
kr d
S|jdkrL|jdkrL|jdkrL|jdkrLdS|j|jk}|j|jk}t�|jd�df}|s�|j|kr�|j|kr�dS|p�|S)zFDecide whether Authorization header should be removed when redirectingT�http)�PN�https)i�
NFN)r�hostname�scheme�portrr8)rC�old_url�new_url�
old_parsed�
new_parsed�changed_port�changed_scheme�default_portr'r'r+�should_strip_auths"















z&SessionRedirectMixin.should_strip_authFNTc	
ksTg}
|�|
�
}t
|j�
j}�x2|�rN|��}
|
�|
�

|
d
d�|
_y
|
j
Wn(tt	t
fk
rv


|
jjdd�

YnXt
|
j�
|jkr�td|j�d�|
d��
|
��
|�d�
r�t
|
j�
}d	�t|j�
|g�
}t
|�
}|jd
kr�|r�|j|d�
}n|jr�|j}|��}|j�
s t|
jt|�
�}nt|�
}t|�
|
_|�|
|
�
|
jtjtjfk�
rzd}x|D]}|
j� |d�
�
q\Wd|
_!|
j}|� d
d�
t"|
j#||
j�
t$|
j#|j%�
|
�&|
j#�

|�'|
|�}|�(|
|
�
|
j)dk	�
o�d|k�
p�d|k}|�
r�t*|
�

|
}|�r|V
q|j+|f
|||||dd�|	��
}
t"|j%|
|
j�
|�|
�
}|
V
qWdS)zBReceives a Response. Returns a generator of Responses or Requests.rNF)
�decode_contentz	Exceeded z redirects.)
r7z//�
:�)
�fragment)zContent-LengthzContent-TypezTransfer-Encoding�CookiezContent-LengthzTransfer-Encoding)�stream�timeout�verify�cert�proxies�allow_redirects),rEr�urlrW�copy�append�history�contentrr�RuntimeError�raw�read�len�
max_redirectsr�close�
startswith�joinrrJ�_replace�geturl�netlocr
r!�rebuild_method�status_coder�temporary_redirect�permanent_redirectrA�pop�bodyr�_cookiesr�cookies�prepare_cookies�rebuild_proxies�rebuild_auth�_body_positionr#�send)rCrD�reqrYrZr[r\r]�yield_requests�adapter_kwargs�histr_�previous_fragment�prepared_request�parsed_rurl�parsed�purged_headers�headerrA�
rewindabler'r'r+�resolve_redirects�s|














































z&SessionRedirectMixin.resolve_redirectscCsR|
j}|
j
}d
|kr*|�|jj
|�r*|d
=|jr8t|�
nd}|dk	rN|
�|�

dS)z�When being redirected we may want to strip authentication from the
        request to avoid leaking credentials. This method intelligently removes
        and reapplies authentication where possible to avoid credential loss.
        �
AuthorizationN)rAr_rS�request�	trust_envr �prepare_auth)rCr�r7rAr_�new_authr'r'r+ry
s



z!SessionRedirectMixin.rebuild_authcCs�|
j}t
|
j�
j}t|
||j�}d
|kr.|d
=yt||�
\}}Wntk
r^


d\}}YnX|�d�
s�|r�|r�t	||�|d
<|S)a�
This method re-evaluates the proxy configuration by considering the
        environment variables. If we are redirected to a URL covered by
        NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
        proxy keys for this URL (in case they were stripped by a previous
        redirect).

        This method also replaces the Proxy-Authorization header where
        necessary.

        :rtype: dict
        zProxy-Authorization)NNrH)
rArr_rJr"r�r�KeyErrorrjr)rCr�r]rArJ�new_proxies�username�passwordr'r'r+rx/
s






z$SessionRedirectMixin.rebuild_proxiescCsX|
j}|j
tjkr|d
krd}|j
tjkr6|d
kr6d}|j
tjkrN|dkrNd}||
_dS)z�When being redirected we may want to change the method of the request
        based on certain specs or browser behavior.
        �HEAD�GET�POSTN)�methodrpr�	see_other�found�moved)rCr�r7r�r'r'r+roN
s


z#SessionRedirectMixin.rebuild_method)FNTNNF)	�__name__�
__module__�__qualname__rErSr�ryrxror'r'r'r+r<js
$





sr<c@s�eZ
dZd
Zdddddddd	d
ddd
gZdd�Zdd�Zdd�Zdd�Zd6dd�
Z	dd�Z
dd�Zdd�Zd7d d!�
Z
d8d"d#�
Zd9d$d%�
Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�ZdS):�Sessiona�
A Requests session.

    Provides cookie persistence, connection-pooling, and configuration.

    Basic Usage::

      >>> import requests
      >>> s = requests.Session()
      >>> s.get('https://httpbin.org/get')
      <Response [200]>

    Or as a context manager::

      >>> with requests.Session() as s:
      ...     s.get('https://httpbin.org/get')
      <Response [200]>
    rArv�authr]�hooks�paramsr[r\�adaptersrYr�rhc

Csrt�|_
d|_i|_t�|_i|_d
|_d|_d|_	t
|_d|_t
i�
|_t�|_|�dt��
|�dt��
dS)NFTzhttps://zhttp://)rrAr�r]rr�r�rYr[r\rrhr�r
rvrr��mountr)
rCr'r'r+�__init__�
s



zSession.__init__c


Cs|S)
Nr')
rCr'r'r+�	__enter__�
s
zSession.__enter__c
Gs|��
dS)
N)
ri)rC�argsr'r'r+�__exit__�
s
zSession.__exit__c
Cs�|
jpi}t
|tj�st|�
}ttt�|j�|�}|
j}|jrR|sR|jsRt	|
j
�
}t�}|j|
j
��|
j
|
j|
j|
jt|
j|jtd
�t|
j|j�t||j�|t|
j|j�d�

|S)a�
Constructs a :class:`PreparedRequest <PreparedRequest>` for
        transmission and returns it. The :class:`PreparedRequest` has settings
        merged from the :class:`Request <Request>` instance and those of the
        :class:`Session`.

        :param request: :class:`Request` instance to prepare with this
            session's settings.
        :rtype: requests.PreparedRequest
        )
r2)
r�r_�files�data�jsonrAr�r�rvr�)rvr-r	�	CookieJarr
rrr�r�r r_r�preparer��upperr�r�r�r6rArr�r;r�)rCr�rv�merged_cookiesr��
pr'r'r+�prepare_request�
s,


















zSession.prepare_requestNTcCstt|
�
�||||pi||pi|||d
�
}|�|�
}|p8i}|�|j||
||�}|	|
d�}|�|�

|j|f
|�
}|S)aw	Constructs a :class:`Request <Request>`, prepares it and sends it.
        Returns :class:`Response <Response>` object.

        :param method: method for the new :class:`Request` object.
        :param url: URL for the new :class:`Request` object.
        :param params: (optional) Dictionary or bytes to be sent in the query
            string for the :class:`Request`.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param json: (optional) json to send in the body of the
            :class:`Request`.
        :param headers: (optional) Dictionary of HTTP Headers to send with the
            :class:`Request`.
        :param cookies: (optional) Dict or CookieJar object to send with the
            :class:`Request`.
        :param files: (optional) Dictionary of ``'filename': file-like-objects``
            for multipart encoding upload.
        :param auth: (optional) Auth tuple or callable to enable
            Basic/Digest/Custom HTTP Auth.
        :param timeout: (optional) How long to wait for the server to send
            data before giving up, as a float, or a :ref:`(connect timeout,
            read timeout) <timeouts>` tuple.
        :type timeout: float or tuple
        :param allow_redirects: (optional) Set to True by default.
        :type allow_redirects: bool
        :param proxies: (optional) Dictionary mapping protocol or protocol and
            hostname to the URL of the proxy.
        :param stream: (optional) whether to immediately download the response
            content. Defaults to ``False``.
        :param verify: (optional) Either a boolean, in which case it controls whether we verify
            the server's TLS certificate, or a string, in which case it must be a path
            to a CA bundle to use. Defaults to ``True``. When set to
            ``False``, requests will accept any TLS certificate presented by
            the server, and will ignore hostname mismatches and/or expired
            certificates, which will make your application vulnerable to
            man-in-the-middle (MitM) attacks. Setting verify to ``False``
            may be useful during local development or testing.
        :param cert: (optional) if String, path to ssl client cert file (.pem).
            If Tuple, ('cert', 'key') pair.
        :rtype: requests.Response
        )
r�r_rAr�r�r�r�r�rvr�)rZr^)rr�r��merge_environment_settingsr_r.r{)rCr�r_r�r�rArvr�r�rZr^r]r�rYr[r\r�r|�prep�settings�send_kwargsrDr'r'r+r��
s(=














zSession.requestcKs|�d
d�
|j
d|
f|�
S)z�Sends a GET request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        r^Tr�)�
setdefaultr�)rCr_�kwargsr'r'r+r8Qs
zSession.getcKs|�d
d�
|j
d|
f|�
S)z�Sends a OPTIONS request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        r^T�OPTIONS)r�r�)rCr_r�r'r'r+�options\s
zSession.optionscKs|�d
d�
|j
d|
f|�
S)z�Sends a HEAD request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        r^Fr�)r�r�)rCr_r�r'r'r+�headgs
zSession.headcKs|jd
|
f||d�|��
S)a�
Sends a POST request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param json: (optional) json to send in the body of the :class:`Request`.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        r�)r�r�)
r�)rCr_r�r�r�r'r'r+�postrszSession.postcKs|jd
|
fd|i
|��
S)au
Sends a PUT request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        �PUTr�)
r�)rCr_r�r�r'r'r+�puts
zSession.putcKs|jd
|
fd|i
|��
S)aw
Sends a PATCH request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        �PATCHr�)
r�)rCr_r�r�r'r'r+�patch�s
z
Session.patchcKs|jd
|
f|�
S)z�Sends a DELETE request. Returns :class:`Response` object.

        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        �DELETE)
r�)rCr_r�r'r'r+�delete�szSession.deletec
Ks�
|�d
|j
�
|�d|j�
|�d|j�
d|krFt|
|j|j�|d<t|
t�rXt	d�
�
|�
dd�}|�d
�
}|
j}|j
|
jd�
}t�}|j|
f
|�
}t�|}	t|	d	�
|_td
||f|�
}|jr�x |jD]}
t|j|
j|
j�
q�Wt|j|
|j�
|�
r|j||
f|�
}dd�|D�
}ng}|�
r>|�d
|�
|�
�}||_|�
s~y"t|j||
fddi
|��
�
|_Wntk
�
r|


YnX|�
s�|j
|S)zISend a given PreparedRequest.

        :rtype: requests.Response
        rYr[r\r]z#You can only send PreparedRequests.r^T)
r_)
�secondsr7c
Ssg|]}
|
�qSr'r')r(rDr'r'r+r,�sz Session.send.<locals>.<listcomp>r
r})r�rYr[r\r"r]r�r-r�
ValueErrorrsr8r��get_adapterr_�preferred_clockr{r�elapsedrrbrrvr�rer��insert�next�_next�
StopIterationrc)
rCr�r�r^rYr��adapter�start�
rr�rD�genrbr'r'r+r{�sJ
















 

zSession.sendc
Cs�|jrv|d
k	r|�
d�
nd
}t|
|d�}x |��D]\}}	|�||	�
q2W|dksZ|d
krvtj�
d�
pttj�
d�
pt|}t||j�}t||j	�}t||j
�}t||j�}||||d�S)z^
        Check the environment and merge it with some settings.

        :rtype: dict
        N�no_proxy)
r�T�REQUESTS_CA_BUNDLE�CURL_CA_BUNDLE)r]rYr[r\)r�r8rr/r��os�environr6r]rYr[r\)
rCr_r]rYr[r\r��env_proxiesr)r*r'r'r+r��s







z"Session.merge_environment_settingscCs@x,|j�
�D]\}}|
���|���
r|SqWtd
|
���
�
dS)z~
        Returns the appropriate connection adapter for the given URL.

        :rtype: requests.adapters.BaseAdapter
        z&No connection adapters were found for N)r�r/�lowerrjr)rCr_�prefixr�r'r'r+r�s
zSession.get_adapterc
Cs x|j�
�D]}
|
��
qWd
S)z+Closes all adapters and as such the sessionN)r��valuesri)rCr*r'r'r+ris
z
Session.closecsB||j�<�f
d
d�|jD�
}x|D]}|j�
|�
|j|<q$WdS)zwRegisters a connection adapter to a prefix.

        Adapters are sorted in descending order by prefix length.
        c
s g|]}
t|
�
t��
kr|
�qSr')
rg)r(r))
r�r'r+r,'sz!Session.mount.<locals>.<listcomp>N)r�rs)rCr�r��keys_to_mover5r')
r�r+r�!s



z
Session.mountc
s�f
d
d��jD�
}
|
S)Nc
si|]}
t�|
d�|
�qS)
N)
�getattr)r(�attr)
rCr'r+�
<dictcomp>-sz(Session.__getstate__.<locals>.<dictcomp>)
�	__attrs__)rC�stater')
rCr+�__getstate__,s

zSession.__getstate__cCs&x |
��D]\}}t
|||�
q
WdS)
N)r/�setattr)rCr�r��valuer'r'r+�__setstate__0s

zSession.__setstate__)NNNNNNNTNNNNNN)NN)
N)
N)r�r�r��__doc__r�r�r�r�r�r�r8r�r�r�r�r�r�r{r�r�rir�r�r�r'r'r'r+r�e
sZ










>/













J



Nr�c
Cst�S)
aZ

    Returns a :class:`Session` for context-management.

    .. deprecated:: 1.0.0

        This method has been deprecated since version 1.0.0 and is only kept for
        backwards compatibility. New code should use :class:`~requests.sessions.Session`
        to create a session. This may be removed at a future date.

    :rtype: Session
    )
r�r'r'r'r+�session5sr�)<r�r��sys�time�collectionsr�datetimer�_internal_utilsrr�rr�r�compatrr	r
rrvrr
rr�
exceptionsrrrrr�rr�modelsrrrr�status_codesr�
structuresr�utilsrrrrr r!r"r#r$r%�platform�perf_counterr�r6r;r<r�r�r'r'r'r+�<module>s8










0
|S