U
|
ý°dV ã @ s d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dlm Z ddl
|
m Z ddl m Z ddlmZ dd lmZmZmZ dd
|
lmZmZmZmZ dd lmZ dd lm Z dd l m Z ddl m Z ddl!m"Z" ddl#m$Z$m%Z% ej&rúd dl'Z'd dl(m)Z) dddgZ*e +e,¡Z-dZ.dZ/e 0d¡Z1G dd dej2Z3dddd d d Z4e 5e4e3¡e 5e4e3¡d Z6eed Z7G d d de Z8G d!d de8Z9d"d#dd$d%dZ:dS )&é )Ú annotationsN)Ú TracebackType)Úurljoiné )ÚRecentlyUsedContainer)ÚRequestMethods)Ú ProxyConfig)ÚHTTPConnectionPoolÚHTTPSConnectionPoolÚport_by_scheme)ÚLocationValueErrorÚ MaxRetryErrorÚProxySchemeUnknownÚURLSchemeUnknown)ÚBaseHTTPResponse)Ú_TYPE_SOCKET_OPTIONS)Ú connection_requires_http_tunnel)ÚRetry)ÚTimeout)ÚUrlÚ parse_url)ÚLiteralÚ PoolManagerÚ ProxyManagerÚproxy_from_url) Úkey_fileÚ cert_fileÚ cert_reqsÚca_certsÚ ssl_versionZssl_minimum_versionZssl_maximum_versionÚ ca_cert_dirÚ ssl_contextÚ key_passwordÚserver_hostnamei @ Ú_SelfTc @ sò e Zd ZU dZded< ded< ded< ded< d ed
|
< d ed < d ed< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded < ded < d ed < d ed!< d ed"< d#ed$< d%ed&< d ed'< d(ed)< ded*< ded+< ded,< d-S ).ÚPoolKeyzÏ
|
All known keyword arguments that could be provided to the pool manager, its
|
pools, or the underlying connections.
|
|
All custom key schemes should include the fields in this key at a minimum.
|
ÚstrÚ
|
key_schemeÚkey_hostú
|
int | NoneÚkey_portz Timeout | float | int | NoneÚ key_timeoutzRetry | bool | int | NoneÚ key_retriesz bool | NoneÚ key_blockztuple[str, int] | NoneÚkey_source_addressú
|
str | NoneÚ key_key_fileÚkey_key_passwordÚ key_cert_fileÚ key_cert_reqsÚ key_ca_certszint | str | NoneÚkey_ssl_versionzssl.TLSVersion | NoneZkey_ssl_minimum_versionZkey_ssl_maximum_versionÚkey_ca_cert_dirússl.SSLContext | NoneÚkey_ssl_contextÚ key_maxsizez!frozenset[tuple[str, str]] | NoneÚ key_headersú
|
Url | NoneÚ
|
key__proxyÚkey__proxy_headersúProxyConfig | NoneZkey__proxy_configz_TYPE_SOCKET_OPTIONS | NoneÚkey_socket_optionsÚkey__socks_optionszbool | str | NoneÚkey_assert_hostnameÚkey_assert_fingerprintÚkey_server_hostnameÚ key_blocksizeN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__© rJ rJ úJd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\urllib3/poolmanager.pyr% 9 s:
|
r% z type[PoolKey]údict[str, typing.Any])Ú key_classÚrequest_contextÚreturnc C sØ | ¡ }|d ¡ |d< |d ¡ |d< dD ],}||kr,|| dk r,t|| ¡ ||< q,| d¡}|dk rxt||d< t| ¡ D ]}| |¡|d| < q| j D ]}||kr¢d||< q¢| d¡dkrÎt
|
|d< | 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_headersÚ_socks_optionsNÚsocket_optionsÚkey_rD ) ÚcopyÚlowerÚ frozensetÚitemsÚgetÚtupleÚlistÚkeysÚpopÚ_fieldsÚ_DEFAULT_BLOCKSIZE)rM rN ÚcontextÚkeyÚ socket_optsÚfieldrJ rJ rK Ú_default_key_normalizer_ s"
|
|
|
rf ©ÚhttpÚhttpsc s e Zd ZU dZdZded< dZded< dAdd d
|
d d fd d ZdddddZdddddddZ dBddddd d d d Z
|
d d d!d"Z dCd$d%d$dd d&d'd(Z d)d d*d+d,Z d-d)d d.d/d0ZdDddd d1d2d3Zdd)d4d5d6Zd7d8d9d:d;ZdEddd8d
|
d=d>d?d@Z ZS )Fr aV
|
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:
|
|
.. code-block:: python
|
|
import urllib3
|
|
http = urllib3.PoolManager(num_pools=2)
|
|
resp1 = http.request("GET", "https://google.com/")
|
resp2 = http.request("GET", "https://google.com/mail")
|
resp3 = http.request("GET", "https://yahoo.com/")
|
|
print(len(http.pools))
|
# 2
|
|
Nr; Úproxyr> Ú proxy_configé
|
Úintú typing.Mapping[str, str] | Noneú
|
typing.AnyÚNone)Ú num_poolsrR Úconnection_pool_kwrO c s4 t |¡ || _| t|| _t| _t ¡ | _d S ©N)ÚsuperÚ__init__rr r ÚpoolsÚpool_classes_by_schemeÚkey_fn_by_schemerW )Úselfrq rR rr ©Ú __class__rJ rK ru Ç s
|
zPoolManager.__init__r$ )ry rO c C s | S rs rJ ©ry rJ rJ rK Ú __enter__Ø s zPoolManager.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | NonezLiteral[False])Úexc_typeÚexc_valÚexc_tbrO c C s | ¡ dS )NF)Úclear)ry r~ r r rJ rJ rK Ú__exit__Û s zPoolManager.__exit__r& ú dict[str, typing.Any] | Noner )rP rQ ÚportrN rO c C st | j | }|dkr | j ¡ }| d¡dkr2t|d< dD ]}| |d¡ q6|dkrftD ]}| |d¡ qT|||f|S )aÎ
|
Create a new :class:`urllib3.connectionpool.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Ú blocksize)rP rQ r rh )rw rr rW r[ ra r_ Ú SSL_KEYWORDS)ry rP rQ r rN Úpool_clsrc ÚkwrJ rJ rK Ú _new_poolå s
|
|
zPoolManager._new_pool)rO c C s | 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)rv r r| rJ rJ rK r s zPoolManager.clearrh r/ r) ©rQ r rP Ú pool_kwargsrO c C sT |s t d| |¡}|p d|d< |s:t |d ¡ d¡}||d< ||d< | |¡S )a¤
|
Get a :class:`urllib3.connectionpool.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.rh rP éP r rQ )r Ú_merge_pool_kwargsr r[ rX Úconnection_from_context)ry rQ r rP r rN rJ rJ rK Úconnection_from_host s
|
z PoolManager.connection_from_hostrL )rN rO c C sX d|kr t dt¡ | d¡ |d ¡ }| j |¡}|sBt|||}| j||dS )zù
|
Get a :class:`urllib3.connectionpool.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.
|
ÚstrictzdThe 'strict' parameter is no longer needed on Python 3+. This will raise an error in urllib3 v2.1.0.rP ©rN ) ÚwarningsÚwarnÚDeprecationWarningr_ rX rx r[ r Úconnection_from_pool_key)ry rN rP Úpool_key_constructorÚpool_keyrJ rJ rK r 1 s ý
|
z#PoolManager.connection_from_contextr% )r rN rO c
|
C sl | j jZ | j |¡}|r*|W 5 Q R £ S |d }|d }|d }| j||||d}|| j |< W 5 Q R X |S )a
|
Get a :class:`urllib3.connectionpool.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.
|
rP rQ r r )rv Úlockr[ r )ry r rN ÚpoolrP rQ r rJ rJ rK r J s
|
|
z$PoolManager.connection_from_pool_key)Úurlr rO c C s t |}| j|j|j|j|dS )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 rP r )r r rQ r rP )ry r r ÚurJ rJ rK Úconnection_from_urld s ÿz PoolManager.connection_from_url)ÚoverriderO c C sV | j ¡ }|rR| ¡ D ]:\}}|dkrHz
|
||= W qP tk
|
rD Y qPX q|||< 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)rr rW rZ ÚKeyError)ry r Úbase_pool_kwargsrc ÚvaluerJ rJ rK r v s
|
|
|
|
z PoolManager._merge_pool_kwargsr Úbool)Ú
|
parsed_urlrO c C s" | j dkrdS t| j | j|j S )z³
|
Indicates if the proxy requires the complete destination URL in the
|
request. Normally this is only needed when not using an HTTP CONNECT
|
tunnel.
|
NF)rj r rk rP )ry r¢ rJ rJ rK Ú!_proxy_requires_url_absolute_form s
|
ÿz-PoolManager._proxy_requires_url_absolute_formTr ©Úmethodr Úredirectr rO c K s t |}| j|j|j|jd}d|d< d|d< d|kr@| j|d< | |¡r\|j||f|}n|j||jf|}|ox| ¡ }|s|S t
|
||}|j dkrd}| d¡} t | ts¼tj| |d } | jr | |¡s |d ¡ }
|
|d D ] } | ¡ | jkrä|
|
| d
|
¡ qä|
|
|d< z| j||||d } W n, tk
|
rN | jrF| ¡ | Y S X | |d< ||d< t d ||¡ | ¡ | j||f|S ) aN
|
Same as :meth:`urllib3.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 rP FÚassert_same_hostr¦ rR i/ ÚGETÚretries)r¦ N)ÚresponseÚ_poolzRedirecting %s -> %s)r r rQ r rP rR r£ ÚurlopenÚ request_uriÚget_redirect_locationr Ústatusr[ Ú
|
isinstancer Úfrom_intÚremove_headers_on_redirectÚ is_same_hostrW rX r_ Ú incrementr Úraise_on_redirectÚ
|
drain_connÚlogÚinfo) ry r¥ r r¦ r r Úconnrª Úredirect_locationr© Ú new_headersÚheaderrJ rJ rK r¬ sL
|
|
|
|
|
|
ÿ
|
zPoolManager.urlopen)rl N)N)Nrh N)N)T)rE rF rG rH rj rI rk ru r} r r r r r r r r r£ r¬ Ú __classcell__rJ rJ rz rK r ¢ s.
|
! ý û& û ÿ ÿc s e Zd ZdZd!dddddd d
|
d d d d
|
fdd Zd"d dd ddd fdd Zd#ddddddZd$ddd d d d fd d Z ZS )%r a>
|
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.
|
|
:param proxy_ssl_context:
|
The proxy SSL context is used to establish the TLS connection to the
|
proxy when using HTTPS proxies.
|
|
:param use_forwarding_for_https:
|
(Defaults to False) If set to True will forward requests to the HTTPS
|
proxy to be made on behalf of the client instead of creating a TLS
|
tunnel via the CONNECT method. **Enabling this flag means that request
|
and response headers and content will be visible from the HTTPS proxy**
|
whereas tunneling keeps request and response headers and content
|
private. IP address, target hostname, SNI, and port are always visible
|
to an HTTPS proxy even when this flag is disabled.
|
|
:param proxy_assert_hostname:
|
The hostname of the certificate to verify against.
|
|
:param proxy_assert_fingerprint:
|
The fingerprint of the certificate to verify against.
|
|
Example:
|
|
.. code-block:: python
|
|
import urllib3
|
|
proxy = urllib3.ProxyManager("https://localhost:3128/")
|
|
resp1 = proxy.request("GET", "https://google.com/")
|
resp2 = proxy.request("GET", "https://httpbin.org/")
|
|
print(len(proxy.pools))
|
# 1
|
|
resp3 = proxy.request("GET", "https://httpbin.org/")
|
resp4 = proxy.request("GET", "https://twitter.com/")
|
|
print(len(proxy.pools))
|
# 3
|
|
rl NFr& rm rn r7 r¡ zNone | str | Literal[False]r/ ro rp )
|
Ú proxy_urlrq rR Ú proxy_headersÚproxy_ssl_contextÚuse_forwarding_for_httpsÚproxy_assert_hostnameÚproxy_assert_fingerprintrr rO c sÀ t |tr&|j d|j d|j }
|
n|}
|
t|
|
} | jdkrFt| j| jsft | jd¡} | j | d} | | _
|
|pri | _ || _ t ||||| _| j
|
| d< | j | d< | j| d< t j||f| d S ) Nz://ú:rg r )r Ú_proxyrS Z _proxy_config)r° r rP rQ r r r r r[ Ú_replacerj r¿ rÀ r rk rt ru ) ry r¾ rq rR r¿ rÀ rÁ r rà rr Z str_proxy_urlrj r rz rJ rK ru s,
|
|
|
|
ü
|
|
|
zProxyManager.__init__rh r) r r r c s< |dkr t j||||dS t j| jj| jj| jj|dS )Nri )r )rt r rj rQ r rP )ry rQ r rP r rz rJ rK r ? s ÿ ÿz!ProxyManager.connection_from_hostztyping.Mapping[str, str])r rR rO c C s0 ddi}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.
|
ÚAcceptz*/*ÚHost)r ÚnetlocÚupdate)ry r rR Úheaders_rÉ rJ rJ rK Ú_set_proxy_headersO s
|
|
z ProxyManager._set_proxy_headersTr r¤ c sR t |}t| j| j|js8| d| j¡}| ||¡|d< t j ||fd|i|S )z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.rR r¦ )
|
r r rj rk rP r[ rR rÌ rt r¬ )ry r¥ r r¦ r r rR rz rJ rK r¬ ` s
|
zProxyManager.urlopen)rl NNNFNN)Nrh N)N)T) rE rF rG rH ru r rÌ r¬ r½ rJ rJ rz rK r ß s" 9 ÷&, û ÿ ÿr& ro )r r rO c K s t f d| i|S )Nr¾ )r )r r rJ rJ rK r o s );Ú
|
__future__r Ú functoolsÚloggingÚtypingr Útypesr Ú urllib.parser Ú _collectionsr Z_request_methodsr Ú
|
connectionr Úconnectionpoolr r
|
r Ú
|
exceptionsr r r r rª r Zutil.connectionr Z
|
util.proxyr Z
|
util.retryr Z util.timeoutr Zutil.urlr r Ú TYPE_CHECKINGÚsslZtyping_extensionsr Ú__all__Ú getLoggerrE r· r ra ÚTypeVarr$ Ú
|
NamedTupler% rf Úpartialrx rw r r r rJ rJ rJ rK Ú<module> sJ
|
|
|
&<
|
|
þ
|
?
|
