U

�Yh+G�@s
dd
lm
Z

ddlZddlZddlZddlmZmZ
ddlm	Z	m
Z

ddlmZ
ddlm
Z
mZmZ
ddlZddlmZ
dd	lmZ
dd
lmZ
ddlmZ
dd
dgZe�e�
ZdZdZe�de�Z dd�Z!e�"e!e �e�"e!e �d�Z#e	e
d�Z$Gdd�de�Z%Gdd
�d
e%�Z&dd�Z'dS)�)
�absolute_importN�
)�HTTPHeaderDict�RecentlyUsedContainer)�HTTPConnectionPool�HTTPSConnectionPool)
�port_by_scheme)�LocationValueError�
MaxRetryError�ProxySchemeUnknown)
�urljoin)
�RequestMethods)
�	parse_url)
�Retry�PoolManager�ProxyManager�proxy_from_url)Zkey_fileZ	cert_fileZ	cert_reqsZca_certsZssl_versionZca_cert_dirZssl_contextZkey_password)Z
key_schemeZkey_hostZkey_portZkey_timeoutZkey_retriesZ
key_strictZ	key_blockZkey_source_addressZkey_key_fileZkey_key_passwordZ
key_cert_fileZ
key_cert_reqsZkey_ca_certsZkey_ssl_versionZkey_ca_cert_dirZkey_ssl_contextZkey_maxsizeZkey_headersZ
key__proxyZkey__proxy_headersZkey_socket_optionsZkey__socks_optionsZkey_assert_hostnameZkey_assert_fingerprintZkey_server_hostname�PoolKeycCs�|
��}|d
�
�|d
<|d�
�|d<dD],}||kr,||dk	r,t||���
||<q,|�d�
}|dk	rxt|�
|d<t|���
D]}|�|�
|d|<q�|j	D]}||kr�d||<q�|f|�
S)a�
    Create a pool key out of a request context dictionary.

    According to RFC 3986, both the scheme and host are case-insensitive.
    Therefore, this function normalizes both before constructing the pool
    key for an HTTPS request. If you wish to change this behaviour, provide
    alternate callables to ``key_fn_by_scheme``.

    :param key_class:
        The class to use when constructing the key. This should be a namedtuple
        with the ``scheme`` and ``host`` keys at a minimum.
    :type  key_class: namedtuple
    :param request_context:
        A dictionary-like object that contain the context for a request.
    :type  request_context: dict

    :return: A namedtuple that can be used as a connection pool key.
    :rtype:  PoolKey
    �scheme�host)�headers�_proxy_headersZ_socks_optionsNZsocket_optionsZkey_)
�copy�lower�	frozenset�items�get�tuple�list�keys�pop�_fields)Z	key_class�request_context�context�keyZsocket_optsZfield�r%�5/usr/lib/python3/dist-packages/urllib3/poolmanager.py�_default_key_normalizerDs











r'��http�httpsc@sxeZ
dZd
ZdZddd�
Zdd�Zdd	�Zdd
d�
Zdd
�Z	ddd�
Z
dd�Zddd�
Zd dd�
Z
dd�Zd!dd�
ZdS)"ra$
    Allows for arbitrary requests while transparently keeping track of
    necessary connection pools for you.

    :param num_pools:
        Number of connection pools to cache before discarding the least
        recently used pool.

    :param headers:
        Headers to include with all requests, unless other headers are given
        explicitly.

    :param \**connection_pool_kw:
        Additional parameters are used to create fresh
        :class:`urllib3.connectionpool.ConnectionPool` instances.

    Example::

        >>> manager = PoolManager(num_pools=2)
        >>> r = manager.request('GET', 'http://google.com/')
        >>> r = manager.request('GET', 'http://google.com/mail')
        >>> r = manager.request('GET', 'http://yahoo.com/')
        >>> len(manager.pools)
        2

    N�
cKs~t�
||�
d
|krR|d
}t|t�sR|dk	}tj|dd�}||_|��}||d
<||_t|
dd�d�|_	t
|_
t��|_dS)N�retriesF�
�redirectc

Ss|��S�
N)
�close)
�
pr%r%r&�<lambda>��z&PoolManager.__init__.<locals>.<lambda>)
Zdispose_func)r
�__init__�
isinstancer�from_int�raise_on_redirectr�connection_pool_kwr�pools�pool_classes_by_scheme�key_fn_by_scheme)�self�	num_poolsrr8r,r7r%r%r&r4�s




	






