wg-backend-django/dell-env/lib/python3.11/site-packages/urllib3/__pycache__/poolmanager.cpython-311.pyc

<EFBFBD>
s]?efY<00>
<01><00>dd
lm
Z

ddlZddlZddlZddlZddlmZ
ddlm	Z	
ddl
mZmZ
ddl
mZ
ddlmZ
dd	lmZmZmZ
dd
lmZmZmZmZ
ddlmZ
ddlmZ
dd
lmZ
ddl m!Z!
ddl"m#Z#
ddl$m%Z%m&Z&
ej'r
ddl(Z(ddl)m*Z*
gd<12>
Z+ej,e-<2D>
<00>
Z.dZ/dZ0ej1d<15>
<00>
Z2Gd<16>dej3<00><00>Z4d(d<1D>Z5ej6e5e4<65><00>ej6e5e4<65><00>d<1E>Z7eed<1E>Z8Gd<1F>d e<0E><00>Z9Gd!<21>d"e9<65><00>Z:d)d'<27>Z;dS)*<2A>)
<01>annotationsN)
<01>
TracebackType)
<01>urljoin<69>
)<02>HTTPHeaderDict<63>RecentlyUsedContainer)
<01>RequestMethods)
<01>ProxyConfig)<03>HTTPConnectionPool<6F>HTTPSConnectionPool<6F>port_by_scheme)<04>LocationValueError<6F>
MaxRetryError<6F>ProxySchemeUnknown<77>URLSchemeUnknown)
<01>BaseHTTPResponse)
<01>_TYPE_SOCKET_OPTIONS)
<01>connection_requires_http_tunnel)
<01>Retry)
<01>Timeout)<02>Url<72>	parse_url)
<01>Literal)<03>PoolManager<65>ProxyManager<65>proxy_from_url)<0B>key_file<6C>	cert_file<6C>	cert_reqs<71>ca_certs<74>ssl_version<6F>ssl_minimum_version<6F>ssl_maximum_version<6F>ca_cert_dir<69>ssl_context<78>key_password<72>server_hostnamei@<00>_SelfTc
<01>,
<00>eZ
dZUd
Zded<ded<ded<ded<d	ed
<ded<d
ed<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<d ed!<ded"<d#ed$<d%ed&<ded'<d(ed)<ded*<ded+<ded,<d-S).<2E>PoolKeyz<79>
    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.
    <20>str<74>
key_scheme<EFBFBD>key_host<73>
int | None<6E>key_portzTimeout | float | int | None<6E>key_timeoutzRetry | bool | int | None<6E>key_retrieszbool | None<6E>	key_blockztuple[str, int] | None<6E>key_source_address<73>
str | None<6E>key_key_file<6C>key_key_password<72>
key_cert_file<6C>
key_cert_reqs<71>key_ca_certszint | str | None<6E>key_ssl_versionzssl.TLSVersion | None<6E>key_ssl_minimum_version<6F>key_ssl_maximum_version<6F>key_ca_cert_dir<69>ssl.SSLContext | None<6E>key_ssl_context<78>key_maxsizez!frozenset[tuple[str, str]] | None<6E>key_headers<72>
Url | None<6E>
key__proxy<EFBFBD>key__proxy_headers<72>ProxyConfig | None<6E>key__proxy_configz_TYPE_SOCKET_OPTIONS | None<6E>key_socket_options<6E>key__socks_optionszbool | str | None<6E>key_assert_hostname<6D>key_assert_fingerprint<6E>key_server_hostname<6D>
key_blocksizeN)<05>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__<5F>__annotations__<5F><00><00>l/home/infidel/Sync/TIP/WireGuard/ocp-wg-backend/dell-env/lib/python3.11/site-packages/urllib3/poolmanager.pyr*r*9sh
<00><00><00><00><00><00><00><08><08><14>O<EFBFBD>O<EFBFBD>O<EFBFBD><11>M<EFBFBD>M<EFBFBD>M<EFBFBD><18><18><18><18>-<2D>-<2D>-<2D>-<2D>*<2A>*<2A>*<2A>*<2A><1A><1A><1A><1A>.<2E>.<2E>.<2E>.<2E><1C><1C><1C><1C> <20> <20> <20> <20><1D><1D><1D><1D><1D><1D><1D><1D><1C><1C><1C><1C>%<25>%<25>%<25>%<25>2<>2<>2<>2<>2<>2<>2<>2<><1F><1F><1F><1F>*<2A>*<2A>*<2A>*<2A><1B><1B><1B><1B>2<>2<>2<>2<><1A><1A><1A><1A>9<>9<>9<>9<>)<29>)<29>)<29>)<29>3<>3<>3<>3<>9<>9<>9<>9<>*<2A>*<2A>*<2A>*<2A>&<26>&<26>&<26>&<26>#<23>#<23>#<23>#<23><1D><1D><1D><1D><1D>rSr*<00>	key_class<73>
type[PoolKey]<5D>request_context<78>dict[str, typing.Any]<5D>returnc
<01>X<00>|
<01><00><00>}|d
<00>
<00><00>|d
<|d<00>
<00><00>|d<dD]8}||vr2||<00>*t||<00><00><00><00>
<00>
||<<00>9|<02>d<05>
<00>
}|<04>t|<04>
<00>
|d<t
|<02><00><00><00>
<00>
D]}|<02>|<03>
<00>
|d|z<<00>|j	D]}||v
rd||<<00>|<02>d<07>
<00>
<00>
t|d<|di|<02>
<01>
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
    <20>scheme<6D>host)<03>headers<72>_proxy_headers<72>_socks_optionsN<73>socket_options<6E>key_rLrR)<0B>copy<70>lower<65>	frozenset<65>items<6D>get<65>tuple<6C>list<73>keys<79>pop<6F>_fields<64>_DEFAULT_BLOCKSIZE)rUrW<00>context<78>key<65>socket_opts<74>fields      rT<00>_default_key_normalizerrq_sV
