U
|
ý°dѧ ã @ s d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl m
|
Z d dl m Z ddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZ dd lmZ dd
|
l m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) dd l*m+Z+ dd l,m-Z- dd l.m/Z/ ddl0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8m9Z9m:Z: ddl;m<Z<m=Z= ddl;m>Z? ddl;m@Z@ ddlAmBZB ejCr¤d dlDZDd dlEmFZF ddlmGZGmHZH e IeJ¡ZKejLe:eMe9df ZNe Od¡ZPG dd dZQejRejShZTG dd d eQeZUG d d d eUZVd d d d!d"d#ZWejXd$d%d$d&d'd(Z>ejXd d%d d&d)d(Z>d%d%d%d&d*d(Z>d3d+d%d d,d-d.ZYd/d$d0d1d2ZZdS )4é )Ú annotationsN©Útimeout)Ú TracebackTypeé )Ú
|
_TYPE_BODY)ÚRequestMethods)Ú BaseSSLErrorÚBrokenPipeErrorÚDummyConnectionÚHTTPConnectionÚ HTTPExceptionÚHTTPSConnectionÚ ProxyConfigÚ_wrap_proxy_error)Úport_by_scheme) ÚClosedPoolErrorÚEmptyPoolErrorÚ FullPoolErrorÚHostChangedErrorÚInsecureRequestWarningÚLocationValueErrorÚ MaxRetryErrorÚNewConnectionErrorÚ ProtocolErrorÚ
|
ProxyErrorÚReadTimeoutErrorÚSSLErrorÚ TimeoutError)ÚBaseHTTPResponse)Úis_connection_dropped)Ú connection_requires_http_tunnel)Ú_TYPE_BODY_POSITIONÚset_file_position)ÚRetry)ÚCertificateError)Ú_DEFAULT_TIMEOUTÚ _TYPE_DEFAULTÚTimeout)ÚUrlÚ_encode_target)Ú_normalize_host)Ú parse_url)Úto_str)ÚLiteral)ÚBaseHTTPConnectionÚBaseHTTPSConnectionÚ_SelfTc @ sx e Zd ZU dZdZded< ejZdddddd d
|
Z dd d d Z
|
dddddZ dddddddZ dd ddZ dS ) ÚConnectionPoola;
|
Base class for all connection pools, such as
|
:class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
|
|
.. note::
|
ConnectionPool.urlopen() does not normalize or percent-encode target URIs
|
which is useful if your target server doesn't support percent-encoded
|
target URIs.
|
Nú
|
str | NoneÚschemeÚstrú
|
int | NoneÚNone)ÚhostÚportÚreturnc C s: |s t dt|| jd| _|| _t|| jd ¡ | _d S )NzNo host specified.©r4 )r r+ r4 r8 r9 Únormalize_hostÚlowerÚ _tunnel_host)Úselfr8 r9 © r@ úMd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\urllib3/connectionpool.pyÚ__init__R s
|
zConnectionPool.__init__©r: c C s t | j d| jd| jdS )Nz(host=z, port=ú))ÚtypeÚ__name__r8 r9 ©r? r@ r@ rA Ú__str___ s zConnectionPool.__str__r1 )r? r: c C s | S ©Nr@ rG r@ r@ rA Ú __enter__b s zConnectionPool.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | NonezLiteral[False])Úexc_typeÚexc_valÚexc_tbr: c C s | ¡ dS )NF)Úclose)r? rK rL rM r@ r@ rA Ú__exit__e s zConnectionPool.__exit__c C s dS ©zD
|
Close all pooled connections and disable the pool.
|
Nr@ rG r@ r@ rA rN o s zConnectionPool.close)N)rF Ú
|
__module__Ú __qualname__Ú__doc__r4 Ú__annotations__ÚqueueÚ LifoQueueÚQueueClsrB rH rJ rO rN r@ r@ r@ rA r2 D s
|
|
|
r2 c @ sj e Zd ZU dZdZeZded< dedddddddf dd d
|
d d d ddd ddd ddZ ddddZ
|
d?ddddd Z d d d d d!Z dd d d"d#Z dd d d$d%Zd&d'dd(d)Zd*dd
|
d d+d,d-Zdddeddd.d.d.f dddd/d d0d&d d d d d d1d2 d3d4Zd dd5d6Zdd d7d8d9Zdddd.d.eddddd.d.f ddd/d dd d d&d d:d d;d d dd1d<d=d>ZdS )@ÚHTTPConnectionPoola
|
Thread-safe connection pool for one host.
|
|
:param host:
|
Host used for this HTTP Connection (e.g. "localhost"), passed into
|
:class:`http.client.HTTPConnection`.
|
|
:param port:
|
Port used for this HTTP Connection (None is equivalent to 80), passed
|
into :class:`http.client.HTTPConnection`.
|
|
:param timeout:
|
Socket timeout in seconds for each individual connection. This can
|
be a float or integer, which sets the timeout for the HTTP request,
|
or an instance of :class:`urllib3.util.Timeout` which gives you more
|
fine-grained control over request timeouts. After the constructor has
|
been parsed, this is always a `urllib3.util.Timeout` object.
|
|
:param maxsize:
|
Number of connections to save that can be reused. More than 1 is useful
|
in multithreaded situations. If ``block`` is set to False, more
|
connections will be created but they will not be saved once they've
|
been used.
|
|
:param block:
|
If set to True, no more than ``maxsize`` connections will be used at
|
a time. When no free connections are available, the call will block
|
until a connection has been released. This is a useful side effect for
|
particular multithreaded situations where one does not want to use more
|
than maxsize connections per host to prevent flooding.
|
|
:param headers:
|
Headers to include with all requests, unless other headers are given
|
explicitly.
|
|
:param retries:
|
Retry configuration to use by default with requests in this pool.
|
|
:param _proxy:
|
Parsed proxy URL, should not be used directly, instead, see
|
:class:`urllib3.ProxyManager`
|
|
:param _proxy_headers:
|
A dictionary with proxy headers, should not be used directly,
|
instead, see :class:`urllib3.ProxyManager`
|
|
:param \**conn_kw:
|
Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`,
|
:class:`urllib3.connection.HTTPSConnection` instances.
|
Úhttpz4type[BaseHTTPConnection] | type[BaseHTTPSConnection]Ú ConnectionClsNr Fr5 r6 ú_TYPE_TIMEOUT | NoneÚintÚboolú typing.Mapping[str, str] | NoneúRetry | bool | int | Noneú
|
Url | NonezProxyConfig | Noneú
|
typing.Any) r8 r9 r ÚmaxsizeÚblockÚheadersÚretriesÚ_proxyÚ_proxy_headersÚ _proxy_configÚconn_kwc K sà t | ||¡ t | |¡ t|ts.t |¡}|d kr<tj}|| _|| _ |
|
|¡| _ || _ || _ | pfi | _|
|
| _t|D ]} | j d ¡ qxd| _d| _| | _| j rÈ| j dg ¡ | j | jd< | j| jd< | j } t | t| ¡ d S )Nr Úsocket_optionsÚproxyÚ proxy_config)r2 rB r Ú
|
isinstancer( Ú
|
from_floatr$ ÚDEFAULTr re rW Úpoolrc rk Ú proxy_headersrl ÚrangeÚputÚnum_connectionsÚ num_requestsri Ú
|
setdefaultÚweakrefÚfinalizeÚ_close_pool_connections)r? r8 r9 r rb rc rd re rf rg rh ri Ú_rp r@ r@ rA rB ² s0
|
|
|
zHTTPConnectionPool.__init__r/ rC c C sN | j d7 _ t d| j | j| jp$d¡ | jf | j| j| jjd| j}|S )z9
|
Return a fresh :class:`HTTPConnection`.
|
r z(Starting new HTTP connection (%d): %s:%sÚ80)r8 r9 r ) rt ÚlogÚdebugr8 r9 rZ r Úconnect_timeoutri ©r? Úconnr@ r@ rA Ú _new_connï s üýüz HTTPConnectionPool._new_connz float | None)r r: c C s¤ d}| j dkrt| dz| j j| j|d}W nF tk
|
rN t| ddY n( tjk
|
rt | jrpt| ddY nX |rt|rt
|
d| j ¡ | ¡ |p¢| ¡ S )a
|
Get a connection. Will return a pooled connection if one is available.
|
|
If no connections are available and :prop:`.block` is ``False``, then a
|
fresh connection is returned.
|
|
:param timeout:
|
Seconds to wait before giving up and raising
|
:class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and
|
:prop:`.block` is ``True``.
|
NzPool is closed.)rc r zHPool is empty and a new connection can't be opened due to blocking mode.z Resetting dropped connection: %s)rp r Úgetrc ÚAttributeErrorrU ÚEmptyr r r| r} r8 rN r )r? r r r@ r@ rA Ú _get_conn s(
|
|
þý z HTTPConnectionPool._get_connzBaseHTTPConnection | Noner7 ©r r: c C s | j dk r~z| j j|dd W dS tk
|
r4 Y nJ tjk
|
r| |rP| ¡ | jrbt| ddt d| j
|
| j ¡ ¡ Y nX |r| ¡ dS )aä
|
Put a connection back into the pool.
|
|
:param conn:
|
Connection object for the current host and port as returned by
|
:meth:`._new_conn` or :meth:`._get_conn`.
|
|
If the pool is already full, the connection is closed and discarded
|
because we exceeded maxsize. If connections are discarded frequently,
|
then maxsize should be increased.
|
|
If the pool is closed, then the connection will be closed and discarded.
|
NF©rc z>Pool reached maximum size and no more connections are allowed.zLConnection pool is full, discarding connection: %s. Connection pool size: %s) rp rs r rU ÚFullrN rc r r| Úwarningr8 Úqsizer r@ r@ rA Ú _put_conn) s.
|
þýý
|
z HTTPConnectionPool._put_connc C s dS )úU
|
Called right before a request is made, after the socket is created.
|
Nr@ r r@ r@ rA Ú_validate_connT s z!HTTPConnectionPool._validate_connc C s d S rI r@ r r@ r@ rA Ú_prepare_proxyY s z!HTTPConnectionPool._prepare_proxyÚ _TYPE_TIMEOUTr( c C s2 |t kr| j ¡ S t|tr$| ¡ S t |¡S dS )z:Helper that always returns a :class:`urllib3.util.Timeout`N)r& r Úclonerm r( rn )r? r r@ r@ rA Ú _get_timeout] s
|
|
|
z HTTPConnectionPool._get_timeoutz&BaseSSLError | OSError | SocketTimeout)ÚerrÚurlÚ timeout_valuer: c C sN t |tr t| |d| d|t|drJ|jtkrJt| |d| d|dS )zAIs the error actually a timeout? Will raise a ReadTimeout or passú Read timed out. (read timeout=rD ÚerrnoN)rm Ú SocketTimeoutr Úhasattrr Ú_blocking_errnos)r? r r r r@ r@ rA Ú_raise_timeouti s
|
|
ÿþ
|
ÿþz!HTTPConnectionPool._raise_timeoutTz_TYPE_BODY | Nonez Retry | Noner ) r Úmethodr Úbodyrd re r ÚchunkedÚ response_connÚpreload_contentÚdecode_contentÚenforce_content_lengthr: c C s | j d7 _ | |¡} | ¡ t | j¡|_zNz| |¡ W n: tt fk
|
rx } z| j
|
|||jd W 5 d}~X Y nX W n| t t t t ttfk
|
rø } zR|}t|t tfr´t|}t|t t t tfrä|rä|jrä|jsät||jj}|W 5 d}~X Y nX z |j||||||
|
| | d W nH tk
|
r. Y n4 t k
|
r` } z|jtjkrP W 5 d}~X Y nX | j}|js|dkrt| |d| d||_z | ¡ }W n: t t fk
|
rÚ } z| j
|
|||d W 5 d}~X Y nX ||_ | |_ | |_ t !d| j| j"| j#|||j$|j%|j&¡ |S ) a8
|
|
Perform a request on a given urllib connection object taken from our
|
pool.
|
|
:param conn:
|
a connection from one of our connection pools
|
|
:param method:
|
HTTP request method (such as GET, POST, PUT, etc.)
|
|
:param url:
|
The URL to perform the request on.
|
|
:param body:
|
Data to send in the request body, either :class:`str`, :class:`bytes`,
|
an iterable of :class:`str`/:class:`bytes`, or a file-like object.
|
|
:param headers:
|
Dictionary of custom headers to send, such as User-Agent,
|
If-None-Match, etc. If None, pool headers are used. If provided,
|
these headers completely replace any pool-specific headers.
|
|
:param retries:
|
Configure the number of retries to allow before raising a
|
:class:`~urllib3.exceptions.MaxRetryError` exception.
|
|
Pass ``None`` to retry until you receive a response. Pass a
|
:class:`~urllib3.util.retry.Retry` object for fine-grained control
|
over different types of retries.
|
Pass an integer number to retry connection errors that many times,
|
but no other types of errors. Pass zero to never retry.
|
|
If ``False``, then retries are disabled and any exception is raised
|
immediately. Also, instead of raising a MaxRetryError on redirects,
|
the redirect response will be returned.
|
|
:type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
|
|
:param timeout:
|
If specified, overrides the default timeout for this one
|
request. It may be a float (in seconds) or an instance of
|
:class:`urllib3.util.Timeout`.
|
|
:param chunked:
|
If True, urllib3 will send the body using chunked transfer
|
encoding. Otherwise, urllib3 will send the body using the standard
|
content-length form. Defaults to False.
|
|
:param response_conn:
|
Set this to ``None`` if you will handle releasing the connection or
|
set the connection to have the response release it.
|
|
:param preload_content:
|
If True, the response's body will be preloaded during construction.
|
|
:param decode_content:
|
If True, will attempt to decode the body based on the
|
'content-encoding' header.
|
|
:param enforce_content_length:
|
Enforce content length checking. Body returned by server must match
|
value of Content-Length header, if present. Otherwise, raise error.
|
r ©r r r N)r rd r r r r¡ r r rD z%s://%s:%s "%s %s %s" %s %s)'ru r Ú start_connectr( Zresolve_default_timeoutr~ r r r r r ÚOSErrorr r r% r rm rk Úhas_connected_to_proxyr r4 Úrequestr
|
r Z
|
EPROTOTYPEÚ read_timeoutÚ is_closedr Ú getresponsere Ú _connectionÚ_poolr| r} r8 r9 Ú _http_vsn_strÚstatusÚlength_remaining)r? r r r r rd re r r r r r r¡ Ú timeout_objÚeÚnew_er§ Úresponser@ r@ rA Ú _make_request| s N
|
ú
|
ÿþþþø
|
|
|
ÿ ö z HTTPConnectionPool._make_requestc C s( | j dkrdS | j d }| _ t| dS rP )rp ry )r? Úold_poolr@ r@ rA rN 1 s
|
zHTTPConnectionPool.close)r r: c C s | d¡rdS t|^}}}}}|p&d}|dk r<t||d}| jrR|sRt |¡}n| jsj|t |¡krjd}|||f| j| j| jfkS )zj
|
Check if the given ``url`` is a member of the same host as this
|
connection pool.
|
ú/TrY Nr; )Ú
|
startswithr, r+ r9 r r r4 r8 )r? r r4 rz r8 r9 r@ r@ rA Ú is_same_host= s
|
|
z HTTPConnectionPool.is_same_hostz bool | Nonez_TYPE_BODY_POSITION | None)r r r rd re ÚredirectÚassert_same_hostr Ú pool_timeoutÚ release_connr Úbody_posr r Ú response_kwr: c K sb t |}|j}|dkr | j}t|ts8tj||| jd}|
|
dkrD| }
|
|r^| |¡s^t| ||| d¡rvt
|
t |}n
|
t
|
|j }d}|
|
}t | j| j|}|s°| ¡ }| | j¡ d}d}t|| } z¾zÈ| |¡}| j| d}|j|_| jdk rR|rR|jrRz| |¡ W nB t t t fk
|
rP } z | j || jj |jd W 5 d}~X Y nX |
|
s\|nd}| j |||f|||| ||| |d|}d}W nð t!k
|
r® d}d} Y nÒ t"t#t t$t t%t&t'fk
|
r~ } z¢d}|}t|t t&frðt%|}t|t t(t"t%t#fr,|r,|jr,|j)s,t*||jj}nt|t t#frFt$d |}|j+|||| t, -¡ d
|
d }| .¡ |}W 5 d}~X Y nX W 5 |s |r| ¡ d}d}|r°| |¡ X |söt/ 0d |||¡ | j1|||||||f|| |
|
| | | |d |S |o| 2¡ } | r¬|j3dkrd}z|j+|||| d}W n, t4k
|
r\ |j5rT| 6¡ | Y S X | 6¡ | 7|¡ t/ 8d|| ¡ | j1|| ||f||||| |
|
| | | |d
|
|S t9|j :d¡} | ;||j3| ¡r^z|j+|||| d}W n, t4k
|
r |j<r| 6¡ | Y S X | 6¡ | .|¡ t/ 8d|¡ | j1||||f||||| |
|
| | | |d
|
|S |S )ay
|
Get a connection from the pool and perform an HTTP request. This is the
|
lowest level call for making a request, so you'll need to specify all
|
the raw details.
|
|
.. note::
|
|
More commonly, it's appropriate to use a convenience method
|
such as :meth:`request`.
|
|
.. note::
|
|
`release_conn` will only behave as expected if
|
`preload_content=False` because we want to make
|
`preload_content=False` the default behaviour someday soon without
|
breaking backwards compatibility.
|
|
:param method:
|
HTTP request method (such as GET, POST, PUT, etc.)
|
|
:param url:
|
The URL to perform the request on.
|
|
:param body:
|
Data to send in the request body, either :class:`str`, :class:`bytes`,
|
an iterable of :class:`str`/:class:`bytes`, or a file-like object.
|
|
:param headers:
|
Dictionary of custom headers to send, such as User-Agent,
|
If-None-Match, etc. If None, pool headers are used. If provided,
|
these headers completely replace any pool-specific headers.
|
|
:param retries:
|
Configure the number of retries to allow before raising a
|
:class:`~urllib3.exceptions.MaxRetryError` exception.
|
|
Pass ``None`` to retry until you receive a response. Pass a
|
:class:`~urllib3.util.retry.Retry` object for fine-grained control
|
over different types of retries.
|
Pass an integer number to retry connection errors that many times,
|
but no other types of errors. Pass zero to never retry.
|
|
If ``False``, then retries are disabled and any exception is raised
|
immediately. Also, instead of raising a MaxRetryError on redirects,
|
the redirect response will be returned.
|
|
:type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
|
|
:param redirect:
|
If True, automatically handle redirects (status codes 301, 302,
|
303, 307, 308). Each redirect counts as a retry. Disabling retries
|
will disable redirect, too.
|
|
:param assert_same_host:
|
If ``True``, will make sure that the host of the pool requests is
|
consistent else will raise HostChangedError. When ``False``, you can
|
use the pool on an HTTP proxy and request foreign hosts.
|
|
:param timeout:
|
If specified, overrides the default timeout for this one
|
request. It may be a float (in seconds) or an instance of
|
:class:`urllib3.util.Timeout`.
|
|
:param pool_timeout:
|
If set and the pool is set to block=True, then this method will
|
block for ``pool_timeout`` seconds and raise EmptyPoolError if no
|
connection is available within the time period.
|
|
:param bool preload_content:
|
If True, the response's body will be preloaded into memory.
|
|
:param bool decode_content:
|
If True, will attempt to decode the body based on the
|
'content-encoding' header.
|
|
:param release_conn:
|
If False, then the urlopen call will not release the connection
|
back into the pool once a response is received (but will release if
|
you read the entire contents of the response such as when
|
`preload_content=True`). This is useful if you're not preloading
|
the response's content immediately. You will need to call
|
``r.release_conn()`` on the response ``r`` to return the connection
|
back into the pool. If None, it takes the value of ``preload_content``
|
which defaults to ``True``.
|
|
:param bool chunked:
|
If True, urllib3 will send the body using chunked transfer
|
encoding. Otherwise, urllib3 will send the body using the standard
|
content-length form. Defaults to False.
|
|
:param int body_pos:
|
Position to seek to in file-like body in the event of a retry or
|
redirect. Typically this won't need to be set because urllib3 will
|
auto-populate the value when needed.
|
N)r¸ Údefaultrµ FTr r¢ )r r rd r re r r r zConnection aborted.é )Úerrorr« Ú _stacktracez1Retrying (%r) after connection broken by '%r': %s)r rº r» r r¼ r r i/ ÚGET)r² r« zRedirecting %s -> %s)
|
re r¸ r¹ r rº r» r r¼ r r z Retry-Afterz Retry: %s)=r, r4 rd rm r$ Úfrom_intre r· r r¶ r- r* r r! rk rl ÚcopyÚupdaterq r# rN r r r
r~ r r¨ r r r¤ r r r³ r r r r r r% r r r¥ r Ú incrementÚsysÚexc_infoÚsleepr| r ÚurlopenÚget_redirect_locationr r Úraise_on_redirectÚ
|
drain_connÚsleep_for_retryr} r] r Úis_retryÚraise_on_status) r? r r r rd re r¸ r¹ r rº r» r r¼ r r r½ Ú
|
parsed_urlZdestination_schemer Úrelease_this_connZhttp_tunnel_requiredr Ú
|
clean_exitr¯ r° r r² r± Úredirect_locationÚhas_retry_afterr@ r@ rA rÊ S s q
|
|
|
ÿ
|
|
ÿýõ ôø ûþ ÷ ÷ ÷
|
|
|
ÿ ÿùòñ
|
|
üòñ
|
|
üòñzHTTPConnectionPool.urlopen)N)rF rQ rR rS r4 r rZ rT r& rB r r
r r r r r r³ rN r· rÊ r@ r@ r@ rA rX y s^
|
3þ
|
õ$=&+ ó( 6 ñrX c s¼ e Zd ZU dZdZeZded< dedddddddddddddddddfdd d
|
d d d ddd dddddddddddddd fdd Z ddddd Z
|
d d d d Z d!dd fd"d# Z Z S )$ÚHTTPSConnectionPoola
|
Same as :class:`.HTTPConnectionPool`, but HTTPS.
|
|
:class:`.HTTPSConnection` uses one of ``assert_fingerprint``,
|
``assert_hostname`` and ``host`` in this order to verify connections.
|
If ``assert_hostname`` is False, no verification is done.
|
|
The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``,
|
``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl`
|
is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade
|
the connection socket into an SSL socket.
|
Úhttpsztype[BaseHTTPSConnection]rZ Nr Fr5 r6 r[ r\ r] r^ r_ r` r3 zint | str | Nonezssl.TLSVersion | Nonezstr | Literal[False] | Nonera r7 )r8 r9 r rb rc rd re rf rg Úkey_fileÚ cert_fileÚ cert_reqsÚ key_passwordÚca_certsÚ ssl_versionÚssl_minimum_versionÚssl_maximum_versionÚassert_hostnameÚassert_fingerprintÚ ca_cert_dirri r: c
|
sf t j||||||||| f | |
|
| _| | _| | _| | _|| _|| _|| _|| _ || _
|
|| _ || _ d S rI ) ÚsuperrB rØ rÙ rÚ rÛ rÜ râ rÝ rÞ rß rà rá )r? r8 r9 r rb rc rd re rf rg rØ rÙ rÚ rÛ rÜ rÝ rÞ rß rà rá râ ri ©Ú __class__r@ rA rB Ó s0 ÷
|
ö z HTTPSConnectionPool.__init__r r c C s@ | j r| j jdkrd}nd}|j|| j| j| jd | ¡ dS )z5Establishes a tunnel connection through HTTP CONNECT.r× rY )r4 r8 r9 rd N)rk r4 Ú
|
set_tunnelr> r9 rq Úconnect)r? r Z tunnel_schemer@ r@ rA r s üz"HTTPSConnectionPool._prepare_proxyr0 rC c C s¼ | j d7 _ t d| j | j| jp$d¡ | jr8| jtkr@td| j}| j}| jdk rr| jjdk rr| jj}| jj}| jf ||| j j
|
| j | j | j | j| j| j| j| j| j| j| jd| jS )zL
|
Return a fresh :class:`urllib3.connection.HTTPConnection`.
|
r z)Starting new HTTPS connection (%d): %s:%sÚ443zCCan't connect to HTTPS URL because the SSL module is not available.N)r8 r9 r rÙ rØ rÛ rÚ rÜ râ rà rá rÝ rÞ rß )rt r| r} r8 r9 rZ r Ú ImportErrorrk r r~ rÙ rØ rÛ rÚ rÜ râ rà rá rÝ rÞ rß ri )r? Ú actual_hostÚ actual_portr@ r@ rA r sD üÿòñz HTTPSConnectionPool._new_connr/ c s: t |¡ |jr| ¡ |js6t d|j dt¡ dS )r z0Unverified HTTPS request is being made to host 'z'. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#tls-warningsN) rã r r¨ rç Ú is_verifiedÚwarningsÚwarnr8 r r rä r@ rA r < s ùz"HTTPSConnectionPool._validate_conn)rF rQ rR rS r4 r rZ rT r& rB r r r Ú __classcell__r@ r@ rä rA rÖ Â s4
|
ë>1)rÖ r5 ra )r Úkwr: c K s^ t | ^}}}}}|pd}|p(t |d¡}|dkrFt|fd|i|S t|fd|i|S dS )a
|
Given a url, return an :class:`.ConnectionPool` instance of its host.
|
|
This is a shortcut for not having to parse out the scheme, host, and port
|
of the url before creating an :class:`.ConnectionPool` instance.
|
|
:param url:
|
Absolute URL string that must include the scheme. Port is optional.
|
|
:param \**kw:
|
Passes additional parameters to the constructor of the appropriate
|
:class:`.ConnectionPool`. Useful for specifying things like
|
timeout, maxsize, headers, etc.
|
|
Example::
|
|
>>> conn = connection_from_url('http://google.com/')
|
>>> r = conn.request('GET', '/')
|
rY éP r× r9 N)r, r r rÖ rX )r rð r4 rz r8 r9 r@ r@ rA Úconnection_from_urlR s rò r7 r3 )r8 r4 r: c C s d S rI r@ ©r8 r4 r@ r@ rA r+ o s r+ c C s d S rI r@ ró r@ r@ rA r+ t s c C s2 t | |} | r.| d¡r.| d¡r.| dd
} | S )z?
|
Normalize hosts for comparisons and use with sockets.
|
ú[ú]r éÿÿÿÿ)r< r¶ Úendswithró r@ r@ rA r+ y s
|
z(HTTPConnectionPool | HTTPSConnectionPool)rp Úpathr: c C s t | j| j| j|djS )zZReturns the URL from a given connection pool. This is mainly used for testing and logging.)r4 r8 r9 rø )r) r4 r8 r9 r )rp rø r@ r@ rA Ú_url_from_pool s rù zqueue.LifoQueue[typing.Any])rp r: c C s: z | j dd}|r| ¡ qW n tjk
|
r4 Y nX dS )z2Drains a queue of connections and closes each one.Fr N)r rN rU r )rp r r@ r@ rA ry s ry )N)[Ú
|
__future__r r ÚloggingrU rÇ Útypingrí rw Úsocketr r Útypesr Z_base_connectionr Z_request_methodsr Ú
|
connectionr r
|
r r r r r r r Ú
|
exceptionsr r r r r r r r r r r r r r² r Zutil.connectionr Z
|
util.proxyr! Z util.requestr" r# Z
|
util.retryr$ Zutil.ssl_match_hostnamer% Z util.timeoutr& r' r( Zutil.urlr) r* r+ r< r, Z util.utilr- Ú TYPE_CHECKINGÚsslZtyping_extensionsr. r/ r0 Ú getLoggerrF r| ÚUnionÚfloatr ÚTypeVarr1 r2 ÚEAGAINÚ EWOULDBLOCKr rX rÖ rò Úoverloadrù ry r@ r@ r@ rA Ú<module> sh (
|
<
|
|
2 O ÿ
|