zPoolManager.__init__c


Cs|Sr/r%�
r<r%r%r&�	__enter__�s
zPoolManager.__enter__cCs|��
d
S)NF)
�clear)r<�exc_typeZexc_valZexc_tbr%r%r&�__exit__�s
zPoolManager.__exit__cCs^|j|
}|d
kr|j
��}dD]}|�|d
�
q |
dkrPtD]}|�|d
�
q>|||f|�
S)a�

        Create a new :class:`ConnectionPool` based on host, port, scheme, and
        any additional pool keyword arguments.

        If ``request_context`` is provided, it is provided as keyword arguments
        to the pool class used. This method is used to actually create the
        connection pools handed out by :meth:`connection_from_url` and
        companion methods. It is intended to be overridden for customization.
        N)rr�portr))r:r8rr �SSL_KEYWORDS)r<rrrCr"Zpool_clsr$�kwr%r%r&�	_new_pool�s







zPoolManager._new_poolc

Cs|j�
�
d
S)z�
        Empty our store of pools and direct them all to close.

        This will not affect in-flight connections, but they will not be
        re-used after completion.
        N)r9r@r>r%r%r&r@�szPoolManager.clearr)cCsT|
std
�
�
|�
|�
}|pd|d<|s:t�|d��d�}||d<|
|d<|�|�
S)a�

        Get a :class:`ConnectionPool` based on the host, port, and scheme.

        If ``port`` isn't given, it will be derived from the ``scheme`` using
        ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is
        provided, it is merged with the instance's ``connection_pool_kw``
        variable and used to create the new connection pool, if one is
        needed.
        zNo host specified.r)r�PrCr)r	�_merge_pool_kwargsrrr�connection_from_context)r<rrCr�pool_kwargsr"r%r%r&�connection_from_host�s






z PoolManager.connection_from_hostcCs,|
d
��}|j
|}||
�
}|j||
d�S)z�
        Get a :class:`ConnectionPool` based on the request context.

        ``request_context`` must at least contain the ``scheme`` key and its
        value must be a key in ``key_fn_by_scheme`` instance variable.
        r�
r")rr;�connection_from_pool_key)r<r"rZpool_key_constructor�pool_keyr%r%r&rI�s


z#PoolManager.connection_from_contextc
Csl|jj
�Z
|j�|
�
}|r*|W5QR�S|d
}|d}|d}|j||||d�}||j|
<W5QRX|S)z�
        Get a :class:`ConnectionPool` based on the provided pool key.

        ``pool_key`` should be a namedtuple that only contains immutable
        objects. At a minimum it must have the ``scheme``, ``host``, and
        ``port`` fields.
        rrrCrL)r9�lockrrF)r<rNr"ZpoolrrrCr%r%r&rM	
s






z$PoolManager.connection_from_pool_keycCs t|
�
}|j
|j|j|j|d
�S)a�

        Similar to :func:`urllib3.connectionpool.connection_from_url`.

        If ``pool_kwargs`` is not provided and a new pool needs to be
        constructed, ``self.connection_pool_kw`` is used to initialize
        the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs``
        is provided, it is used instead. Note that if a new pool does not
        need to be created for the request, the provided ``pool_kwargs`` are
        not used.
        )rCrrJ)rrKrrCr)r<�urlrJ�
ur%r%r&�connection_from_url!
s

�zPoolManager.connection_from_urlc	CsV|j�
�}|
rR|
��D]:\}}|d
krHz
||=WqPtk
rD


YqPXq|||<q|S)a

        Merge a dictionary of override values for self.connection_pool_kw.

        This does not modify self.connection_pool_kw and returns a new dict.
        Any keys in the override dictionary with a value of ``None`` are
        removed from the merged dictionary.
        N)r8rr�KeyError)r<�overrideZbase_pool_kwargsr$�valuer%r%r&rH1
s










zPoolManager._merge_pool_kwargsTcKs�
t|�
}|j
|j|j|jd
�}d|d<d|d<d|krD|j��|d<|jdk	rj|jdkrj|j|
|f|�
}n|j|
|j	f|�
}|o�|�
�}|s�|St||�}|jdkr�d	}
d|d
<t
|d�
��|d<|�d|j�}	t|	t�s�tj|	|d�}	|	j�
r<|�|�
�
s<tt�|d�
�
}
|
D]&}|��|	jk�
r|d�|d�
�
qz|	j|
|||d
�}	Wn$tk
�
rv