<00><00>.<1E>"<22>"<22>$<24>$<24>G<EFBFBD><1F><08>)<29>/<2F>/<2F>1<>1<>G<EFBFBD>H<EFBFBD><15><1D>f<EFBFBD>o<EFBFBD>+<2B>+<2B>-<2D>-<2D>G<EFBFBD>F<EFBFBD>O<EFBFBD>?<3F>;<3B>;<3B><03><0E>'<27>><3E>><3E>g<EFBFBD>c<EFBFBD>l<EFBFBD>6<>$<24>W<EFBFBD>S<EFBFBD>\<5C>%7<>%7<>%9<>%9<>:<3A>:<3A>G<EFBFBD>C<EFBFBD>L<EFBFBD><4C><1A>+<2B>+<2B>.<2E>/<2F>/<2F>K<EFBFBD><12><1E>$)<29>+<2B>$6<>$6<><07> <20>!<21><14>G<EFBFBD>L<EFBFBD>L<EFBFBD>N<EFBFBD>N<EFBFBD>#<23>#<23>
1<>
1<><03> '<27><0B><0B>C<EFBFBD> 0<> 0<><07><06><13><0C><1D><1D><1B>"<22>"<22>"<22><05><10><07><1F><1F>!<21>G<EFBFBD>E<EFBFBD>N<EFBFBD><4E><0F>{<7B>{<7B>?<3F>#<23>#<23>+<2B>#5<><07><0F> <20><14>9<EFBFBD><1F><1F>w<EFBFBD><1F><1F>rS<00><02>http<74>httpsc
<01><><00><00>eZ
dZUd
ZdZded<dZded<		d=d><3E>f
d<10>
Zd?d<13>Zd@d<1B>Z		dAdBd#<23>Z
dCd$<24>Z			dDdEd)<29>ZdFd+<2B>Z
dGd.<2E>Z	dAdHd0<64>ZdId2<64>ZdJd6<64>Z	dKdLd<<3C>Z<12>x
ZS)MraV
    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

    NrB<00>proxyrE<00>proxy_config<69>
<00>	num_pools<6C>intr]<00>typing.Mapping[str, str] | None<6E>connection_pool_kw<6B>
typing.AnyrY<00>Nonec
<01><><00>
<01>t
<00><00><00>
|<02>
<00>

