Your IP : 216.73.216.213
[�A � @ s� d d l m Z d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z d d l m
Z
d d l m Z m
Z
m Z d d l m Z d d l m Z d d
l m Z d d l m Z d d
d g Z e j e � Z d5 Z d6 Z e j d- e � Z d. d/ � Z d0 e j e e � d1 e j e e � i Z! d0 e d1 e i Z" Gd2 d � d e � Z# Gd3 d
� d
e# � Z$ d4 d � Z% d S)7� )�absolute_importN� )�RecentlyUsedContainer)�HTTPConnectionPool�HTTPSConnectionPool)�port_by_scheme)�LocationValueError�
MaxRetryError�ProxySchemeUnknown)�urljoin)�RequestMethods)� parse_url)�Retry� PoolManager� ProxyManager�proxy_from_url�key_file� cert_file� cert_reqs�ca_certs� ssl_version� ca_cert_dir� ssl_context�
key_scheme�key_host�key_port� key_timeout� key_retries�
key_strict� key_block�key_source_address� key_key_file�
key_cert_file�
key_cert_reqs� key_ca_certs�key_ssl_version�key_ca_cert_dir�key_ssl_context� key_maxsize� key_headers�
key__proxy�key__proxy_headers�key_socket_options�key__socks_options�key_assert_hostname�key_assert_fingerprint�PoolKeyc C s | j � } | d j � | d <| d j � | d <xD d D]< } | | k r; | | d k r; t | | j � � | | <q; W| j d � } | d k r� t | � | d <x1 t | j � � D] } | j | � | d | <q� Wx' | j D] } | | k r� d | | <q� W| | � 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_headers�_socks_optionsNZsocket_optionsZkey_)r3 r4 r5 )
�copy�lower� frozenset�items�get�tuple�list�keys�pop�_fields)Z key_class�request_context�context�keyZ socket_opts�field� rD �D/opt/alt/python35/lib/python3.5/site-packages/urllib3/poolmanager.py�_default_key_normalizer9 s
rF �http�httpsc @ s� e Z d Z d Z d Z d d d d � Z d d � Z d d � Z d d
d � Z d d
� Z d d d d d � Z
d d � Z d d d � Z d d d � Z
d d � Z d d d � Z d S) r a$
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�
c K sP t j | | � | | _ t | d d d � �| _ t | _ t j � | _ d S)NZ dispose_funcc S s
| j � S)N)�close)�prD rD rE �<lambda>� s z&PoolManager.__init__.<locals>.<lambda>)r �__init__�connection_pool_kwr �pools�pool_classes_by_scheme�key_fn_by_schemer6 )�self� num_poolsr3 rN rD rD rE rM � s zPoolManager.__init__c C s | S)NrD )rR rD rD rE � __enter__� s zPoolManager.__enter__c C s | j � d S)NF)�clear)rR �exc_typeZexc_val�exc_tbrD rD rE �__exit__� s
zPoolManager.__exit__c C s� | j | } | d k r( | j j � } x d D] } | j | d � q/ W| d k rv x t D] } | j | d � q\ W| | | | � 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.
Nr1 r2 �portrG )r1 r2 rY )rP rN r6 r> � SSL_KEYWORDS)rR r1 r2 rY r@ Zpool_clsrB �kwrD rD rE � _new_pool� s
zPoolManager._new_poolc C s | j 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)rO rU )rR rD rD rE rU � s zPoolManager.clearrG c C st | s t d � � | j | � } | p* d | d <| sS t j | d j � d � } | | d <| | d <| j | � 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.rG r1 �P rY r2 )r �_merge_pool_kwargsr r: r7 �connection_from_context)rR r2 rY r1 � pool_kwargsr@ rD rD rE �connection_from_host� s
z PoolManager.connection_from_hostc C s< | d j � } | 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.
r1 r@ )r7 rQ �connection_from_pool_key)rR r@ r1 Zpool_key_constructor�pool_keyrD rD rE r_ � s
z#PoolManager.connection_from_contextc
C sz | j j �g | j j | � } | r) | S| d } | d } | d } | j | | | d | �} | | j | <Wd QRX| 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.
r1 r2 rY r@ N)rO �lockr: r\ )rR rc r@ �poolr1 r2 rY rD rD rE rb � s
z$PoolManager.connection_from_pool_keyc C s4 t | � } | j | j d | j d | 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.
rY r1 r` )r
ra r2 rY r1 )rR �urlr` �urD rD rE �connection_from_url
s !z PoolManager.connection_from_urlc C so | j j � } | rk xS | j � D]E \ } } | d k r] y | | =Wqg t k
rY Yqg Xq" | | | <q" W| 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)rN r6 r9 �KeyError)rR �overrideZbase_pool_kwargsrB �valuerD rD rE r^ s
z PoolManager._merge_pool_kwargsTc
K s� t | � } | j | j d | j d | j �} d | d <d | d <d | k rc | j j � | d <| j d k r� | j d k r� | j | | | � } n | j | | j | � } | o� | j
� } | s� | St | | � } | j d k r� d
} | j
d � } t | t � s$t j | d | �} | j re| j | � rex% | j D] }
| d j |
d � qGWy" | j | | d | d
| �} Wn" t k
r�| j r�� | SYn X| | d <| | d <t j d | | � | j | | | � 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.
rY r1 FZassert_same_host�redirectr3 NrG i/ ZGET�retries�responseZ_poolzRedirecting %s -> %s)r
ra r2 rY r1 r3 r6 �proxy�urlopenZ request_uriZget_redirect_locationr �statusr: �
isinstancer Zfrom_intZremove_headers_on_redirectZ is_same_hostr> Z incrementr Zraise_on_redirect�log�info) rR �methodrf rl r[ rg Zconnrn Zredirect_locationrm �headerrD rD rE rp - s@ $
"
zPoolManager.urlopen)�__name__�
__module__� __qualname__�__doc__ro rM rT rX r\ rU ra r_ rb rh r^ rp rD rD rD rE r y s
c sp e Z d Z d Z d d d � f d d � Z d d d � f d d � Z d d d
� Z d � f d d
� Z � S)r ax
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
rI Nc s� t | t � r+ d | j | j | j f } t | � } | j sg t j | j d � } | j d | � } | j d k r� t | j � � | | _
| p� i | _ | j
| d <| j | d <t t
| � j | | | � d S) Nz
%s://%s:%ir] rY rG rH �_proxyr4 )rG rH )rr r r1 r2 rY r
r r: �_replacer
ro �
proxy_headers�superr rM )rR � proxy_urlrS r3 r} rN ro rY )� __class__rD rE rM � s
zProxyManager.__init__rG c sb | d k r. t t | � j | | | d | �St t | � j | j j | j j | j j d | �S)NrH r` )r~ r ra ro r2 rY r1 )rR r2 rY r1 r` )r� rD rE ra � s
z!ProxyManager.connection_from_hostc C sB d d i } t | � j } | r+ | | d <| r> | j | � | 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)rR rf r3 Zheaders_r� rD rD rE �_set_proxy_headers� s
z ProxyManager._set_proxy_headersTc sh t | � } | j d k rF | j d | j � } | j | | � | d <t t | � j | | d | | �S)z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.rG r3 rl )r
r1 r: r3 r� r~ r rp )rR ru rf rl r[ rg r3 )r� rD rE rp � s
zProxyManager.urlopen)rw rx ry rz rM ra r� rp rD rD )r� rE r i s c K s t d | | � S)Nr )r )rf r[ rD rD rE r � s )r r r r r r r )r r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ )&�
__future__r � collections� functoolsZlogging� _collectionsr Zconnectionpoolr r r �
exceptionsr r r
Z packages.six.moves.urllib.parser �requestr Zutil.urlr
Z
util.retryr �__all__Z getLoggerrw rs rZ Z _key_fields�
namedtupler0 rF �partialrQ rP r r r rD rD rD rE �<module> s^ 6 �W