|	j�
rn�|YSX|	|d<||d<t�d||�
|j|
|f|�
S)a]

        Same as :meth:`urllib3.connectionpool.HTTPConnectionPool.urlopen`
        with custom cross-host redirect logic and only sends the request-uri
        portion of the ``url``.

        The given ``url`` parameter must be absolute, such that an appropriate
        :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.
        )rCrFZassert_same_hostr.rNr)i/
ZGETZbodyr,r-)�responseZ_poolzRedirecting %s -> %s) rrKrrCrrr�proxy�urlopenZrequest_uriZget_redirect_locationrZstatusrZ_prepare_for_method_changerr,r5rr6Zremove_headers_on_redirectZis_same_hostr�sixZiterkeysrr Z	incrementr
r7�log�info)r<�methodrPr.rErQZconnrVZredirect_locationr,r�headerr%r%r&rXE
sJ	












�










zPoolManager.urlopen)r+N)
N)Nr)N)
N)
N)
T)�__name__�
__module__�__qualname__�__doc__rWr4r?rBrFr@rKrIrMrRrHrXr%r%r%r&r�s


	


csHeZ
dZd
Zd�f
dd�	Zd�f
dd�	Zdd	d
�
Zd�f
dd
�	Z�ZS)rax
    Behaves just like :class:`PoolManager`, but sends all requests through
    the defined proxy, using the CONNECT method for HTTPS URLs.

    :param proxy_url:
        The URL of the proxy to be used.

    :param proxy_headers:
        A dictionary containing headers that will be sent to the proxy. In case
        of HTTP they are being sent with each request, while in the
        HTTPS/CONNECT case they are sent only once. Could be used for proxy
        authentication.

    Example:
        >>> proxy = urllib3.ProxyManager('http://localhost:3128/')
        >>> r1 = proxy.request('GET', 'http://google.com/')
        >>> r2 = proxy.request('GET', 'http://httpbin.org/')
        >>> len(proxy.pools)
        1
        >>> r3 = proxy.request('GET', 'https://httpbin.org/')
        >>> r4 = proxy.request('GET', 'https://twitter.com/')
        >>> len(proxy.pools)
        3

    r+Ncs�t|
t
�rd
|
j|
j|
jf}
t|
�
}|jsFt�|jd�}|j|d�
}|jdkrZt	|j�
�
||_
|pfi|_|j
|d<|j|d<tt
|�j||f|�

dS)Nz
%s://%s:%irG)
rCr(�_proxyr)r5rrrrCrrr�_replacerrW�
proxy_headers�superrr4)r<�	proxy_urlr=rrdr8rWrC�
�	__class__r%r&r4�
s"	




�










zProxyManager.__init__r)csD|d
kr tt
|�j|
|||d�Stt
|�j|jj|jj|jj|d�S)Nr*)
rJ)rerrKrWrrCr)r<rrCrrJrgr%r&rK�
s



�

�z!ProxyManager.connection_from_hostcCs0d
di
}t|
�
j
}|r||d<|r,|�|�

|S)z�
        Sets headers needed by proxies: specifically, the Accept and Host
        headers. Only sets headers not provided by the user.
        ZAcceptz*/*ZHost)r�netloc�update)r<rPrZheaders_rir%r%r&�_set_proxy_headers�
s





zProxyManager._set_proxy_headersTcsNt|�
}|j
d
kr0|�d|j�}|�||�|d<tt|�j|
|fd|i
|��
S)z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.r)rr.)rrrrrkrerrX)r<r\rPr.rErQrrgr%r&rX�
s


zProxyManager.urlopen)r+NN)Nr)N)
N)
T)	r^r_r`rar4rKrkrX�
__classcell__r%r%rgr&r�
s


�

c
Kstfd
|i
|
��
S)Nrf)
r)rPrEr%r%r&r�
s
)(Z
__future__r�collections�	functoolsZlogging�_collectionsrrZconnectionpoolrrr�
exceptionsr	r
rrYZsix.moves.urllib.parserZrequestr
Zutil.urlrZ
util.retryr�__all__Z	getLoggerr^rZrDZ_key_fields�
namedtuplerr'�partialr;r:rrrr%r%r%r&�<module>
s6













6


�
a