||_|
t|
<01>
<00>
|_t
|_t<00><00><00>|_dS<00>
N)<08>super<65>__init__r|r<00>pools<6C>pool_classes_by_scheme<6D>key_fn_by_schemerb)<05>selfryr]r|<00>	__class__s    <20>rTr<>zPoolManager.__init__<5F>s^<00><><00>	<0E><07><07><18><18><17>!<21>!<21>!<21>"4<><04><1F><0C>F<>*<2A>9<EFBFBD>5<>5<><04>
<EFBFBD>'=<3D><04>#<23> 0<> 5<> 5<> 7<> 7<><04><1D><1D>rSr<>r(c


<01><00>|Sr<>rR<00>
r<>s
 rT<00>	__enter__zPoolManager.__enter__<5F>s<00><00><13>rS<00>exc_type<70>type[BaseException] | None<6E>exc_val<61>BaseException | None<6E>exc_tb<74>TracebackType | None<6E>Literal[False]c
<01>.<00>|<00><00><00>
d
S)NF)
<01>clear)r<>r<>r<>r<>s    rT<00>__exit__zPoolManager.__exit__<5F>s<00><00>	
<0A>
<EFBFBD>
<EFBFBD><0C><0C><0C><14>urSr[r+r\<00>portrW<00>dict[str, typing.Any] | Nonerc
<01>&
<00>|j|
}|<04>|j
<00><00><00>}|<04>d<02>
<00>
<00>
t|d<dD]}|<04>|d
<01><00>
<00>|
dkr tD]}|<04>|d
<01><00>
<00>|||fi|<04>
<01>
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)r[r\r<>rs)r<>r|rbrfrlrj<00>SSL_KEYWORDS)r<>r[r\r<>rW<00>pool_clsrn<00>kws        rT<00>	_new_poolzPoolManager._new_pool<6F>s<><00><00> .2<EFBFBD>-H<><16>-P<><08><1A>"<22>"<22>5<>:<3A>:<3A><<3C><<3C>O<EFBFBD><1B><1E><1E>{<7B>+<2B>+<2B>3<>+=<3D>O<EFBFBD>K<EFBFBD>(<28>.<2E>
	+<2B>
	+<2B>C<EFBFBD><1B><1F><1F><03>T<EFBFBD>*<2A>*<2A>*<2A>*<2A><11>V<EFBFBD><1B><1B>"<22>

.<2E>

.<2E><02><1F>#<23>#<23>B<EFBFBD><04>-<2D>-<2D>-<2D>-<2D><17>x<EFBFBD><04>d<EFBFBD>6<>6<>o<EFBFBD>6<>6<>6rSc

<01>8<00>|j<00>
<00><00>
d
S)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<>r<>r<>s
 rTr<>zPoolManager.clear
s<00><00>	
<0A>
<EFBFBD><18><18><1A><1A><1A><1A>rSrsr4r.<00>pool_kwargsc
<01><><00>|
st
d
<01>
<00>
<00>
|<00>
|<04>
<00>
}|p
d|d<|s-tj|d<00><00><00>d<04><00>}||d<|
|d<|<00>|<05>
<00>
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.rsr[<00>Pr<>r\)r<00>_merge_pool_kwargsr
rfrc<00>connection_from_context)r<>r\r<>r[r<>rWs      rT<00>connection_from_hostz PoolManager.connection_from_host
s<><00><00>"<14>
	;<3B>$<24>%9<>:<3A>:<3A>:<3A><1E>1<>1<>+<2B>><3E>><3E><0F>$*<2A>$4<>f<EFBFBD><0F><08>!<21><13>
	M
<01>!<21>%<25>o<EFBFBD>h<EFBFBD>&?<3F>&E<>&E<>&G<>&G<><12>L<>L<>D<EFBFBD>"&<26><0F><06><1F>"&<26><0F><06><1F><13>+<2B>+<2B>O<EFBFBD><<3C><<3C><rSrXc
<01>6
<00>d
|
vr/t
j
dt<00><00>
|
<01>d
<01>
<00>

|
d<00><00><00>}|j<00>|<02>
<00>
}|st|<02>
<00>
<00>
||
<01>
<00>
}|<00>||
<01><04><00>S)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.
        <20>strictzdThe 'strict' parameter is no longer needed on Python 3+. This will raise an error in urllib3 v2.1.0.r[<00>
rW)	<09>warnings<67>warn<72>DeprecationWarningrjrcr<>rfr<00>connection_from_pool_key)r<>rWr[<00>pool_key_constructor<6F>pool_keys     rTr<>z#PoolManager.connection_from_context1
s<><00><00><14><EFBFBD>&<26>&<26><14>M<EFBFBD>
><3E>"<22>
<0E>
<0E>
<0E>

<1C><1F><1F><08>)<29>)<29>)<29> <20><18>*<2A>0<>0<>2<>2<><06>#<23>4<>8<>8<><16>@<40>@<40><1C>#<23>
	+<2B>"<22>6<EFBFBD>*<2A>*<2A>*<2A>'<27>'<27><0F>8<>8<><08><13>,<2C>,<2C>X<EFBFBD><EFBFBD>,<2C>W<>W<>WrSr<>r*c
