U ÀÒ.e�Bã@sddlmZddlZddlZddlZddlmZddlmZm Z ddlm Z ddl m Z m Z mZddlmZdd lmZdd lmZdd lmZdd lmZd ddgZe e¡ZdZdZe de¡Z dd„Z!e "e!e ¡e "e!e ¡dœZ#ee dœZ$Gdd „d eƒZ%Gdd„de%ƒZ&dd„Z'dS)é)Úabsolute_importNé)ÚRecentlyUsedContainer)ÚHTTPConnectionPoolÚHTTPSConnectionPool)Úport_by_scheme)ÚLocationValueErrorÚ MaxRetryErrorÚProxySchemeUnknown)Úsix)Úurljoin)ÚRequestMethods)Ú parse_url)ÚRetryÚ PoolManagerÚ ProxyManagerÚproxy_from_url)Zkey_fileZ cert_fileZ cert_reqsZca_certsZ ssl_versionZ ca_cert_dirZ ssl_contextZ key_password)Z key_schemeZkey_hostZkey_portZ key_timeoutZ key_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_contextZ key_maxsizeZ key_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ÚkeyZ socket_optsZfield©r%úC/usr/lib/python3.8/site-packages/pip/_vendor/urllib3/poolmanager.pyÚ_default_key_normalizerDs    r'©ÚhttpÚhttpsc@sxeZdZdZdZddd„Zdd„Zdd „Zdd d „Zd d „Z ddd„Z dd„Z ddd„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é cKs8t ||¡||_t|dd„d�|_t|_t ¡|_dS)NcSs| ¡S©N)Úclose)Úpr%r%r&Ú¢óz&PoolManager.__init__..)Z dispose_func)r Ú__init__Úconnection_pool_kwrÚpoolsÚpool_classes_by_schemeÚkey_fn_by_schemer)ÚselfÚ num_poolsrr2r%r%r&r1Ÿs  zPoolManager.__init__cCs|Sr,r%©r6r%r%r&Ú __enter__©szPoolManager.__enter__cCs | ¡dS)NF)Úclear)r6Úexc_typeZexc_valZexc_tbr%r%r&Ú__exit__¬szPoolManager.__exit__cCs^|j|}|dkr|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))r4r2rr Ú SSL_KEYWORDS)r6rrr=r"Zpool_clsr$Úkwr%r%r&Ú _new_pool±s  zPoolManager._new_poolcCs|j ¡dS)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)r3r:r8r%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éPr=r)rÚ_merge_pool_kwargsrrrÚconnection_from_context)r6rr=rÚ 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")rr5Úconnection_from_pool_key)r6r"rZpool_key_constructorÚpool_keyr%r%r&rCì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. rrr=rF)r3Úlockrr@)r6rHr"Zpoolrrr=r%r%r&rGù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. )r=rrD)rrErr=r)r6ÚurlrDÚur%r%r&Úconnection_from_urls ÿzPoolManager.connection_from_urlc CsV|j ¡}|rR| ¡D]:\}}|dkrHz ||=WqPtk rDYqPXq|||<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)r2rrÚKeyError)r6ÚoverrideZbase_pool_kwargsr$Úvaluer%r%r&rB!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 ¡} t| tƒsÊtj| |d �} | j�r| |¡�stt |d¡ƒ} | D]"} |  ¡| jkrô|d | d¡qôz| j||||d �} Wn$tk �rR| j�rJ‚|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. )r=rFZassert_same_hostÚredirectrNr)i/ZGETÚretries)rP)ÚresponseZ_poolzRedirecting %s -> %s)rrErr=rrrÚproxyÚurlopenZ request_uriZget_redirect_locationr ZstatusrÚ isinstancerZfrom_intZremove_headers_on_redirectZ is_same_hostrr Ziterkeysrr Z incrementr Zraise_on_redirectÚlogÚinfo) r6ÚmethodrJrPr?rKZconnrRZredirect_locationrQrÚheaderr%r%r&rT5sF       ÿ zPoolManager.urlopen)r+N)N)Nr)N)N)N)T)Ú__name__Ú __module__Ú __qualname__Ú__doc__rSr1r9r<r@r:rErCrGrLrBrTr%r%r%r&r�s     csHeZdZdZd‡fdd„ Zd‡fdd„ Zdd d „Zd‡fd 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+Nc s˜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:%irA)r=r(Ú_proxyr)rUrrrr=rrrÚ_replacer rSÚ proxy_headersÚsuperrr1)r6Ú proxy_urlr7rr`r2rSr=©Ú __class__r%r&r1�s" ý      zProxyManager.__init__r)csD|dkr tt|ƒj||||d�Stt|ƒj|jj|jj|jj|d�S)Nr*)rD)rarrErSrr=r)r6rr=rrDrcr%r&rE®s ÿ ÿz!ProxyManager.connection_from_hostcCs0ddi}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)r6rJrZheaders_rer%r%r&Ú_set_proxy_headers¸s  zProxyManager._set_proxy_headersTc sNt|ƒ}|jdkr0| d|j¡}| ||¡|d<tt|ƒj||fd|i|—ŽS)z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.r)rrP)rrrrrgrarrT)r6rXrJrPr?rKrrcr%r&rTÇs  zProxyManager.urlopen)r+NN)Nr)N)N)T) rZr[r\r]r1rErgrTÚ __classcell__r%r%rcr&rtsû cKstfd|i|—ŽS)Nrb)r)rJr?r%r%r&rÕs)(Z __future__rÚ collectionsÚ functoolsZloggingÚ _collectionsrZconnectionpoolrrrÚ exceptionsrr r Zpackagesr Zpackages.six.moves.urllib.parser Zrequestr Zutil.urlrZ util.retryrÚ__all__Z getLoggerrZrVr>Z _key_fieldsÚ namedtuplerr'Úpartialr5r4rrrr%r%r%r&Ús4            6  þ ta