/usr/lib/python3.9/site-packages/urllib3/__pycache__
Edit: /usr/lib/python3.9/site-packages/urllib3/__pycache__/poolmanager.cpython-39.pyc (15233B)
a
s
>> 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 s8 t | | || _t|dd d| _t| _t | _d S )Nc S s | S N)close)pr, r, r- z&PoolManager.__init__..)Z dispose_func)r __init__connection_pool_kwr poolspool_classes_by_schemekey_fn_by_schemer )self num_poolsr r9 r, r, r- r8 s
zPoolManager.__init__c C s | S r3 r, r= r, r, r- __enter__ s zPoolManager.__enter__c C s | dS )NF)clear)r= exc_typeZexc_valZexc_tbr, r, r- __exit__ s zPoolManager.__exit__c C sb | j | }|du r | j }dD ]}||d q |dkrPtD ]}||d q>|||fi |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)r r portr0 )r; r9 r r' SSL_KEYWORDS)r= r r rD r) Zpool_clsr+ kwr, r, r- _new_pool s
zPoolManager._new_poolc 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)r: rA r? r, r, r- rA s zPoolManager.clearr0 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.r0 r P rD r )r _merge_pool_kwargsr r# r connection_from_context)r= r rD r pool_kwargsr) r, r, r- connection_from_host s
z PoolManager.connection_from_hostc C s: |d }| j|}|s$t|||}| 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.
r r) )r r< r# r
connection_from_pool_key)r= r) r Zpool_key_constructorpool_keyr, r, r- rJ s z#PoolManager.connection_from_contextc C s | j jf | j |}|r,|W d S |d }|d }|d }| j||||d}|| j |< W d n1 st0 Y |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.
Nr r rD rM )r: lockr# rG )r= rO r) Zpoolr r rD r, r, r- rN s
(z$PoolManager.connection_from_pool_keyc 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.
)rD r rK )r rL r rD r )r= urlrK ur, r, r- connection_from_url s z PoolManager.connection_from_urlc C sT | j }|rP| D ]8\}}|du rFz
||= W qN tyB Y qN0 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)r9 r r" KeyError)r= overrideZbase_pool_kwargsr+ valuer, r, r- rI / s
z PoolManager._merge_pool_kwargsc C s" | j du rdS 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)proxyr proxy_configr )r= Z
parsed_urlr, r, r- !_proxy_requires_url_absolute_formC s
z-PoolManager._proxy_requires_url_absolute_formc C s@ | j du s|dkrdS | j jdkr&dS tjr<| jjs %s)!r rZ r rL r rD r r rY urlopenZ request_uriZget_redirect_locationr statusr Z_prepare_for_method_changer#
isinstancer Zfrom_intZremove_headers_on_redirectZ is_same_hostr% r Ziterkeysr r' Z incrementr
Zraise_on_redirectZ
drain_connloginfo) r= methodrQ r[ rF rR Zconnr^ Zredirect_locationr] r headerr, r, r- r_ a sP
zPoolManager.urlopen)r2 N)N)Nr0 N)N)N)T)__name__
__module__ __qualname____doc__rW rX r8 r@ rC rG rA rL rJ rN rS rI rY rZ r_ r, r, r, r- r s
r c sH e Zd ZdZd fdd Zd fdd Zdd
d Zd 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.
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
r2 NFc
s t |tr d|j|j|jf }t|}|jdvr:t|j|jsZt|jd} |j | d}|| _
|pfi | _ || _ t
||| _| j
|d< | j |d< | j|d< tt| j||fi | d S )Nz
%s://%s:%ir/ rH )rD _proxyr Z
_proxy_config)ra r r r rD r r r r# _replacerW
proxy_headersproxy_ssl_contextr rX superr r8 )
r= proxy_urlr> r rl rm r r9 rW rD __class__r, r- r8 s(
zProxyManager.__init__r0 c sD |dkr t t| j||||dS t t| j| jj| jj| jj|dS )Nr1 )rK )rn r rL rW r rD r )r= r rD r rK rp r, r- rL s
z!ProxyManager.connection_from_hostc 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.
ZAcceptz*/*ZHost)r netlocupdate)r= rQ r Zheaders_rr r, r, r- _set_proxy_headers s
z ProxyManager._set_proxy_headersTc sV t |}t| j| j|js8|d| j}| |||d< tt | j
||fd|i|S )z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.r r[ ) r r rW rX r r# r rt rn r r_ )r= rd rQ r[ rF rR r rp r, r- r_ s
zProxyManager.urlopen)r2 NNNF)Nr0 N)N)T) rf rg rh ri r8 rL rt r_
__classcell__r, r, rp r- r s * %
r c K s t f d| i|S )Nro )r )rQ rF r, r, r- r s r )/Z
__future__r collections functoolsZlogging _collectionsr r Zconnectionpoolr r r
exceptionsr r
r r r
Zpackagesr Z packages.six.moves.urllib.parser Zrequestr Z
util.proxyr Z
util.retryr Zutil.urlr __all__Z getLoggerrf rb rE Z _key_fields
namedtupler Z_proxy_config_fieldsr r. partialr< r; r r r r, r, r, r- s:
6
s