<01>
<00>|jj
5
|j<00>|
<01>
<00>
}|r|cd
d
d
<01><00>
S|d}|d}|d}|<00>||||<02><05><00>}||j|
<d
d
d
<01><00>
n#1swxYw

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\r<>r<>)r<><00>lockrfr<>)r<>r<>rW<00>poolr[r\r<>s       rTr<>z$PoolManager.connection_from_pool_keyJ
s<><00><00><12>Z<EFBFBD>_<EFBFBD>	(<28>	(<28><18>:<3A>><3E>><3E>(<28>+<2B>+<2B>D<EFBFBD><13>

<1C><1B>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>%<25>X<EFBFBD>.<2E>F<EFBFBD>"<22>6<EFBFBD>*<2A>D<EFBFBD>"<22>6<EFBFBD>*<2A>D<EFBFBD><17>><3E>><3E>&<26>$<24><04>o<EFBFBD>><3E>V<>V<>D<EFBFBD>#'<27>D<EFBFBD>J<EFBFBD>x<EFBFBD> <20>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28>	(<28><><EFBFBD><EFBFBD>	(<28>	(<28>	(<28>	(<28><14>s<00>A?<03>;A?<03>?B<07>
B<07>urlc
<01>p<00>t
|
<01>
<00>
}|<00>
|j|j|j|<02>
<01><00>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<>r[r<>)rr<>r\r<>r[)r<>r<>r<><00>
us    rT<00>connection_from_urlzPoolManager.connection_from_urld
s;<00><00>
<16>c<EFBFBD>N<EFBFBD>N<EFBFBD>
<01><13>(<28>(<28>
<0A>F<EFBFBD><11><16>
<01><08>k<EFBFBD>)<29>
<EFBFBD>
<EFBFBD>	
rS<00>overridec
<01><><00>|j<00>
<00><00>}|
r6|
<01><00><00>D]!\}}|<04>	||=<00>#t$r
Y<00>wxYw
|||<<00>"|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.
        )r|rbre<00>KeyError)r<>r<><00>base_pool_kwargsrn<00>values     rTr<>zPoolManager._merge_pool_kwargsv
s<><00><00> <20>2<>7<>7<>9<>9<><18><13>	2<>&<26>n<EFBFBD>n<EFBFBD>.<2E>.<2E>
2<>
2<>
<EFBFBD><03>U<EFBFBD><18>=<3D><1D>,<2C>S<EFBFBD>1<>1<><31>#<23>
<1D>
<1D>
<1D><1C><04>
<1D><><EFBFBD><EFBFBD>-2<>$<24>S<EFBFBD>)<29>)<29><1F>s<00><<02>
A	<05>
A	<05>
parsed_urlr<00>boolc
<01>V<00>|j<00>dSt|j|j|
j<00><00>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)rvrrwr[)r<>r<>s  rT<00>!_proxy_requires_url_absolute_formz-PoolManager._proxy_requires_url_absolute_form<72>
s7<00><00><10>:<3A><1D><18>5<EFBFBD>2<><10>J<EFBFBD><04>)<29>:<3A>+<<3C>
<EFBFBD>
<EFBFBD>
<EFBFBD>	
rST<>method<6F>redirectr<74>rc
<01><><00>t
|<02>
<00>
}|j
<00>tjdtd<03><04><00>
|<00>|j|j|j
<00><05><00>}d|d<d|d<d	|v
r
|j|d	<|<00>	|<05>
<00>
r|j
|
|fi|<04>
<01>
}n|j
|
|jfi|<04>
<01>
}|o|<07><00><00>}|s|St||<08><00>}|jd
kr1d}
d
|d<t|d	<00>
<00>
<00><00><00>|d	<|<04>d
<0A>
<00>
}	t%|	t&<00><00>st'j|	|<03><0E><00>}	|	jrp|<06>|<08>
<00>
s[|d	<00><00><00>}
|d	D]3}|<0B><00><00>|	jvr|
<EFBFBD>|d
<01><00>
<00>4|
|d	<	|	<09>|
|||<06><0F><00>}	n.#t6$r!
|	jr|<07><00><00>
<00>|cYSwxYw
|	|d
<||d<t<<00>d||<08><00>
|<07><00><00>
|j
|
|fi|<04>
<01>
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.
        Na	
