U
|
I=®d,T ã @ sÌ d Z ddlZddlZddlmZmZ ddlmZ ddl m
|
Z
|
ddl m Z ddl mZ ddlmZ dd lmZ dd
|
lmZ dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddl m Z ddl m!Z!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0m1Z1m2Z2mZmZm3Z3m4Z4m5Z5m6Z6 ddl7m8Z8 zddl9m:Z: W n e;k
|
r d d Z:Y nX d Z<d Z=dZ>dZ?G d d! d!e@ZAG d"d# d#eAZBdS )$z
|
requests.adapters
|
~~~~~~~~~~~~~~~~~
|
|
This module contains the transport adapters that Requests uses to define
|
and maintain connections.
|
é N)Ú PoolManagerÚproxy_from_url)Ú HTTPResponse)Ú parse_url)ÚTimeout)ÚRetry)ÚClosedPoolError)ÚConnectTimeoutError)Ú HTTPError)Ú MaxRetryError)ÚNewConnectionError)Ú
|
ProxyError)Ú ProtocolError)ÚReadTimeoutError)ÚSSLError)Ú ResponseError)ÚLocationValueErroré )ÚResponse)ÚurlparseÚ
|
basestring)ÚDEFAULT_CA_BUNDLE_PATHÚextract_zipped_pathsÚget_encoding_from_headersÚprepend_scheme_if_neededÚget_auth_from_urlÚ urldefragauthÚ select_proxy)ÚCaseInsensitiveDict)Úextract_cookies_to_jar) ÚConnectionErrorÚConnectTimeoutÚ ReadTimeoutr r Ú
|
RetryErrorÚ InvalidSchemaÚInvalidProxyURLÚ
|
InvalidURL)Ú_basic_auth_str)ÚSOCKSProxyManagerc O s t dd S )Nz'Missing dependencies for SOCKS support.)r$ )ÚargsÚkwargs© r+ úTD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pip/_vendor/requests/adapters.pyr( . s r( Fé
|
c s2 e Zd ZdZ fddZd ddZd d
|
Z ZS ) Ú BaseAdapterzThe Base Transport Adapterc s t t| ¡ d S ©N)Úsuperr. Ú__init__©Úself©Ú __class__r+ r, r1 : s zBaseAdapter.__init__FNTc C s t dS )aC Sends PreparedRequest object. Returns Response object.
|
|
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
|
:param stream: (optional) Whether to stream the request content.
|
: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 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
|
:param cert: (optional) Any user-provided SSL certificate to be trusted.
|
:param proxies: (optional) The proxies dictionary to apply to the request.
|
N©ÚNotImplementedError)r3 ÚrequestÚstreamÚtimeoutÚverifyÚcertÚproxiesr+ r+ r, Úsend= s zBaseAdapter.sendc C s t dS )z!Cleans up adapter specific items.Nr6 r2 r+ r+ r, ÚcloseO s zBaseAdapter.close)FNTNN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r1 r> r? Ú __classcell__r+ r+ r4 r, r. 7 s ÿ
|
r. c s e Zd ZdZdddddgZeeeef fdd Zd d
|
Z d d Z
|
efd dZ dd Z dd Z dd Zd$ddZdd Zdd Zd d Zd d Zd%d"d#Z ZS )&Ú HTTPAdaptera The built-in HTTP Adapter for urllib3.
|
|
Provides a general-case interface for Requests sessions to contact HTTP and
|
HTTPS urls by implementing the Transport Adapter interface. This class will
|
usually be created by the :class:`Session <Session>` class under the
|
covers.
|
|
:param pool_connections: The number of urllib3 connection pools to cache.
|
:param pool_maxsize: The maximum number of connections to save in the pool.
|
:param max_retries: The maximum number of retries each connection
|
should attempt. Note, this applies only to failed DNS lookups, socket
|
connections and connection timeouts, never to requests where data has
|
made it to the server. By default, Requests does not retry failed
|
connections. If you need granular control over the conditions under
|
which we retry a request, import urllib3's ``Retry`` class and pass
|
that instead.
|
:param pool_block: Whether the connection pool should block for connections.
|
|
Usage::
|
|
>>> import requests
|
>>> s = requests.Session()
|
>>> a = requests.adapters.HTTPAdapter(max_retries=3)
|
>>> s.mount('http://', a)
|
Ú max_retriesÚconfigÚ_pool_connectionsÚ _pool_maxsizeÚ _pool_blockc sd |t krtddd| _n t |¡| _i | _i | _tt| ¡ || _ || _
|
|| _ | j |||d d S )Nr F)Úread©Úblock) ÚDEFAULT_RETRIESr rF Úfrom_intrG Ú proxy_managerr0 rE r1 rH rI rJ Úinit_poolmanager)r3 Úpool_connectionsÚ pool_maxsizerF Ú
|
pool_blockr4 r+ r, r1 q s zHTTPAdapter.__init__c s fdd j D S )Nc s i | ]}|t |d qS r/ )Úgetattr)Ú.0Úattrr2 r+ r, Ú
|
<dictcomp> s z,HTTPAdapter.__getstate__.<locals>.<dictcomp>)Ú __attrs__r2 r+ r2 r, Ú __getstate__ s zHTTPAdapter.__getstate__c C sD i | _ i | _| ¡ D ]\}}t| || q| j| j| j| jd d S )NrL )rP rG ÚitemsÚsetattrrQ rH rI rJ )r3 ÚstaterW Úvaluer+ r+ r, Ú __setstate__ s ÿzHTTPAdapter.__setstate__c K s0 || _ || _|| _tf |||dd|| _dS )a Initializes a urllib3 PoolManager.
|
|
This method should not be called from user code, and is only
|
exposed for use when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param connections: The number of urllib3 connection pools to cache.
|
:param maxsize: The maximum number of connections to save in the pool.
|
:param block: Block when no free connections are available.
|
:param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
|
T)Ú num_poolsÚmaxsizerM ÚstrictN)rH rI rJ r Ú poolmanager)r3 Ú connectionsra rM Ú pool_kwargsr+ r+ r, rQ s ÿÿz HTTPAdapter.init_poolmanagerc K s || j kr| j | }n|| ¡ d¡r^t|\}}t|f||| j| j| jd| }| j |< n4| |¡}t |f|| j| j| jd| }| j |< |S )aÏ Return urllib3 ProxyManager for the given proxy.
|
|
This method should not be called from user code, and is only
|
exposed for use when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param proxy: The proxy to return a urllib3 ProxyManager for.
|
:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
|
:returns: ProxyManager
|
:rtype: urllib3.ProxyManager
|
Úsocks)ÚusernameÚpasswordr` ra rM )Ú proxy_headersr` ra rM )
|
rP ÚlowerÚ
|
startswithr r( rH rI rJ ri r )r3 ÚproxyÚ proxy_kwargsÚmanagerrg rh ri r+ r+ r, Úproxy_manager_for¦ s6
|
ÿúù
|
|
ÿûúz HTTPAdapter.proxy_manager_forc C sü | ¡ d¡rn|rnd}|dk r"|}|s.tt}|r>tj |¡sLtd |¡d|_ tj
|
|¡sf||_ q||_ nd|_ d|_ d|_ |røt |ts¤|d |_|d |_n ||_d|_|jrÔtj |j¡sÔtd |j¡|jrøtj |j¡søtd
|
|j¡dS ) aA Verify a SSL certificate. This method should not be called from user
|
code, and is only exposed for use when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param conn: The urllib3 connection object associated with the cert.
|
:param url: The requested URL.
|
:param verify: 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
|
:param cert: The SSL certificate to verify.
|
ÚhttpsNTzECould not find a suitable TLS CA certificate bundle, invalid path: {}Ú CERT_REQUIREDÚ CERT_NONEr r z9Could not find the TLS certificate file, invalid path: {}z1Could not find the TLS key file, invalid path: {})rj rk r r ÚosÚpathÚexistsÚIOErrorÚformatÚ cert_reqsÚisdirÚca_certsÚ ca_cert_dirÚ
|
isinstancer Ú cert_fileÚkey_file)r3 ÚconnÚurlr; r< Úcert_locr+ r+ r, Ú cert_verifyË s> ÿ
|
|
ÿÿzHTTPAdapter.cert_verifyc C s t }t|dd|_tt|di |_t|j|_||_|jj|_t |j
|
t r^|j
|
d¡|_
|
n|j
|
|_
|
t |j|| ||_| |_|S )a¶ Builds a :class:`Response <requests.Response>` object from a urllib3
|
response. This should not be called from user code, and is only exposed
|
for use when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`
|
|
:param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response.
|
:param resp: The urllib3 response object.
|
:rtype: requests.Response
|
ÚstatusNÚheadersúutf-8)r rU Ú status_coder r r ÚencodingÚrawÚreasonr| r ÚbytesÚdecoder Úcookiesr8 Ú
|
connection)r3 ÚreqÚrespÚresponser+ r+ r, Úbuild_responseÿ s
|
|
zHTTPAdapter.build_responseNc C sd t ||}|rDt|d}t|}|js.td| |¡}| |¡}n t|}| ¡ }| j |¡}|S )a Returns a urllib3 connection for the given URL. This should not be
|
called from user code, and is only exposed for use when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param url: The URL to connect to.
|
:param proxies: (optional) A Requests-style dictionary of proxies used on this request.
|
:rtype: urllib3.ConnectionPool
|
ÚhttpzFPlease check proxy URL. It is malformed and could be missing the host.)
|
r r r Úhostr% ro Úconnection_from_urlr Úgeturlrc )r3 r r= rl Ú proxy_urlrP r Úparsedr+ r+ r, Úget_connection$ s
|
|
|
zHTTPAdapter.get_connectionc C s& | j ¡ | j ¡ D ] }| ¡ qdS )z¢Disposes of any internal state.
|
|
Currently, this closes the PoolManager and any active ProxyManager,
|
which closes any pooled connections.
|
N)rc ÚclearrP Úvalues)r3 rl r+ r+ r, r? ? s
|
zHTTPAdapter.closec C s` t |j|}t|jj}|o"|dk}d}|rDt|j ¡ }| d¡}|j}|r\|s\t|j}|S )a? Obtain the url to use when making the final request.
|
|
If the message is being sent through a HTTP proxy, the full URL has to
|
be used. Otherwise, we should only use the path portion of the URL.
|
|
This should not be called from user code, and is only exposed for use
|
when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
|
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
|
:rtype: str
|
rp Frf )r r r Úschemerj rk Úpath_urlr ) r3 r8 r= rl r Úis_proxied_http_requestÚusing_socks_proxyÚ proxy_schemer r+ r+ r, Ú request_urlI s
|
|
zHTTPAdapter.request_urlc K s dS )a" Add any headers needed by the connection. As of v2.0 this does
|
nothing by default, but is left for overriding by users that subclass
|
the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
This should not be called from user code, and is only exposed for use
|
when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param request: The :class:`PreparedRequest <PreparedRequest>` to add headers to.
|
:param kwargs: The keyword arguments from the call to send().
|
Nr+ )r3 r8 r* r+ r+ r, Ú add_headersf s zHTTPAdapter.add_headersc C s& i }t |\}}|r"t|||d< |S )a Returns a dictionary of the headers to add to any request sent
|
through a proxy. This works with urllib3 magic to ensure that they are
|
correctly sent to the proxy, rather than in a tunnelled request if
|
CONNECT is being used.
|
|
This should not be called from user code, and is only exposed for use
|
when subclassing the
|
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
|
|
:param proxy: The url of the proxy being used for this request.
|
:rtype: dict
|
zProxy-Authorization)r r' )r3 rl r rg rh r+ r+ r, ri t s ÿzHTTPAdapter.proxy_headersFTc C sä z| |j|¡}W n. tk
|
r@ } zt||dW 5 d}~X Y nX | ||j||¡ | ||¡} | j||||||d |jdkpd|jk }
|
t |t
|
ræz|\} } t | | d}W qþ t k
|
râ } zd |¡} t | W 5 d}~X Y qþX nt |t ròn t ||d}zF|
|
s2|j|j| |j|jdddd| j|d
|
}nt|d rD|j}|jtd
|
}zÚ|j|j| d d |j ¡ D ]\}}| ||¡ qn| ¡ |jD ]D}| tt|d d
d¡¡ | d¡ | |¡ | d¡ q| d¡ z|j d d}W n t k
|
r | ¡ }Y nX t j |||ddd}W n | !¡ Y nX W n t"t#j$fk
|
r~ } zt%| |dW 5 d} ~ X Y nZ t&k
|
r" } zt |j't(r¸t |j't)s¸t*||dt |j't+rÒt,||dt |j't-rìt.||dt |j't/rt0||dt%||dW 5 d}~X Y n¶ t1k
|
rP } zt%||dW 5 d}~X Y n t-k
|
rz } z t.|W 5 d}~X Y n^ t/t2fk
|
rÖ } z:t |t/rªt0||dn t |t3rÄt4||dn W 5 d}~X Y nX | 5||¡S )a Sends PreparedRequest object. Returns Response object.
|
|
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
|
:param stream: (optional) Whether to stream the request content.
|
: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 or urllib3 Timeout object
|
: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
|
:param cert: (optional) Any user-provided SSL certificate to be trusted.
|
:param proxies: (optional) The proxies dictionary to apply to the request.
|
:rtype: requests.Response
|
)r8 N)r9 r: r; r< r= zContent-Length)ÚconnectrK zrInvalid timeout {}. Pass a (connect, read) timeout tuple, or a single float to set both timeouts to the same valueF)
|
Úmethodr Úbodyr ÚredirectÚassert_same_hostÚpreload_contentÚdecode_contentÚretriesr: Ú
|
proxy_pool)r: T)Úskip_accept_encodingé r
s
|
s 0
|
|
)Ú buffering)Úpoolr r§ r¨ )6r r r r& r r r¡ r¤ r r| ÚtupleÚ TimeoutSauceÚ
|
ValueErrorrw Úurlopenr£ rF Úhasattrrª Ú _get_connÚDEFAULT_POOL_TIMEOUTÚ
|
putrequestr[ Ú putheaderÚ
|
endheadersr> ÚhexÚlenÚencodeÚ getresponseÚ TypeErrorr Ú from_httplibr? r ÚsocketÚerrorr r r r r r! r r# Ú _ProxyErrorr Ú _SSLErrorr r Ú
|
_HTTPErrorr r" r )r3 r8 r9 r: r; r< r= r Úer Úchunkedr¢ rK Úerrr Úlow_connÚheaderr^ ÚiÚrr+ r+ r, r> s²
|
þ
|
ö
|
þ
|
|
|
|
û
|
zHTTPAdapter.send)N)FNTNN)r@ rA rB rC rY ÚDEFAULT_POOLSIZErN ÚDEFAULT_POOLBLOCKr1 rZ r_ rQ ro r r r r? r r¡ ri r> rD r+ r+ r4 r, rE T s* ÿ þ %4%
|
|
rE )CrC Úos.pathrs r¿ Z pip._vendor.urllib3.poolmanagerr r Z pip._vendor.urllib3.responser Úpip._vendor.urllib3.utilr r r° Z pip._vendor.urllib3.util.retryr Z pip._vendor.urllib3.exceptionsr r r
|
rà r r r rÁ r r r r r r Úmodelsr Úcompatr r Úutilsr r r r r r r Ú
|
structuresr r r Ú
|
exceptionsr r! r" r# r$ r% r& Úauthr' Z!pip._vendor.urllib3.contrib.socksr( Ú ImportErrorrÌ rË rN rµ Úobjectr. rE r+ r+ r+ r, Ú<module> sF $ ,
|