URLs without a scheme (ie 'https://') are deprecated and will raise an error in a future version of urllib3. To avoid this DeprecationWarning ensure all URLs start with 'https://' or 'http://'. Read more in this issue: https://github.com/urllib3/urllib3/issues/2920<32>)<02>category<72>
stacklevel)r<>r[F<>assert_same_hostr<74>r]i/
<00>GET<45>body<64>retries)
r<>)<02>response<73>_poolzRedirecting %s -> %s) rr[r<>r<>r<>r<>r\r<>r]r<><00>urlopen<65>request_uri<72>get_redirect_locationr<00>statusr<00>_prepare_for_method_changerf<00>
isinstancer<00>from_int<6E>remove_headers_on_redirect<63>is_same_hostrbrcrj<00>	incrementr<00>raise_on_redirect<63>
drain_conn<EFBFBD>log<6F>info)r<>r<>r<>r<>r<>r<><00>connr<6E><00>redirect_locationr<6E><00>new_headers<72>headers            rTr<>zPoolManager.urlopen<65>
s<><00><00>
<16>c<EFBFBD>N<EFBFBD>N<EFBFBD>
<01><0C>8<EFBFBD><1B><14>M<EFBFBD>A
<01>,<2C><1C>

<0E>
<0E>
<0E>
<0E><14>(<28>(<28><11><16>a<EFBFBD>f<EFBFBD>Q<EFBFBD>X<EFBFBD>(<28>N<>N<><04>!&<26><02><1D><1E><1E><02>:<3A><0E><14>B<EFBFBD><1E><1E> <20>L<EFBFBD>B<EFBFBD>y<EFBFBD>M<EFBFBD><0F>1<>1<>!<21>4<>4<>	A
<01>#<23>t<EFBFBD>|<7C>F<EFBFBD>C<EFBFBD>6<>6<>2<EFBFBD>6<>6<>H<EFBFBD>H<EFBFBD>#<23>t<EFBFBD>|<7C>F<EFBFBD>A<EFBFBD>M<EFBFBD>@<40>@<40>R<EFBFBD>@<40>@<40>H<EFBFBD>$<24>I<><18>)G<>)G<>)I<>)I<><19> <20>
	<1C><1B>O<EFBFBD>$<24>C<EFBFBD>):<3A>;<3B>;<3B><19><13>?<3F>c<EFBFBD>!<21>!<21><1A>F<EFBFBD><1D>B<EFBFBD>v<EFBFBD>J<EFBFBD>*<2A>2<EFBFBD>i<EFBFBD>=<3D>9<>9<>T<>T<>V<>V<>B<EFBFBD>y<EFBFBD>M<EFBFBD><14>&<26>&<26><19>#<23>#<23><07><19>'<27>5<EFBFBD>)<29>)<29>
	A
<01><1B>n<EFBFBD>W<EFBFBD>x<EFBFBD>@<40>@<40>@<40>G<EFBFBD>
<13>-<2D>	(<28>d<EFBFBD>6G<36>6G<36><1D>7
<EFBFBD>7
<EFBFBD>	(<28><1D>Y<EFBFBD>-<2D>,<2C>,<2C>.<2E>.<2E>K<EFBFBD><1C>Y<EFBFBD>-<2D>
2<>
2<><06><19><<3C><<3C>><3E>><3E>W<EFBFBD>%G<>G<>G<><1F>O<EFBFBD>O<EFBFBD>F<EFBFBD>D<EFBFBD>1<>1<>1<><31>'<27>B<EFBFBD>y<EFBFBD>M<EFBFBD>	<1C><1D>'<27>'<27><06><03>h<EFBFBD>d<EFBFBD>'<27>S<>S<>G<EFBFBD>G<EFBFBD><47><1C>	<1C>	<1C>	<1C><16>(<28>
<16><18>#<23>#<23>%<25>%<25>%<25><15><1B>O<EFBFBD>O<EFBFBD>O<EFBFBD>		<1C><><EFBFBD><EFBFBD> <20><02>9<EFBFBD>
<0A>!<21><02>:<3A><0E><0B><08><08>'<27><13>.?<3F>@<40>@<40>@<40><10><1B><1B><1D><1D><1D><1B>t<EFBFBD>|<7C>F<EFBFBD>$5<><<3C><<3C><12><<3C><<3C><s<00>	G#<00>#(H<03>

H)rxN)ryrzr]r{r|r}rYr~)r<>r(rYr()r<>r<>r<>r<>r<>r<>rYr<>r<>)
r[r+r\r+r<>rzrWr<>rYr)rYr~<00>NrsN<>
r\r4r<>r.r[r4r<>r<>rYr)rWrXrYr)r<>r*rWrXrYr)r<>r+r<>r<>rYr)r<>r<>rYrX)r<>rrYr<><00>
T<>
r<EFBFBD>r+r<>r+r<>r<>r<>r}rYr)rMrNrOrPrvrQrwr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<><00>
__classcell__<5F>
r<>s
@rTrr<00>s<>
<00><><00><00><00><00><00><00><08><08>B
<1D>E<EFBFBD><1C><1C><1C><1C>'+<2B>L<EFBFBD>+<2B>+<2B>+<2B>+<2B><1C>37<33>8<>8<>8<>8<>8<>8<>8<>"
<14>
<14>
<14>
<14><15><15><15><15>9=<3D>$7<>$7<>$7<>$7<>$7<>L
<1B><1B><1B><1B> <20>#<23>48<34>=<3D>=<3D>=<3D>=<3D>=<3D>:X
<01>X
<01>X
<01>X
<01>2<14><14><14><14>6E
I
<01>
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>$ <20> <20> <20> <20>,
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>7;<3B>P
=<3D>P
=<3D>P
=<3D>P
=<3D>P
=<3D>P
=<3D>P
=<3D>P
=<3D>P
=rSrc
<01>d<00><00>eZ
dZd
Z							d+d,<2C>f
d<18>
Z			d-d.<2E>f
d!<21>
Z	d/d0d$<24>Z	d1d2<64>f
d*<2A>
Z<07>x
ZS)3ra>
    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

    rxNF<4E>	proxy_urlr+ryrzr]r{<00>
proxy_headers<72>proxy_ssl_contextr><00>use_forwarding_for_httpsr<73><00>proxy_assert_hostname<6D>None | str | Literal[False]<5D>proxy_assert_fingerprintr4r|r}rYr~c	
<01><>
<00>
<01>t
|
t<00><00>r|
j<00>d
|
j<00>d|
j<00><00>}
n|
}
t|
<EFBFBD>
<00>
}|jdv
rt
|j<00>
<00>
<00>
|js0tj|jd<04><00>}|<0B>	|<0C><05>
<00>
}||_
|p
i|_||_t||||<08><00>|_|j
|	d<|j|	d<|j|	d<t<00><00>j||fi|	<09>
<01>

dS)	Nz://<2F>
:rrr<>)
r<><00>_proxyr^<00>
_proxy_config)r<>rr[r\r<>rrr
rf<00>_replacervr<>r<>r
rwr<>r<>)r<>r<>ryr]r<>r<>r<>r<>r<>r|<00>
str_proxy_urlrvr<>r<>s             <20>rTr<>zProxyManager.__init__#s+
<00><><00><16>i<EFBFBD>!3<>4<>4<>	&<26>(<28>/<2F>U<>U<>I<EFBFBD>N<EFBFBD>U<>U<>Y<EFBFBD>^<5E>U<>U<>M<EFBFBD>M<EFBFBD>%<25>M<EFBFBD><19>-<2D>(<28>(<28><05><10><<3C>0<>0<>0<>$<24>U<EFBFBD>\<5C>2<>2<>2<><14>z<EFBFBD>	.<2E>!<21>%<25>e<EFBFBD>l<EFBFBD>B<EFBFBD>7<>7<>D<EFBFBD><19>N<EFBFBD>N<EFBFBD><04>N<EFBFBD>-<2D>-<2D>E<EFBFBD><1A><04>
<EFBFBD>*<2A>0<>b<EFBFBD><04><1A>!2<><04><1E>'<27><1D>$<24>!<21>$<24>	
<EFBFBD>
<EFBFBD><04><19>(,<2C>z<EFBFBD><1A>8<EFBFBD>$<24>/3<>/A<><1A>+<2B>,<2C>.2<EFBFBD>.?<3F><1A>?<3F>+<2B><18><05><07><07><18><19>G<EFBFBD>B<>B<>/A<>B<>B<>B<>B<>BrSrsr\r<>r.r[r<>r<>rc
<01><><00>
<01>|d
kr%t
<00><00><00>
|
|||<04><02><00>St
<00><00><00>
|jj|jj|jj|<04><02><00>S)Nrt)
r<>)r<>r<>rvr\r<>r[)r<>r\r<>r[r<>r<>s     <20>rTr<>z!ProxyManager.connection_from_hostLss<00><><00><12>W<EFBFBD><1C><1C><18>7<EFBFBD>7<EFBFBD>/<2F>/<2F><14>d<EFBFBD>F<EFBFBD><0B>0<><0E><0E>
<0E><15>w<EFBFBD>w<EFBFBD>+<2B>+<2B><10>J<EFBFBD>O<EFBFBD>T<EFBFBD>Z<EFBFBD>_<EFBFBD>d<EFBFBD>j<EFBFBD>.?<3F>[<5B>,<2C>
<EFBFBD>
<EFBFBD>	
rSr<><00>typing.Mapping[str, str]c
<01>r<00>d
di
}t
|
<01>
<00>
j
}|r||d<|r|<03>|<02>
<00>

|S)z<>
        Sets headers needed by proxies: specifically, the Accept and Host
        headers. Only sets headers not provided by the user.
        <20>Acceptz*/*<2A>Host)r<00>netloc<6F>update)r<>r<>r]<00>headers_r<5F>s     rT<00>_set_proxy_headerszProxyManager._set_proxy_headers\sM<00><00><1D>e<EFBFBD>$<24><08><1A>3<EFBFBD><1E><1E>&<26><06><11>
	&<26>%<25>H<EFBFBD>V<EFBFBD><1C><12>
	%<25><14>O<EFBFBD>O<EFBFBD>G<EFBFBD>$<24>$<24>$<24><17>rSTr<54>r<>r<>rc
<01>
<00>
<01>t
|<02>
<00>
}t|j|j|j<00><00>s4|<04>d
|j<00><00>}|<00>||<06><00>|d
<t<00><00>j	|
|fd|i
|<04>
<01>
S)z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.r]r<>)
rrrvrwr[rfr]r<>r<>r<>)r<>r<>r<>r<>r<>r<>r]r<>s       <20>rTr<>zProxyManager.urlopenms<><00><><00>
<16>c<EFBFBD>N<EFBFBD>N<EFBFBD>
<01>.<2E>t<EFBFBD>z<EFBFBD>4<EFBFBD>;L<>a<EFBFBD>h<EFBFBD>W<>W<>	B
<01><19>f<EFBFBD>f<EFBFBD>Y<EFBFBD><04><0C>5<>5<>G<EFBFBD> <20>3<>3<>C<EFBFBD><17>A<>A<>B<EFBFBD>y<EFBFBD>M<EFBFBD><1E>u<EFBFBD>w<EFBFBD>w<EFBFBD><EFBFBD>v<EFBFBD>s<EFBFBD>D<>D<>X<EFBFBD>D<><12>D<>D<>DrS)rxNNNFNN)r<>r+ryrzr]r{r<>r{r<>r>r<>r<>r<>r<>r<>r4r|r}rYr~r<>r<>r<>)r<>r+r]r{rYr<>r<>r<>)	rMrNrOrPr<>r<>r<>r<>r<>r<>s
@rTrr<00>
s<><00><><00><00><00><00><00>4<08>4<08>r
<1C>37<33>9=<3D>37<33>).<2E>=A<>/3<>'C
<01>'C
<01>'C
<01>'C
<01>'C
<01>'C
<01>'C
<01>X
 <20>#<23>48<34>
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>
<EFBFBD>"D
H
<01><18><18><18><18><18>$7;<3B>E
<01>E
<01>E
<01>E
<01>E
<01>E
<01>E
<01>E
<01>E
<01>E
<01>E
rSrr<>r+r<>r}c

<01><00>t
dd
|i
|
<01>
<01>
S)Nr<4E>rR)
r)r<>r<>s  rTrr|s<00><00><17>,<2C>,<2C>#<23>,<2C><12>,<2C>,<2C>,rS)rUrVrWrXrYr*)r<>r+r<>r}rYr)<<3C>
__future__r<00>	functools<6C>logging<6E>typingr<67><00>typesr<00>urllib.parser<00>_collectionsrr<00>_request_methodsr	<00>
connectionr
<00>connectionpoolrrr
<00>
exceptionsrrrrr<>r<00>util.connectionr<00>
util.proxyr<00>
util.retryr<00>util.timeoutr<00>util.urlrr<00>
TYPE_CHECKING<4E>ssl<73>typing_extensionsr<00>__all__<5F>	getLoggerrMr<>r<>rl<00>TypeVarr(<00>
NamedTupler*rq<00>partialr<6C>r<>rrrrRrSrT<00><module>r

s<><00>


<01>"<22>"<22>"<22>"<22>"<22>"<22><10><10><10><10><0E><0E><0E><0E>
<0A>
<0A>
<0A>
<0A><0F><0F><0F><0F><1F><1F><1F><1F><1F><1F> <20> <20> <20> <20> <20> <20>?<3F>?<3F>?<3F>?<3F>?<3F>?<3F>?<3F>?<3F>,<2C>,<2C>,<2C>,<2C>,<2C>,<2C>#<23>#<23>#<23>#<23>#<23>#<23>S<>S<>S<>S<>S<>S<>S<>S<>S<>S<>
<02>
<02>
<02>
<02>
<02>
<02>
<02>
<02>
<02>
<02>
<02>
<02>
'<27>&<26>&<26>&<26>&<26>&<26>1<>1<>1<>1<>1<>1<>7<>7<>7<>7<>7<>7<><1D><1D><1D><1D><1D><1D>!<21>!<21>!<21>!<21>!<21>!<21>$<24>$<24>$<24>$<24>$<24>$<24>$<24>$<24>	<09><17>
*<2A><0E>J<EFBFBD>J<EFBFBD>J<EFBFBD>)<29>)<29>)<29>)<29>)<29>)<29>
;<3B>
;<3B>
;<3B><07><18>g<EFBFBD><17><08>!<21>!<21><03><02><0C><1B><12>	<17><16><1E><08>	!<21>	!<21><06>#
<1E>#
<1E>#
<1E>#
<1E>#
<1E>f<EFBFBD><1F>#
<1E>#
<1E>#
<1E>L
4
 <20>4
 <20>4
 <20>4
 <20>x

<1E>I<EFBFBD><1D>5<>w<EFBFBD>?<3F>?<3F>
<1E>Y<EFBFBD>
<1E>6<><07>
@<40>
@<40><02><02><10>
#5<>?R<>S<>S<><16>G
=<3D>G
=<3D>G
=<3D>G
=<3D>G
=<3D>.<2E>G
=<3D>G
=<3D>G
=<3D>T
M
E
<01>M
E
<01>M
E
<01>M
E
<01>M
E
<01>;<3B>M
E
<01>M
E
<01>M
E
<01>`

-<2D>

-<2D>

-<2D>

-<2D>

-<2D>

-rS